几种常见排序算法思想及其实现

几种常见排序算法思想及其实现

1.冒泡排序

排序思想：先找出数组中最大的元素，放在最右边，然后找出第二大的，放在右边第二个位置…

注：与选择排序不同的是，冒泡排序在找最大元素时，边比较边交换，而选择排序是找到最小的再交换，这也是冒泡排序稳定，而选择排序不稳定的原因

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = new int[] {5,3,4,7,9,8,0,6};
//        int[] selectionSort = sort(arr);
        int[] selectionSort = sort2(arr);
        for (int item: selectionSort) {
            System.out.println(item);
        }
    }
    
    private static int[] sort(int[] arr) {
        int len = arr.length;
        if(len <= 1){
            return arr;
        }
        for (int i = 0; i < len; i++) {
            for (int j = 0; j < len - i -1; j++) {
                if(arr[j] > arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        return arr;
    }

    /**
     * 冒泡排序优化
     * @param arr
     * @return
     */
    private static int[] sort2(int[] arr) {
        int len = arr.length;
        if(len <= 1){
            return arr;
        }
        for (int i = 0; i < len; i++) {
            boolean flag = true;
            for (int j = 0; j < len - i -1; j++) {
                if(arr[j] > arr[j+1]) {
                    flag = false;
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            if(flag){
                break;
            }
        }
        return arr;
    }
}

2.选择排序

排序思想：先找到数组中最小的元素，与数组第一个元素交换位置，然后找出剩余元素中最小的元素，与数组第二个位置交换…

public class SelectionSort {
    public static void main(String[] args) {
        int[] arr = new int[] {5,3,4,7,9,8,0,6};
        int[] selectionSort = sort(arr);

        for (int item: selectionSort) {
            System.out.println(item);
        }
    }

    private static int[] sort(int[] arr) {
        int len = arr.length;

        //遍历整个数组
        for (int i = 0; i < len; i++) {
            int min = i;
            //遍历无序部分
            for (int j = i + 1; j < len; j++) {
                if(arr[min] > arr[j]) {
                    min = j;
                }
            }

            int temp = arr[i];
            arr[i] = arr[min];
            arr[min] = temp;
        }

        return arr;
    }
}

3.插入排序

排序思想：将右边无序元素依次插入到左边有序元素中，刚开始将第一个元素作为左边有序数组

public class InsertionSort {
    public static void main(String[] args) {
        int[] arr = new int[] {5,3,4,7,9,8,0,6};
        int[] selectionSort = sort(arr);

        for (int item: selectionSort) {
            System.out.println(item);
        }
    }

    private static int[] sort(int[] arr) {
        int len = arr.length;

        if(len <= 1){
            return arr;
        }

        for (int i = 1; i < len; i++) {
            //要插入的数据
            int temp = arr[i];
            //要插入的位置的前一个位置
            int j = i - 1;
            while (j >= 0 && temp < arr[j]){
                j--;
            }
            //移动数组,k是需要移动的元素的索引
            for (int k = i - 1; k > j; k--) {
                arr[k+1] = arr[k];
            }
            arr[j+1] =temp;
        }

        return arr;
    }
}

4.归并排序

排序思想（分治）：首先，将一个大的数组递归分割，直到数组的大小都为1，我们认为大小为 1的数组是有序的。然后，我们将大小为1的数组合并成大小为2的数组，将大小为2的数组合并成大小为4的数组…

public class MergeSort {
    public static void main(String[] args) {
        int[] arr = new int[] {5,3,4,7,9,8,0,6};
        int[] selectionSort = sort(arr, 0, arr.length-1);
//        int[] selectionSort = sort2(arr);
        for (int item: selectionSort) {
            System.out.println(item);
        }
    }

    /**
     * 递归式归并排序(分而治之)
     * @param arr
     * @return
     */
    private static int[] sort(int[] arr, int left, int right) {
        //递归结束的条件：递归到只有一个元素，即left == right
        if(left < right){
            //分
            int mid = left + (right - left) / 2;
            //治
            sort(arr, left, mid);
            sort(arr, mid + 1, right);
            //合
            merge(arr, left, mid, right);
        }

        return arr;
    }

    /**
     * 合并有序数组
     * @param arr
     * @param left
     * @param mid
     * @param right
     */
    private static void merge(int[] arr, int left, int mid, int right) {
        int i = left;
        int j= mid + 1;
        int[] temp =new int[right - left + 1];

        for (int k = 0; k < temp.length ; k++) {
            //如果左边（右边）数组元素取完，则直接复制右边（左边）数组
            if(i > mid) {
                temp[k] = arr[j++];
            }else if(j > right) {
                temp[k] = arr[i++];
            }else if(arr[i] <= arr[j]){
                temp[k] = arr[i++];
            }else {
                temp[k] = arr[j++];
            }
        }

        //将临时数组的值复制到原数组 arr 中
        for (int k = 0; k < temp.length ; k++) {
            arr[left++] = temp[k];
        }
    }
}

5.快速排序

排序思想（分治）：首先，从数组中选择一个元素作为中轴元素（一般选第一个元素，或者也可随机获取），将小于中轴元素的元素放在中轴元素左边，大于中轴元素的放在中轴元素右边，此时中轴元素有序。然后，将中轴元素左边部分和右边部分也重复同样的操作（通过递归），直到数组的大小为1，此时每个元素都有序。

注：快速排序应该注意，如果选择左边第一个数为中轴元素，则应该先移动右边下标 j ，如果选择右边第一个元素为中轴元素，应该先移动左边下标 i

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = new int[] {5,3,4,7,9,8,0,6};

        quickSort(arr, 0, arr.length - 1);
        for (int item:arr) {
            System.out.println(item);
        }
    }

    /**
     * 递归快排
     * @param arr
     * @param left
     * @param right
     * @return
     */
    private static void quickSort(int[] arr, int left, int right){
        if (left < right){
            int mid = partition(arr,left,right);
            quickSort(arr,left,mid-1);
            quickSort(arr,mid+1,right);
        }
    }

    public static int partition(int[] arr, int left, int right){
        int pivot = arr[left];
        int i = left;
        int j = right;
        while(i < j){
            while(i < j && arr[j] >= pivot){
                j--;
            }
            while(i < j && arr[i] <= pivot){
                i++;
            }
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        arr[left] = arr[i];
        arr[i] = pivot;
        return i;
    }
}

6.堆排序

排序思想：将无序数组构建成二叉堆，将堆顶元素与最后一个元素交换，将剩余元素再次构成一个二叉堆，再把堆顶元素与第二个元素交换…

public class HeapSort {
    public static void main(String[] args) {
        int[] arr = new int[]{5,3,4,7,9,8,0,6};
        heapSort(arr);
        for (int item: arr) {
            System.out.println(item);
        }
    }

    /**
     * 堆排序
     * @param arr
     */
    private static void heapSort(int[] arr){
        int n = arr.length;

        //构建大顶堆
        for (int i = (n-2)/2; i >= 0; i--) {
            downAdjust(arr, i, n-1);
        }

        //进行堆排序
        for (int i = n - 1; i >= 1; i--) {
            //将堆顶元素与第一个元素交换
            int temp = arr[i];
            arr[i] = arr[0];
            arr[0] = temp;
            //恢复二叉堆
            downAdjust(arr,0,i-1);
        }
    }

    /**
     * 下沉操作，构建二叉堆
     * @param arr
     * @param parent
     * @param n
     */
    private static void downAdjust(int[] arr, int parent, int n){
        //临时保存要下沉的元素
        int temp = arr[parent];
        //定位左孩子节点的位置
        int child = 2 * parent + 1;
        //开始下沉
        while (child <= n){
            // 如果右孩子节点比左孩子大，则定位到右孩子
            if(child + 1 <= n && arr[child] < arr[child + 1]){
                child++;
            }
            // 如果孩子节点小于或等于父节点，则下沉结束
            if (arr[child] <= temp ){
                break;
            }
            // 父节点进行下沉
            arr[parent] = arr[child];
            parent = child;
            child = 2 * parent + 1;
        }
        arr[parent] = temp;
    }
}