4-排序

1 冒泡排序

冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较
相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。

优化：
因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在
排序过程中设置一个标志flag 判断元素是否进行过交换。从而减少不必要的比较。(这里说的优化，可以在冒泡排
序写好后，在进行)

public static void bubbleSort(int[] arr) {

    int temp = 0;
    boolean flag = false;  //标识变量，表示是否进行过交换
    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]) {
                flag = true;
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }

        if (!flag) {  //在一趟排序中，一次交换都没有发生过
            break;
        } else {
            flag = false;  //重置flag，进行下次判断
        }
    }
}

---

2 选择排序

public static void selectSort(int[] arr){
    for (int i = 0; i < arr.length - 1; i++) {
        int minIndex = i;
        int minVal = arr[minIndex];
        for (int j = i+1; j < arr.length; j++) {
            if(minVal > arr[j]){
                minVal = arr[j];
                minIndex = j;
            }
        }
        if(minIndex != i){
            arr[minIndex] = arr[i];
            arr[i] = minVal;
        }
    }
}

---

3 插入排序

public static void insertSort(int[] nums) {
        int insertVal = 0;
        int insertIndex = 0; //当前要插入的元素下标
        for (int i = 1; i < nums.length; i++) {
            insertVal = nums[i];
            insertIndex = i;
            while (insertIndex - 1 >= 0 && insertVal < nums[insertIndex - 1]) {
                nums[insertIndex] = nums[insertIndex-1];
                insertIndex--;
            }
            if (insertIndex !=i){
                nums[insertIndex] = insertVal;
            }
        }
    }

---

4 希尔排序

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含
的关键词越来越多，当增量减至1 时，整个文件恰被分成一组，算法便终止

public static void shellSort(int[] arr) {
    int temp = 0;
    int count = 0;
    for (int gap = arr.length / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < arr.length; i++) {
            // 遍历各组中所有的元素(共gap 组，每组有个元素), 步长gap
            for (int j = i - gap; j >= 0; j -= gap) {
                // 如果当前元素大于加上步长后的那个元素，说明交换
                if (arr[j] > arr[j + gap]) {
                    temp = arr[j];
                    arr[j] = arr[j + gap];
                    arr[j + gap] = temp;
                }
            }
        }
        System.out.println("希尔排序第" + (++count) + "轮=" + Arrays.toString(arr));
    }
}

//对交换式的希尔排序进行优化->移位法
public static void shellSort3(int[] arr) {
        int count = 0;
        int insertVal = 0, insertIndex = 0;
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < arr.length; i++) {
                insertIndex = i;
                insertVal = arr[i];
                while (insertIndex - gap >= 0 && insertVal < arr[insertIndex - gap]) {
                    arr[insertIndex] = arr[insertIndex - gap];
                    insertIndex -= gap;
                }

                arr[insertIndex] = insertVal;
            }
            System.out.println("希尔排序第" + (++count) + "轮=" + Arrays.toString(arr));

        }
    }

---

5 快速排序

public static void quickSort(int[] arr, int low, int high) {
    if (low < high) {
        int index = getIndex(arr, low, high);
        quickSort(arr, low, index - 1);
        quickSort(arr, index + 1, high);
    }
}

public static int getIndex(int[] arr, int low, int high) {
    //基准数据
    int temp = arr[low];
    while (low < high) {
        while (low < high && arr[high] >= temp) {
            high--;
        }
        arr[low] = arr[high];

        while (low < high && arr[low] <= temp) {
            low++;
        }
        arr[high] = arr[low];
    }
    arr[low] = temp;
    return low;
}

---

6 归并排序

public static void mergeSort(int[] arr, int low, int high, int[] temp) {
    if (low < high){
        int mid = (low+high)/2;
        //对左边序列进行归并排序
        mergeSort(arr,low,mid,temp);
        //对右边序列进行归并排序
        mergeSort(arr,mid+1,high,temp);
        //合并两个有序序列
        merge(arr,low,mid,high,temp);
    }
}

