java5 - 数组与排序算法

数组是什么？

---

### 一、[一维数组](http://baike.baidu.com/item/%E4%B8%80%E7%BB%B4%E6%95%B0%E7%BB%84?sefr=cr)

1 声明与定义的区别

一般的情况下我们常常这样叙述，
把建立空间的声明称之为"定义",
而把不需要建立存储空间称之为"声明".

很明显我们在这里指的声明是范围比较窄的，
也就是说非定义性质的声明。

	// 1、声明
	int a[];
	int[] b;

	// 2、定义
	a = new int[5];
	b = new int[5];	

	// 3、赋值
	a[0] = 1;
	a[1] = 2;
	a[2] = 3;
	a[3] = 4;
	a[4] = 5;

	// 4、定义
	int[] a = new int[10];
	int a[] = new int[10];

	// 5、定义并初始化
	int[] a = {1,2,3,4};
	int[] a = new int[]{1,2,3,4};

1.2 运用

1. 数组名表示什么？
2. arr[0]表示什么？
3. 怎么获取数组长度？
4. 如何使用数组下标取值？
5. 如何输出数组中所有的元素？
6. 如何给数组中所有元素求和？
7. 如何找出数组中最大值，最小值？
8. 如何判断数组中是否包含某一个值？
9. 如何去除数组中的重复元素？
10. 如何求两个数组元素的交集与并集？
11. 如何判断两个数组是包含的元素值都相同？

练习：

一个班有10个同学的数学成绩需要记录，
要计算班级
总成绩，
平均成绩，
最高分，
最低分，
及格人数等数据。

二、二维数组

2.1 二维数组其实就是矩阵。

2.2 声明、定义与初始化

	// 声明
	int a[][];
	int[][] b;

	// 第一次给一个声明的变量赋值叫做初始化
	a = new int[][]{{1,1,1},{2,2,2}}; 

	// 定义
	int c[][] = {{1,1,1},{2,2,2}};

	int[][] d = {{1,1,1},{2,2,2}};

2.3 运用

练习1

//	某校幼儿园有3个班，每个班有5个人，计算各班平均年龄？计算全园平均年龄？计算总人数？

	int students[][] = { { 3, 6, 4, 5, 4 }, { 2, 3, 5, 3, 2 }, { 3, 4, 6, 2, 4 } };
	int[][] students = { { 3, 6, 4, 5, 4 }, { 2, 3, 5, 3, 2 }, { 3, 4, 6, 2, 4 } };

练习2

1. 打印出杨辉三角？

---

### 三、数组排序

3.1、选择排序

	int[] array1 = { 2, 3, 1, 5, 4 };
	// 控制遍历的次数
	for (int i = 0; i < array1.length - 1; i++) {
		// int min = array1[i]; // 默认最小值
		int minIndex = i; // 记录最小值的下标
		// 找出最小值
		for (int j = i + 1; j < array1.length; j++) {
			if (array1[j] < array1[minIndex]) {
				minIndex = j;
			}
		}
		// 如果最小值不在最前面，和最前面做交换
		if (minIndex != i) {
			int temp = array1[i];
			array1[i] = array1[minIndex];
			array1[minIndex] = temp;
		}
	}
	// 输出
	System.out.println("选择排序之后：");
	for (int i = 0; i < array1.length; i++) {
		System.out.println("array1[" + i + "] = " + array1[i]);
	}

3.2、冒泡排序

	int array3[] = { 1, 3, 4, 6, 2, 11, 19, 2, 7, 0 };
	// 控制遍历次数
	for (int i = 0; i < array3.length - 1; i++) {
		// 控制比较交换
		for (int j = 0; j < array3.length - i - 1; j++) {
			// 控制交换条件
			if (array3[j] > array3[j + 1]) {
				int temp = array3[j];
				array3[j] = array3[j + 1];
				array3[j + 1] = temp;
			}
			System.out.print("array3 第" + (i + 1) + "次冒泡,第" + (j + 1) + "比较结束：");
			for (int i1 = 0; i1 < array3.length; i1++) {
				System.out.print("," + array3[i1]);
			}
			System.out.println("");
		}
		System.out.print("array3 第" + (i + 1) + "次冒泡结束：");
		for (int i1 = 0; i1 < array3.length; i1++) {
			System.out.print("," + array3[i1]);
		}
		System.out.println("");
	}
	System.out.println("array3 冒泡排序之后：");
	for (int i = 0; i < array3.length; i++) {
		System.out.println("array3[" + i + "] = " + array3[i]);
	}

3.3、直接插入排序

	int array6[] = { 3, 4, 2, 1, 5, 6, 9, 8, 7, 0 };
	/**
	 * 2 2,3,4
	 */
	for (int i = 1; i < array6.length; i++) {
		int j = i; // 2, i = 2 ; j = 2
		int temp = array6[i];
		while (j > 0 && temp < array6[j - 1]) {
			array6[j] = array6[j - 1]; // array6[2] = array6[1];
			j--;
		}
		System.out.println("第" + i + "次移动后：");
		for (int i1 = 0; i1 < array6.length; i1++) {
			System.out.print("," + array6[i1]);
		}
		System.out.println();
		array6[j] = temp;
	}
	System.out.println("array6 直接插入排序之后：");
	for (int i = 0; i < array6.length; i++) {
		System.out.println("array6[" + i + "] = " + array6[i]);
	}

3.4、阶乘

	/**
	 * 1！	= 1
	 * 2！	= 2 x 1	 			= 2 x 1！
	 * 3! 	= 3 x 2 x 1	 		= 3 x 2!
	 * 4! 	= 4 x 3 x 2 x 1 	= 4 x 3!
	 * ......
	 */	static int Factorial(int n) {
		// return n*(n-1)!
		if (n < 1) {
			return 0;
		}
		if (n == 1) {
			return 1;
		} else {
			return n * Factorial(n - 1);
		}
	}

3.5、归并排序

	static void MSort(int[] arr, int left, int right) {
		int mid = (left + right) / 2;
		if (left < right) {
			// 递归拆分左边
			MSort(arr, left, mid);
			// 递归拆分右边
			MSort(arr, mid + 1, right);
			// 将拆分的有序数组排序
			Merge(arr, left, mid, right);
		}
	}

	static void Merge(int[] arr, int left, int mid, int right) {
		int[] temp = new int[right - left + 1];
		int low1 = left; // 左边数组的起始位置
		int low2 = mid + 1; // 右边数组的起始位置
		int index = 0;
		// 比较拆分的两个子数组，依次取最小值，放入新数组
		while (low1 <= mid && low2 <= right) {
			if (arr[low1] <= arr[low2]) {
				temp[index++] = arr[low1++];
			} else {
				temp[index++] = arr[low2++];
			}
		}
		// 把左边剩余的装进新数组
		while (low1 <= mid) {
			temp[index++] = arr[low1++];
		}
		// 把右边剩余的装进新数组
		while (low2 <= right) {
			temp[index++] = arr[low2++];
		}
		//把新数组里面的有序元素数，装进原数组
		for (int i = 0; i < temp.length; i++) {
			arr[i + left] = temp[i];
		}
	}