数组

数组

一维数组

1. 一维数组的声明与初始化

int num;//声明
num = 10;//初始化
int id = 1001;//声明+初始化

int[] ids;//声明
//1.1静态初始化：数组的初始化和数组元素的赋值操作同时进行
ids = new int[]{1001,1002,1003,1004}
//1.2动态初始化：数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];
int[] arr4 = {1,2,3,4,5};//类型推断

2. 一维数组的引用：通过角标的方式调用（角标或索引从0开始的，到数组长度-1结束。）
3. 数组的属性：length。说明：数组一旦初始化，其长度就是确定的。arr.length 数组长度一旦确定，就不可修改
4. 一维数组的遍历
5. 数组元素的默认初始化值：

   整型：0
   浮点型：0.0
   char型：0或'\u0000'而非'0'
   boolean型：false
   引用数据类型: null

二维数组

1. 如何理解二维数组？ 数组属于引用数据类型，数组的元素也可以是引用数据类型，一个一维数组A的元素如果还是一个一维数组类型的，则，此数组A称为二维数组。

//一维数组
int[] arr = new int[]{1,2,3};
//静态初始化
int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
//动态初始化1
/*
	动态初始化格式：数据类型[][] 变量名 = new 数据类型[m][n];
	m表示这是一个二维数组，可以存放多少个一维数组
	n表示这是一个一维数组，可以存放多少个数组


*/
String[][] arr2 = new String[3][2];
//动态初始化2
String[][] arr3 = new String[3][];
//其他写法：
int[] arr4[] = new int[][]{{1,2,3},{4,5,8,10},{6,7,3}};
int[] arr5[]={{1,2,3},{4,5},{6,7,8}};

数组中常见的算法

//杨辉三角（二维数组）
//1.声明并初始化二维数组
int[][] yangHui = new int[10][];
//2.给数组的元素赋值
for(int i = 0;i<yangHui.length;i++){
	yangHui[i] = new int[i+1];
	//2.1给首末元素赋值
	yangHui[i][0] = yangHui[i][i] = 1;
	//2.2给每行的非首末元素赋值
	//if(i>1){
		for(int j = 1;j<yangHui[i].length-1;j++){
			yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
		}
	//}
	//3.遍历二维数组
	for(int i = 0;i<yangHui.length;i++){
		for(int j = 0;j<yangHui[i].length;j++){
			System.out.println(yangHui[i][j]+" ");
		}
		System.out.println();
	}
}

//二分查找
//前提：所要查找的数组必须有序
int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};

int dest1 = -34;//所需要查找的数
int head = 0;//初始的首索引
int end = arr2.length-1;//初始的末索引
boolean isFlag1 = true;//定义是否查找到的标记
while(head<=end){
	int middle = (head + end)/2;
	if(dest1 == arr2[middle]){
	System.out.println("找到了指定元素：位置为："+middle);
	isFlag1 = false;
	break;
	}else if(arr2[middle]>dest1){
		end = middle-1;
	}else{
		head = middle+1;
	}
	if(isFlag1=true){
		System.out.println("很遗憾，没有找到");
	}
}

• 数组中涉及到的常见的排序算法：
  • 十大内部排序算法
    1. 选择排序（直接选择排序、堆排序）
    2. 交换排序（冒泡排序、快速排序）
    3. 插入排序（直接插入排序、折半插入排序、Shell排序）
    4. 归并排序
    5. 桶式排序
    6. 基数排序

//冒泡排序
//排序思想：
//1.比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个
//2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数
//3.针对所有的元素重复以上的步骤，除了最后一个。
//4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较为止
public class BubbleSortTest{
	public static void main(String arg[]){
		int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
		//冒泡排序
		for(int i = 0;i<arr.length-1;i++){
			for(int j = 0;j<arr.length-1-i;j++){
				if(arr[j]>arr[j+1]){
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1]=temp;
				}
			}
		}
	}
}

//快速排序---时间复杂度O(nlog(n))
//排序思想：
//1.从数列中挑出一个元素，称为“基准”（pivot）
//2.重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
//3.递归地（recursive）把小于基准值元素地子数列和大于基准值元素地子数列排序。
//4.递归地最底部情形，是数列地大小是0或1，也就是永远都已经被排序好了。虽然一直递归下去，但这个算法总会结束，因为在每次迭代（iteration）中，它至少会把一个元素摆到它最后地位置去。
//核心代码：
private static void subSort(innt[] data,int start,int end){
	if(start<end){
		int base = data[start];//把基准设置为第一个元素
		int low = start;//low指向第一个元素
		int high = end+1;//high指向最后一个元素
		while(true){
			while(low<end&&data[++low]-base<=0)
			；
			while(high>start&&data[--high]-base>=0)
			;
			if(low<high){
				swap(data,low,high);
			}else{
				break;
			}
		}
		swap(data,start,high);
		subSort(data,start,high-1);//递归调用
		subSort(data,high+1,end);
	}
}