public static void merge(int[] arr, int low, int mid, int high, int[] temp) {
    //初始化i，左边有序序列的初始索引
    int i = low;
    //初始化j，右边有序序列的初始索引
    int j = mid + 1;
    //指向temp数组的当前索引
    int t = 0;
    //先把左右两边(有序)的数据按照规则填充到temp 数组,直到左右两边的有序序列，有一边处理完毕为止
    while (i <= mid && j <= high) {
        if (arr[i] < arr[j]) {
            temp[t++] = arr[i++];
        } else {
            temp[t++] = arr[j++];
        }
    }
    //把有剩余数据的一边的数据依次全部填充到temp
    while (i <= mid) {
        temp[t++] = arr[i++];
    }
    //把有剩余数据的一边的数据依次全部填充到temp
    while (j <= high) {
        temp[t++] = arr[j++];
    }

    //排好序后复制到原来数组的对应位置
    for (int k = 0; k < t; k++) {
        arr[low + k] = temp[k];
    }
}

7 基数排序

public static void radixSort(int[] arr) {

    //得到数组中最大的数的位数
    int max = arr[0];
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    //得到最大数是几位数
    int maxLength = (max + "").length();
    /*
    定义一个二维数组，表示10个桶，每个桶j就是一个一维数组
    说明：1.二维数组包含10个一维数组
          2.为了防止放入数的时候，数据溢出，每一个一维数组大小定位 arr.length
          3.基数排序是使用空间换时间的经典算法
     */
    int[][] bucket = new int[10][arr.length];
    /*
    为了记录每个桶中，实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数
    比如：bucketElementCounts[0] , 记录的就是bucket[0] 桶的放入数据个数
     */
    int[] bucketElementCounts = new int[10];

    for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
        //针对每个元素对应的位进行排序处理，第一次是个位，第二次是十位......
        for (int j = 0; j < arr.length; j++) {
            //取出每个元素的对应位的值
            int digitOfElement = arr[j] / n % 10;
            //放入到对应的桶中
            bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
            bucketElementCounts[digitOfElement]++;
        }
        //按照这个桶的顺序(一维数组下表依次取出数据，放入原来数组)
        int index = 0;
        //遍历每一个桶，并将桶中数据放入到原数组
        for (int k = 0; k < bucketElementCounts.length; k++) {
            //如果桶中有数据，才将其放入原数组
            if (bucketElementCounts[k] != 0) {
                //循环该桶即第k个桶
                for (int l = 0; l < bucketElementCounts[k]; l++) {
                    arr[index++] = bucket[k][l];
                }
            }
            //第i+1轮处理后，需要将买每个 bucketElementCounts[k] = 0 ！！！
            bucketElementCounts[k] = 0;
        }

        System.out.println("第" + (i + 1) + "轮，排序处理后 arr = " + Arrays.toString(arr));
    }

}

---

8 堆排序

/**
 * 将一个数组(二叉树)，调整成大顶堆
 * 功能： 完成将以i对应的非叶子结点的树调整成大顶堆
 * 举例int arr[] = {4, 6, 8, 5, 9}; => i = 1 => adjustHeap => 得到{4, 9, 8, 5, 6}
 * 如果我们再次调用adjustHeap 传入的是i = 0 => 得到{4, 9, 8, 5, 6} => {9,6,8,5, 4}
 *
 * @param arr    待调整的数组
 * @param i      非叶子节点在数组中的索引
 * @param length 表示堆多少个元素进行调整，length是在逐渐减少
 */
public static void adjustHeap(int[] arr, int i, int length) {
    int temp = arr[i];
    for (int j = i * 2 + 1; j < length; j = j * 2 + 1) {
        if (j + 1 < length && arr[j] < arr[j + 1]) {//左子节点<右子节点
            j++;  //j指向右子节点
        }
        if (arr[j] > temp) { //如果子节点大于父节点
            arr[i] = arr[j]; //把较大的值赋给当前节点
            i = j;  //i指向j，继续循环比较
        } else {
            break;
        }
    }
    //当for循环结束后，我们已经将以i为父节点的树的最大值，放在了最顶(局部)
    arr[i] = temp;  //将temp值放入到调整后的位置
}


public static void heapSort(int[] arr) {
    int temp = 0;
    for (int i = arr.length / 2 - 1; i >= 0; i--) {
        //将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆
        adjustHeap(arr, i, arr.length);
    }

    /*
    将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端
    重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。
    */
    for (int j = arr.length - 1; j > 0; j--) {
        temp = arr[j];
        arr[j] = arr[0];
        arr[0]=temp;
        adjustHeap(arr,0,j);

    }
    System.out.println("数组=" + Arrays.toString(arr));
}

9 总结