java学习第七日：数组与排序及查找

Java要求一个项目通过分包的方式来管理项目
好处：1.有利于代码的管理和维护以及开发
2.防止名称的冲突
定义方法：package 包名称； //有效代码的第一行
行业规范：使用自己公司的域名倒着写!!
例如：com.baidu.项目名称.功能模块的名称

数组

1.数组:编程中遇到了大量数据的时候，使用传统的变量定义来保存数据，非常困难，所以使用容器来解决问题：数组，栈，链表，…….数组是一种特殊的容器，因为数组的定义是：数组是一种连续的内存空间的分配。
2.数组的优点：是连续的内存空间的分配

• 缺点：
  • 数组一但确定长度就得确定,这是数组的一个缺点，对于添加、插入、删除操作非常不友好,很麻烦;
  • 没有特定的方法获得数组中元素的个数，length这个属性不够。

Java如何定义数组

• 一维数组

1.数据类型[ ] 变量名称 = new 数据类型[ 大小]；

int []grade = new int[10];  //定义数组

2.数据类型[ ] 变量名称 = new 数据类型[ ]{元素1，元素2……. }，大小由元素的数量决定
输出数组所有内容

int []grade = new int[]{1,2，3,4，5};//定义数组
		for(int i=0;i<grade.length;i++) {
		 // ".length"表示数组的长度
			System.out.print(grade[i]);
		}

可用遍历方法输出：

int []grade = new int[]{1,2，3,4，5};//定义数组
		for(int i : grade) {
			System.out.print(grade[i]);
		}

3.（不常用）数据类型[ ] 变量名称 = {元素1，元素2……. }

double[] prices ={6,7，8,9};

• 二维数组

1. 数据类型[ ][ ] 变量名称 = new 数据类型[ 大小][大小 ]；

int[][] grade = new int[3][4];
 for(int i=0;i<grade.length;i++){
 System.out.print(grade[i][j]); 
}

排序

排序是程序，最多一种算法

1. 冒泡排序 ：两两比较，找到最大和最小,比较输出最大数 极限状态（需要比较的最多次数）下需要比较n-1次.

大数上浮法排序（找最大数）：

int []arr = new int[]{1,2，3,4，5};
public static void bubble(int[] arr) {
		// 控制的每一次找到一个最大数
		for (int i = 0; i < arr.length - 1; i++) {
		// 第二次循环需要把之前比过的减去，所以会再减一个i
			for (int j = 0; j < arr.length - 1 - i; j++) {
				if (arr[j] > arr[j+1]) {
				  //传参
					swap(arr, j, j+1);
				}
			}
		}
	}
	public static void swap(int[] grade,int i,int j){
	int temp = grade[i];
    grade[i] = grade[j];
	grade[j] = temp;
	}

小数下沉法（找最小数）：

public static void bubbleSort02(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = arr.length - 1; j > i; j--) {
				if (arr[j] < arr[j - 1]) {
					swap(arr, j, j - 1);
				}
			}
		}
	}
	private static void swap(int[] arr, int i, int j) {
		arr[i] = arr[i] + arr[j];
		arr[j] = arr[i] - arr[j];
		arr[i] = arr[i] - arr[j];
	}
}

2. .选择排序：
   每次找到最小值，将它交换到对应位置（第一位）

int []arr = new int[]{1,2，3,4，5};
public static void selectSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			int min = i;//定义为最小
			for (int j = i; j < arr.length; j++) {
				if (arr[min] > arr[j]) {
					min = j; //值交换
				}
			}
			if (min != i) {
				swap(arr, i, min);
			}
		}
	}

选择排序变种：

public static void selectSort02(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = i; j < arr.length; j++) {
				if (arr[i] > arr[j]) {
					swap(arr, i, j);
				}
			}
		}
	}

3.插入排序：
默认第一个是有序的，第二个开始，像有序进行插入。
就像扑克牌一样，我们抽出一张牌和之前的牌进行比较，比之前的小就放在比他大的那张牌前面，以此类推不断抽取，直到从小到大排完。

	int []arr = new int[]{1,2，3,4，5};
	public static void insertSort(int[] arr) {
		for (int i = 1; i < arr.length; i++) {
		//令j=i，和之前的元素进行比较，且j自减要大于0防止溢出
			for (int j = i; j > 0 && arr[j] < arr[j - 1] ; j--) {
				swap(arr, j, j - 1);
			}
		}
	}
	private static void swap(int[] arr, int i, int j) {
		arr[i] = arr[i] + arr[j];
		arr[j] = arr[i] - arr[j];
		arr[i] = arr[i] - arr[j];
	}
}

4.用Arrays.sort方法进行排序：
java.util.Arrays;

int []arr = new int[]{1,2，3,4，5};
Arrays.sort(arr);
for(int i: arr){
   System.out.print(i+",");
}

查找

1.使用Arrays.binarySearch方法查询

int index = Arrays.binarySearch（arr,8);//8指的是数组下标
System.out.print(index);

2.如果查询是无序数据，效率非常低，只能遍历查询所有值。

// 线性查找，但是效率较低
	public static int linearSearch(int[] arr, int key) {
		for (int i = 0; i < arr.length; i++) {
			if (key == arr[i]) {
				return i;
			}
		}
		return -1;
	}

3.二分查找，又称折半查找，讲一个数组内容分为两半，确定查找的内容在哪一半后在进行折半，在进行大概范围确定，直到找到改元素为止。

	public static int binarySearch(int[] arr, int key) {
		int start = 0;
		int end = arr.length - 1;
		
		while (start <= end) {
			// 注意，需要将中间值的下标重新计算
			int middle = (start + end) / 2;
			if (arr[middle] > key) {
				end = middle - 1;
			} else if (arr[middle] < key) {
				start = middle + 1;
			} else {
				return middle;
			}
		}
		return -1;
	}