算法 -- 内部排序之插入/选择/交换排序

1.插入排序

a.直接插入排序

构建有序序列，对于未排序数据，在已排序序列中从后往前扫描，找到相应位置插入

算法描述：

从第一个元素开始，该元素被认为有序；

取出下一个元素，在已排序序列中从后往前扫描；

如果新元素小于有序序列元素，将新元素放入有序序列，并将原元素后移；

重复以上操作，保证有序序列从小到大排列，无序序列从后向前比较插入。

public static int[] getInsertionSort(int[] arr) {
        if (arr.length == 0) {
            return arr;
        }
        int current; // 当前未排序数据
        for (int i = 0; i < arr.length; i++) {
            current = arr[i];
            int preIndex = i-1; // 最后一个有序序列中元素下标
            // 假设当前有序序列数据>新元素（未排序数据）
            while (preIndex >= 0 && current < arr[preIndex]) {
                arr[preIndex + 1] = arr[preIndex]; // 新元素加入有序序列，有序序列元素后移
                preIndex--;
            }
            arr[preIndex + 1] = current;
        }
        return arr;
    }

b.希尔排序

按照增量进行比较，直至增量为1。

算法描述：

选择一个增量序列t1，t2，t3。。。；

按增量序列个数k，对序列进行排序（例如：1与k+1比较，2与k+2比较）；

每趟排序，根据对应的增量，将待排序序列分割成若干个长度的子序列，分别对每个子序列中相同位置的元素进行比较插入。

public static int[] getShellSort(int[] arr) {
        // 最大的增量设置为 数组长度/2
        for (int gap = arr.length/2; gap > 0; gap = gap/2) {
            // 增量的后半部分
            for (int i = gap;i<arr.length;i++){
                int j = i; // 前半部分元素索引下标
                int current = arr[i]; // 后半部分的当前元素（后半部分从开第一开始）
                while (j-gap>=0 && arr[j-gap]>current){ // 例：增量=5： 前半部分1 arr[0] > 后半部分1 arr[0]
                    arr[j] = arr[j-gap]; // 交换两个元素数据
                    j = j-gap;
                }
                arr[j] = current; // 前半部分元素赋值
            }
        }
        return arr;
    }

2.选择排序

a.简单选择排序

从未排序中中找到最小（大）元素，存放到排序序列的初始位置，然后，再从剩余的未排序序列中继续寻找最小（大）元素，放到排序序列末尾。以此类推。

算法描述：

初始状态：有序序列为空；

第i趟排序（从i=1开始），当前有序序列【1，2，3】和无序序列【7，9，4，6。。】，从无序序列中找到最小的（例如4），将它与无序序列中第一个记录交换，并将其划分为有序序列，此时有序序列长度+1，无序序列长度-1。

public static int[] getSelectionSort(int[] arr) {
        int minIndex; // 最小元素索引下标
        for (int i=0;i<arr.length-1;i++){
            minIndex = i;
            for (int j=i+1;j<arr.length;j++){ // 在未排序序列中寻找最小元素
                if (arr[j]<arr[minIndex]){
                    minIndex = j;
                }
            }
            // 将最小元素放入有序序列中
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
        return arr;
    }

b.堆排序

子节点的键值总是小于（小于）它的父节点。

算法描述：

构建大顶堆：将初始待排序元素依次放入二叉树中，构建大顶堆；

调整元素：从右下角最后一个父节点开始调整，使其符合子节点的值大于两个孩子的值。依次调整整棵树；

排序：交换根和最后一个叶子结点。重复2在重复3反复。

public class HeapSort {

    public static void main(String[] args) {
        int[] arr = {2,1,4,6,3,8,1};
        buildMaxHeap(arr);
        heapSort(arr);
        print(arr);
    }

    /**
     * 建立大顶堆
     *
     * @param arr 数组对象
     */
    public static void buildMaxHeap(int[] arr) {
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            heapift(arr, i, arr.length - 1);
        }
    }

    /**
     * 调整堆
     *
     * @param arr 数组对象
     * @param i   父节点
     * @param end
     */
    public static void heapift(int[] arr, int i, int end) {
        int left = 2 * i + 1; // 当前节点的左孩子
        int temp = arr[i]; // 当前节点（父节点）的值

        while (left <= end) {
            // 选出两个孩子中较大的
            if (left < end && arr[left + 1] > arr[left]) { // 右孩子大
                left++; // 右孩子
            }
            if (temp < arr[left]) {
                arr[i] = arr[left]; // 孩子节点与当前节点替换
                i = left;
                left = 2 * left + 1;
            }else {
                break;
            }
            arr[i] = temp;
        }
    }

    public static int[] heapSort(int[] arr) {
        // 取出堆顶元素，与最后一个元素交换，调整堆
        for (int i=arr.length-1;i>=0;i--){
            int temp = arr[i];
            arr[i] = arr[0]; // 最后一个元素
            arr[0] = temp;
            heapift(arr,0,i-1);
        }
        return arr;
    }
    // 输出
    public static void print(int[] arr) {
        for(int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}

3.交换排序

a.冒泡排序

两两交换

算法描述：

比较相邻的两个元素。如果第一个比第二个，就交换它们；

对每一对相邻的元素做同样的工作，从第一个开始到结尾最后一对。

public static int[] bubbleSort(int[] arr) {
        for (int j = 0; j < arr.length; j++) {
            for (int i = 0; i < arr.length - 1 - j; i++) {
                if (arr[i] > arr[i + 1]) {
                    int temp = arr[i + 1];
                    arr[i + 1] = arr[i];
                    arr[i] = temp;
                }
            }
        }
        return arr;
    }

b.快速排序

从未排序元素中指定第一个为基准pivot，比基准大的在后面，比基准小的在前面。

算法描述：

以数组中第一个元素为基准pivot；

重新排列数组，所有比基准小的放在基准前面，所有比基准大的放在基准后面；

递归的把小于基准的元素和大于基准的元素排序。

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {4,2,6,9,10,0,3,7,8};
        quickSort(arr, 0, arr.length - 1);
        for (int i : arr) {
            System.out.print(i+ "\t");
        }

    }

    // 根据基准快速排序
    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pivot = getPivot(arr, low, high);
            // 就行迭代对 pivot 之前和之后的数组就行相同的操作使整个数组有序
            quickSort(arr, low, pivot - 1);
            quickSort(arr, pivot + 1, high);
        }
    }

    /**
     * 设置基准
     *
     * @param high 高于基准的元素下标
     * @param low  低于基准的元素下标
     */
    public static int getPivot(int[] arr, int low, int high) {
        // 基准数据
        int pivot = arr[low];
        while (low < high) {
            // 从后往前，当high的元素大于基准时，high--
            while (low < high && arr[high] >= pivot) {
                high--;
            }
            // 如果high的元素小于基准时
            arr[low] = arr[high];
            // 从前往后，当low的元素小于基准时，low++
            while (low < high && arr[low] <= pivot) {
                low++;
            }
            // 如果low的元素大于基准时
            arr[high] = arr[low];
        }
        // 跳出循环时，low和high相等，此时的low、high就是pivot的正确索引位置
        arr[low] = pivot;
        return low;
    }
}

这几种面试时问的多，尤其是冒泡排序或者快速排序。有错误可以指出，谢谢

我学习时参考的https://www.cnblogs.com/onepixel/p/7674659.html