排序法总结

冒泡排序法：

1、比较相邻的元素。如果第二个比第一个小，就交换他们两个。
2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。完成一次循环之后，最后面的数就是找到的最大的数，循环可以不再比较。
3、针对所有的元素重复以上的步骤，除了最后一个。
4、循环至所有元素都不需要改变顺序。

```java
public class Sort {
    public static void main(String[] args) {
        //冒泡排序
        int[] numbers=new int[]{23,2,34,5,64,72,30,98};
        int i,j;
        for(i=0;i<numbers.length-1;i++)
        {
            for(j=0;j<numbers.length-1-i;j++) //第i次执行内循环，最后面的i个元素的位置是确定的
            {
                if(numbers[j]>numbers[j+1])
                {
                    int temp=numbers[j];
                    numbers[j]=numbers[j+1];
                    numbers[j+1]=temp;
                }
            }
        }
        System.out.println("从小到大排序后的结果是:");
        for(i=0;i<numbers.length;i++)
            System.out.print(numbers[i]+" ");
    }
}

快速排序法：

1、在数组中任意确定一个基准值base，不妨取数组的第一个数
2、设定双指针，i 指针是头指针，j 是尾指针，i 指针从前往后，找到数组里面第一个比base大的值的位置，j 指针从后往前，找到第一个比base小的值的位置。
3、交换指针 i 和 j 指向的内容，交换完之后，指针 i 指向的内容比base小，指针 j 指向的内容比base大。
4、交换指针 i 的内容和base的位置，base归位，这样 i 的内容、base、j 的内容就从小到大排列，数组被base切分为两个部分。
5、对切分出来的两个部分重复上述操作（递归），如果得到头指针i小于尾指针j，这一部分的排序完成，返回。

public class quickSort {
	public static void main(String[] args) {
		int[] array=new int[]{23,2,34,5,64,72,30,98};
		quickSort(array);
		for(int i = 0;i<array.length;i++) {
			System.out.print(array[i]+"\t");
		}
		
	}
	/**
	 * 快速排序
	 * @param array
	 */
	public static void quickSort(int[] array) {
	    int len;
	    if(array == null  //非法矩阵
	            || (len = array.length) == 0
	            || len == 1) {
	        return ;
	    }
	    sort(array, 0, len - 1);
	}
	
	/**
	 * 快排核心算法，递归实现
	 * @param array
	 * @param left
	 * @param right
	 */
	public static void sort(int[] array, int left, int right) {
	    if(left > right) { //当上一次调用时只有一个数了，也就是left==right，再次调用就会出现这个情况
	        return;
	    }
	    // 不妨直接取数组的第一个数位base
	    int base = array[left];  
	    int i = left, j = right;
	    while(i != j) {
	        // 先从右边开始往左找，直到找到比base值小的数
	        while(array[j] >= base && i < j) {
	            j--;
	        }

	        // 再从左往右边找，直到找到比base值大的数
	        while(array[i] <= base && i < j) {
	            i++;
	        }

	        // 上面的循环结束表示找到了位置，交换两个数在数组中的位置
	        if(i < j) {
	            int tmp = array[i];
	            array[i] = array[j];
	            array[j] = tmp;
	        }
	    }

	    // 将基准数放到中间的位置（基准数归位）
	    array[left] = array[i];
	    array[i] = base;

	    // 递归，继续向基准的左右两边执行和上面同样的操作
	    // i的索引处为上面已确定好的基准值的位置，无需再处理
	    sort(array, left, i - 1);
	    sort(array, i + 1, right);
	}
}

归并排序：

1、将要排序的数组从中间分成两个数组，长度最多相差1.
2、将两个分出来的数组再次中中间分开，直至分成一个部分只有一个元素，不能再分了，开始一步步比较合并。
3、创建一个中间数组term[ ] ，长度这一步需要合并的两个数组长度这和（这一步中合并所有相邻的，长度相差最多为1的子数组）。
4、从两个数组中逐个拿小的那个元素放到term[ ]中，拿完之后term[ ]的元素的顺序都是排好的，然后覆盖到原数组的内容。
5、一步步往回合并，直到合并成原来数组长度的term[ ]，覆盖原数组。

public class mergeSort {

    public static int[] sort(int[] nums, int low, int high) {  
        int mid = (low + high) / 2;  
        if (low < high) {  
            // 左边  
            sort(nums, low, mid);  
            // 右边  
            sort(nums, mid + 1, high);  
            // 左右归并  
            merge(nums, low, mid, high);  
        }  
        return nums;  
    }  
  
    public static void merge(int[] nums, int low, int mid, int high) {  
        int[] temp = new int[high - low + 1];  
        int i = low;// 左指针  
        int j = mid + 1;// 右指针  
        int k = 0;  
  
        // 把较小的数先移到新数组中  
        while (i <= mid && j <= high) {  
            if (nums[i] <= nums[j]) {  //看两边指针的内容，哪个小就哪个放进新数组
                temp[k++] = nums[i++];   //i和k 用完之后再自增
            } else {  
                temp[k++] = nums[j++];  
            }  
        }  
  
        // 如果是左边有剩余的数，就把左边剩余的数移入数组  
        while (i <= mid) {  
            temp[k++] = nums[i++];  
        }  
  
        // 如果是右边有剩余的数，就把右边边剩余的数移入数组  
        while (j <= high) {  
            temp[k++] = nums[j++];  
        }  
  
        // 把新数组中的数覆盖nums数组  
        for (int k2 = 0; k2 < temp.length; k2++) {  //排好序的内容覆盖原来的内容
            nums[k2 + low] = temp[k2];  
        }  
    }  
  
      
    // 归并排序的实现  
    public static void main(String[] args) {  
        
        int[] nums = {23,2,34,5,64,72,30,98};  
        mergeSort.sort(nums, 0, nums.length-1);  
        System.out.println(Arrays.toString(nums));  
    }  
} 

二分法查找：

用于查找升序序列中的元素：
1、3值指针，low，mid，high，low是数组的头指针，high是数组的尾指针，mid是数组的中间指针（mid=（low+high）/2）
2、将target值与mid指向的值比较，如果target值比mid的内容大，说明target只能在后半部分（low=mid+1），如果target值比mid内容小，说明target只能在前半部分（high=mid-1），如果mid的内容就等于target值，找到了。
3、不断重复第二步，如果high<low，说明没找到。

public static int binarySearch(int[] nums,int target) {
		
		int low = 0;
		int high = nums.length;
		while(low<=high) {
			int mid = (low+high)/2;
			if(nums[mid]>target) {
				high = mid-1;
			}
			else if(nums[mid]<target) {
				low = mid+1;
			}
			else if(nums[mid]==target){
				return mid;
			}
			
		}
		return -1;
	}