6种排序算法

插入排序

原理

插入排序，顾名思义肯定是已插入为主，将待排序的数组分为已排序（数组前部分）和未排序（数组后部分），这里我们已从小到大排序，数组为num[0–end]刚开始排序时，固定第一个数num[0]为已经排序好的数，从第二个数num[1]开始，从后往前比较已排序中的数据，如果小于num[1] <num[0] 则交换位置，直到比较到已排序数组的第一个位置结束。
num[0…i]为已排序数组
num[i+1…end]为未排序数组
比较num[i+1]与num[0…i]中的数据，从后往前比较，若num[i+1] <num[j] 则交换两个数位置，直到j==0，也就是比较到
num[i+1] 与num[0]
$$算法复杂度O(n^2)$$

代码

/**
     * 插入排序
     * @param nums
     */
    private static void insertSort(int[] nums){
        for (int i = 1;i<nums.length;i++){
            int index = i;
            for (int j=i-1;j>=0;j--){
                if (nums[index]<nums[j]){
                    int temp = nums[index];
                    nums[index] = nums[j];
                    nums[j] = temp;
                    index--;
                }
            }
        }
    }

冒泡排序

原理

冒泡排序，两两交换位置，$$算法复杂度O(n^2)$$

代码

/**
     * 冒泡排序
     * @param nums
     */
    private static void maopao(int[] nums){
        for (int i = 0;i<nums.length-1;i++){
            for (int j = 0;j<nums.length-1;j++){
                if (nums[j]>nums[j+1]){
                    int temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                }
            }
        }
    }

选择排序

原理

每轮循环选择一个最小值，将这个值与第一个位置交换，以此类推，一共n-1轮
$$算法复杂度O(n^2)$$

代码

/**
     * 选择排序
     * @param nums
     */
    private static void selectSort(int[] nums){
        for(int i=0;i<nums.length-1;i++){
            int min = Integer.MAX_VALUE;
            int index = 0;
            for (int j = i;j<nums.length;j++){
                if (nums[j] < min){
                    min = nums[j];
                    index=j;
                }
            }
            nums[index] = nums[i];
            nums[i] = min;
        }
    }

归并排序

原理

归并排序的思想是，利用二分的特性，将序列分成两个子序列进行排序，将排序后的两个子序列归并（合并），当序列的长度为2时，它的两个子序列长度为1，即视为有序，可直接合并，即达到归并排序的最小子状态
需要O(n)的辅助空间。归并排序是稳定的。
$$算法复杂度O(nlogn)$$

代码

/**
     * 归并排序
     * @param nums
     */
    private static void guibingsort(int[] nums){
        gbsort(nums,0,nums.length-1);
    }

    private static void gbsort(int[] nums,int start,int end){
        if (start < end){
            int mid = (start+end)/2;
            gbsort(nums,start,mid);
            gbsort(nums,mid+1,end);
            merge(nums,start,mid,end);
        }
    }

    private static void merge(int[] nums,int left,int mid,int right){
        int[] temp = new int[right-left+1];
        int index = 0;
        int leftstart = left;
        int rightstart = mid+1;
        while (leftstart<= mid &&rightstart<= right){
            if (nums[leftstart] <= nums[rightstart]){
                temp[index] = nums[leftstart];
                leftstart++;
                index++;
            }else {
                temp[index] = nums[rightstart];
                rightstart++;
                index++;
            }
        }
        while (leftstart<= mid){
            temp[index] = nums[leftstart];
            leftstart++;
            index++;
        }
        while (rightstart<=right){
            temp[index] = nums[rightstart];
            rightstart++;
            index++;
        }
        for (int i = 0;i<temp.length;i++){
            nums[left] = temp[i];
            left++;
        }
    }

快速排序

原理

