数组最常见的操作（排序）

/*
对数组操作最基本的动作就是存和取。
核心思想：就是对角标的操作
*/

数组最常见的操作
1.遍历
2.获取最值（最大值，最小值）
/*
思路：
2-1.需要进行比较，并定义变量记录住每次比较后较大的值
2-2.对数组中的元素进行遍历取出和变量中记录的元素进行比较，如果遍历到的元素大于变量中记录的元素，就用变量记录住该较大的值。
2-3.遍历结束，该变量记录的就是最大值

定义一个功能来实现
明确一， 结果。
是数组中的元素，类型为int
明确二，未知内容
数组
*/

package array;

public class ArrayDemo {
	public static void main(String[] args) {
		int [] arr= {3,6,9,40};
	//	int max =getMax(arr);
	int max = getMax_2(arr);
		System.out.println(max);
	}

	public static int getMax(int[] arr) {
		int max = arr[0];
		for (int i = 1; i < arr.length; i++) {
			if (arr[i] > max)
				max = arr[i];
		}
		return max;
	}
	public static int getMax_2(int[] arr) {
		int maxindex = 0;
		for (int i = 1; i < arr.length; i++) {
			if (arr[i] >arr[maxindex] )
				maxindex = i;
		}
		return arr[maxindex];
	}
}

3.排序（选择排序，冒泡排序）
先拿0角标的数值跟后面的角标的数值比较，最终比较出来最小的值，放在0角标上，在那1角标的数值跟后面的比，以此类推，（外循环控制次数（列）角标5的值和角标5的值比较没有意义，所以，外循环<arr.length-1）

package array;
/*
 * 选择排序，，，从小到大排序
 * */
public class SelectSort {
	public static void main(String[] args) {
		int[] arr = {12,56,19,33,45,66};
		selectSort(arr);
		systemArray(arr);	
	}
	
public static void selectSort(int []arr) {
	for (int x = 0; x <arr.length-1 ; x++) {
		for (int y = x+1; y < arr.length; y++) {
			if (arr[x]>arr[y]) {
				int temp =arr[x];
				arr[x]=arr[y];
				arr[y]=temp;
			}
		}
	}
}

public static void systemArray(int []arr) {
	System.out.print("[");
	for (int j = 0; j < arr.length; j++) {
		if (j!=arr.length-1) {
			System.out.print(arr[j]+",");
			}else {
				System.out.print(arr[j]+"]");
			}
	}
}
}

冒泡排序：

冒泡排序，在第一次循环的时候，最大值会被排出来，所以在第二次循环的时候，最后的角标上的数，就不用参与排序了。外循环中如果循环到最后一个元素了，就没有相邻数据了，所以arr.length-1(x=0时，确定5角标的数，x=1时，确定4角标的数，以此类推当X=4的时候，1角标的数，就确定下来了。0角标的数不需要和其他数比较了。)，内循环arr.length-1-x;一:是为了避免角标越界,二：是为了当外循环增加一次的时候，内循环参与比较的参数个数递减

还有另一种写法，定义变量记录数，和该数的角标

public static void selectSort_2(int[] arr) {
	for (int x = 0; x < arr.length-1; x++) {
		//定义一个变量记录住比较数
		int num = arr[x];
		//定义一个变量记录角标
		int index = x;
		for (int y = 0; y < arr.length; y++) {
			if (num > arr[y]) {
				//如果角标值大于小于记录的值，就讲角标值赋给num
				num = arr[y];
				//将角标赋值给index
				index = y;
			}
		}
		if (index!=x) {
			//换位置
			BubbleSort.app(arr, x, index);
		}
	}
}

4.折半查找（二分查找）
在说二分查找之前，先说一个数组基本查找一个数的方法，如下图
如果找到了，返回该数的角标，没找到返回-1

二分法的表现：

例子：

package array;

public class HalfSearchArray {
	public static void main(String[] args) {
		int[] arr = { 15, 16, 17, 18, 19, 20, 25, 160, 170, 180 };
		int halfSearch = halfSearch(arr, 25);
		System.out.println("halfSearch" + halfSearch);
	}

	public static int halfSearch(int[] arr, int key) {
		int max = arr.length - 1;
		int min = 0;
		int mid = (min + max) / 2;
		while (arr[mid] != key) {
			if (key > arr[mid]) {
				min = mid + 1;
			} else if (key < arr[mid]) {
				max = mid - 1;

			}
			if (max < min) {
				return -1;
			}
			mid = (max + min) / 2;
		}
		return mid;
	}
}

二分法的另一种表现形式：

/*
面试题：
给定一个有序的数组，如果在该数组中储存一个元素，并保证这个数组还是有序的，那么这个元素的储存的角标如何获取。
int[] arr = { 15, 16, 17, 18, 19, 20, 25, 160, 170, 180 };
思考：对有序的数组进行查找，首先想到二分法，
返回值不在返回-1，直接返回min
在真实的开发中 用binarySearch方法，这个方法就是如果你查找的数存在，返回该数的角标，如果该数不存在则返回 -插入点-1
*/

package array;

public class HalfSearchArray {
	public static void main(String[] args) {
		int[] arr = { 15, 16, 17, 18, 19, 20, 25, 160, 170, 180 };
		int halfSearch = halfSearch(arr, 50);
		System.out.println("halfSearch" + halfSearch);
	}

    public static int halfSearch_2(int[] arr, int key) {
    		int max = arr.length - 1;
    		int min = 0;
    		int mid;
    		while (min <= max) {
    			mid = (min + max) >> 1;
    			if (key > arr[mid]) {
    				min = mid + 1;
    			} else if (key < arr[mid]) {
    				max = mid - 1;
    			} else {
    				return mid;
    			}
    		}
    		return min;
    	}
}