数组是什么？
### 一、[一维数组](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 运用
- 数组名表示什么？
- arr[0]表示什么？
- 怎么获取数组长度？
- 如何使用数组下标取值？
- 如何输出数组中所有的元素？
- 如何给数组中所有元素求和？
- 如何找出数组中最大值，最小值？
- 如何判断数组中是否包含某一个值？
- 如何去除数组中的重复元素？
- 如何求两个数组元素的交集与并集？
- 如何判断两个数组是包含的元素值都相同？
练习：
一个班有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];
}
}