与归并排序类似，也是分治，但是不同的是，快速排序是选定一个值，将数组中比这个值大的放在右边，比这个值小的放在左边，一轮排序下来之后，返回中间mid值，根据mid值将数组分为左右两个部分再次排序。
快速排序利用分而治之的思想，它的最好和平均实际复杂度为O(nlogn)，但是，如果选取基准的规则正好与实际数值分布相反，例如我们选取第一个数为基准，而原始序列是倒序的，那么每一轮循环，快排都只能把基准放到最右侧，故快排的最差时间复杂度为O(n2)。快排算法本身没有用到额外的空间，可以说需要的空间为O(1)；对于递归实现，也可以说需要的空间是O(n)，因为在递归调用时有栈的开销，当然最坏情况是O(n)，平均情况是O(logn)。快速排序是不稳定的。

代码

	quick(nums,0,nums.length-1);
 /**
     * 快速排序
     * @param nums
     * @param start
     * @param end
     */
    private static void quick(int[] nums,int start,int end){
        if (start<end){
            int mid = quickSort(nums,start,end);
            quick(nums,start,mid-1);
            quick(nums,mid+1,end);
        }
    }

    private static int quickSort(int[] nums,int start,int end){
        int val = nums[start];
        while (start<end){
            while (start<end && nums[end]>=val)
                end--;
            nums[start] = nums[end];
            while (start<end && nums[start]<=val)
                start++;
            nums[end] = nums[start];
        }
        nums[start] = val;
        return start;
    }

堆排序

原理

父节点为i 左子节点为(2i+1) 右子节点为 2(i+1) 子节点为i 父节点为 (i-1)/2
可以从上往下建堆，也可以从下往上建堆，建堆，分为大顶堆和小顶堆，每次完成建堆之后，将堆顶也就是index=0这个位置的数与数组最后一个数交换，如果从小到大排序，则建立大顶堆，反之小顶堆，一次循环建堆可能存在堆没有完全建成，所以我使用了一个变量max或者min来存储，一次建堆之后判断堆顶是不是最大值或者最小值，若不是则继续建堆，若是则交换第一个数与最后一个数，以此类推
$$算法复杂度O(nlogn)$$

代码

 /**
     * 堆排序
     * 父节点为i
     * 左子节点为(2*i+1)  右子节点为  2*(i+1)
     *
     * 子节点为i 父节点为 (i-1)/2
     * @param nums
     */
    private static void heapSort(int[] nums){
        for (int i = nums.length-1;i>=0;i--){
            heapBig(nums,i);
        }
    }
    private static void heapBig(int[] nums,int end){
        //初始化堆--> 大顶堆
        int index = 0;
        int max = nums[0];
        while ((2*index+1) <= end){
            if (2*index+1<=end&&nums[index] < nums[2*index+1]){
                int temp = nums[index];
                nums[index] = nums[2*index+1];
                nums[2*index+1] = temp;
            }
            if (2*(index+1)<=end&&nums[index] < nums[2*(index+1)]){
                int temp = nums[index];
                nums[index] = nums[2*(index+1)];
                nums[2*(index+1)] = temp;
            }
            max = Math.max(nums[index],max);
            index++;
        }
        if (max !=nums[0]){
            heapBig(nums,end);
        }else {
            int temp = nums[0];
            nums[0] = nums[end];
            nums[end] = temp;
        }
    }

    private static void heapSmall(int[] nums,int end){
        //初始化堆--> 小顶堆
        int index = 0;
        int min = nums[0];
        while ((2*index+1) <= end){
            if (2*index+1<=end&&nums[index] > nums[2*index+1]){
                int temp = nums[index];
                nums[index] = nums[2*index+1];
                nums[2*index+1] = temp;
            }
            if (2*(index+1)<=end&&nums[index] > nums[2*(index+1)]){
                int temp = nums[index];
                nums[index] = nums[2*(index+1)];
                nums[2*(index+1)] = temp;
            }
            min = Math.min(nums[index],min);
            index++;
        }
        if (min !=nums[0]){
            heapSmall(nums,end);
        }else {
            int temp = nums[0];
            nums[0] = nums[end];
            nums[end] = temp;
        }
    }

以上就是6中排序方法，以此记录一下