常见的几种数组排序的算法

常见的几种数组的排序算法

数组准备

int[] arrs = {9, 4, 3, 18, 2, 19, 14, 7, 16, 5, 17, 34, 8, 10, 20, 12};

冒泡排序（大 -> 小）

思路：

1. i ： i每次循环，都会确定数组中最后一位元素是数组中最小的元素。
2. j ： 每次循环，数组都会从下标为j的元素与下标为j+1的元素进行比较，如果小于，则调换两者的位置，依次向下进行判断，直到确定数组最后一位元素为最小的元素。

for (int i = 0; i < arrs.length - 1; i++) {  
            for (int j = 0; j < arrs.length - 1 - i; j++) {
                if (arrs[j] < arrs[j + 1]) {
                    int t = arrs[j];
                    arrs[j] = arrs[j + 1];
                    arrs[j + 1] = t;
                }
            }
        }
        System.out.println(Arrays.toString(arrs));

选择排序（大 -> 小）

思路：

1. i：i 每次循环数组下标i元素都会与数组其他的所有元素进行比较，并确定数组i下标元素比较其i下标后面的元素，为最大元素。
2. j = i + 1：i 每次循环，都会与i+1进行比较，并确定i 元素大于 i+1元素

for (int i = 0; i < arrs.length - 1; i++) {
            for (int j = i + 1; j < arrs.length; j++) {
                if (arrs[i] < arrs[j]) {
                    int t = arrs[i];
                    arrs[i] = arrs[j];
                    arrs[j] = t;
                }
            }
        }
        System.out.println(Arrays.toString(arrs));

插入排序（大 -> 小）

思路：

1. 把数组开始下标元素当做以排序元素，从第二个元素开始进行排序。
2. 排序步骤： 将排序元素依次与前一个元素进行比较，如果小于前一个元素（适合）则直接插入当前下标位置，如果不适合，则将上一个元素向后移动一位，然后继续判断与后面的元素是否满足，不适合则前面的元素继续先后移动一位，继续之前的操作，直到找到合适的位置，将排序的元素插入。

for(int i = 1;i < arrs.length; i++){
	int j = i - 1;		// 将i的前一个元素下标取出
	int x = arrs[i];	// 获取第i个元素的值
	while(j > -1 && x < arrs[j]){	// 判断 是否比前面的元素小
		arrs[j + 1] = arrs[j];
		j--;
	}
	arrs[j + 1] = x;			 // 将排序元素插入适合的位置
}
System.out.println(Arrays.toString(arrs));

两路归并排序（大 -> 小）

思路：

1. 两路归并算法，两个排好序的子序列合并为一个子序列 (分治算法)
2. 归并排序是一种概念上最简单的排序算法，与快速排序一样，归并排序也是基于分治法的。归并排序将待排序的元素序列分成两个长度相等的子序列，为每一个子序列排序，然后再将他们合并成一个子序列。合并两个子序列的过程也就是两路归并。

    public static void main(String[] args) {
        mergeSort(arrs, 0, arrs.length - 1);
        System.out.println("排好序的数组");
        System.out.println(Arrays.toString(arrs));
    }

    private static void mergeSort(int[] arrs, int startIndex, int endIndex) {
        if (startIndex < endIndex) {				//当子序列中只有一个元素时结束递归
            int mid = (startIndex + endIndex) / 2;	//划分子序列
            mergeSort(arrs, startIndex, mid);		//对左侧子序列进行递归排序
            mergeSort(arrs, mid + 1, endIndex);		//对右侧子序列进行递归排序
            merge(arrs, startIndex, mid, endIndex);	//合并
        }
    }

    private static void merge(int[] arrs, int left, int mid, int right) {
        int[] tmp = new int[arrs.length];			//辅助数组	
        int p1 = left, p2 = mid + 1, k = left;		//p1、p2是检测指针，k是存放指针

	    /* 遍历两个数组，按 从大 -> 小 的顺序，放入新的数组中 */
        while (p1 <= mid && p2 <= right) {
            if (arrs[p1] >= arrs[p2])
                tmp[k++] = arrs[p1++];
            else
                tmp[k++] = arrs[p2++];
        }

        while (p1 <= mid) tmp[k++] = arrs[p1++];	//如果第一个序列未检测完，直接将后面所有元素加到合并的序列中
        while (p2 <= right) tmp[k++] = arrs[p2++];	//如果第二个序列未检测完，直接将后面所有元素加到合并的序列中

		//复制回原数组
        for (int i = left; i <= right; i++) {
            arrs[i] = tmp[i];
        }
    }

二分查找法

二分查找算法：前提数组必须是排序后的数组
思路：

        Arrays.sort(arrs);		// 将数组进行排序 升序
        System.out.println("排序后的数组attr=" + Arrays.toString(arrs));
        int num = 14;			// 查找数组中为14的元素

        int left = 0;			// 开始下标
        int right = arrs.length;	// 结束下标
        int index;				// 查询条件匹配的下标
        while (true) {		
            int mid = (left + right) / 2;	// 获取数组中间下标
            if (arrs[mid] == num) {			// 判断是否为查找的元素
                index = mid;				
                break;
            } else if (arrs[mid] > num) {	// 判断查找的元素是否小于当前元素
                right = mid;				// 小于则查找左侧的元素，否则查找右边的元素
            } else if (arrs[mid] < num) {
                left = mid;					
            }
        }
        System.out.println(arrs[index]);