重要排序算法

排序算法最佳时间复杂度平均时间复杂度最坏时间复杂度稳定性空间复杂度
插入排序O(n)O(n^2)O(n^2)稳定O(1)
快速排序O(nlogn)O(nlogn)O(n^2)不稳定O(logn)
堆排序O(nlogn)O(nlogn)O(nlogn)不稳定O(1)
冒泡排序O(n)O(n^2)O(n^2)稳定O(1)
归并排序O(nlogn)O(nlogn)O(nlogn)稳定O(n)

直接插入排序

把待排序的记录按其值的大小逐一插入到一个已排好序的有序序列中,直到所有的记录插入完为止。

public void insertSort(int[] array){
    for(int i = 1; i < array.length; i++){
        int temp = array[i];
        int j = i;
        while(j - 1 >= 0 && array[j - 1] > temp){
            array[j] = array[j - 1];
            j--;
        }
        array[j] = temp;
    }
}

快速排序

任取待排序元素序列中的某元素作为基准值,按照该基准值将待排序集合分割成两子序列,左子序列中所有元素均小于基准值,右子序列中所有元素均大于基准值,然后最左右子序列重复该过程,直至所有元素都排列在相应位置上为止。

class Solution{
    public void quickSort(int[] array, int start, int end){
        if(start >= end){
            return;
        }
        int pivot = partition(array, start, end);
        quickSort(array, start, pivot - 1);
        quickSort(array, pivot + 1, end);
    }

    public int partition(int[] array, int left, int right){
        int temp = array[left];
        while(left < right){
            while(left < right && array[right] >= temp){
                right--;
            }
            array[left] = array[right];
            while(left < right && array[left] <= temp){
                left++;
            }
            array[right] = array[left];
        }
        array[left] = temp;
        return left;
    }
}

堆排序

首先将数组元素建成大小为n的大顶堆,堆顶(数组第一个元素)是所有元素中的最大值,将堆顶元素和数组最后一个元素进行交换,再将除了最后一个数的n-1个元素   建立成大顶堆,再将最大元素和数组倒数第二个元素进行交换,重复直至堆大小减为1。

class Solution{
    public void heapSort(int[] array) {
        //1、大根堆 O(N)
        createHeap(array);
        //2、排序O(n*logn)
        for(int i = array.length - 1; i >= 1; ) {
            swap(array, 0, i);               // 把堆顶元素(当前最大)交换到数组末尾
            i--;                               // 逐步减少堆有序的部分
            shiftDown(array, 0, i);     // 下标0位置下沉操作,使得区间 [0, i] 堆有序
        }
    }

    //创建大根堆
    private void createHeap(int[] array) {
        for (int parent = (array.length - 1) / 2; parent >= 0; parent--) {
            shiftDown(array, parent, array.length - 1);
        }
    }

    //向下调整
    private void shiftDown(int[] array, int parent, int len) {
        int child = 2 * parent + 1;
        while (child <= len) {
            if(child + 1 <= len && array[child] < array[child + 1]) {
                child++;    //它一定保存的是左右孩子的最大值的下标
            }
            if(array[child] > array[parent]) {
                swap(array, child, parent);
                parent = child;
                child = 2 * parent + 1;
            }else {
                break;
            }
        }
    }

    public void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

冒泡排序

它重复的遍历数组,每次比较两个元素,按照规定的排序规则将其排序,当数组有序时,排序结束。

class Solution{
    public static void bubbleSort(int[] array) {
        for(int i = array.length - 1; i >= 0; i--) {
            boolean flag = false;
            for(int j = 0; j < i; j++) {
                if(array[j] > array[j + 1]) {
                    swap(array, j, j + 1);
                    flag = true;
                }
            }
            if(flag == false) {
                break;
            }
        }
    }

    public static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

归并排序

首先让数组中的每一个数单独成为长度为1的区间,然后两两一组有序合并,得到长度为2的有序区间,依次进行,直到合成整个区间。

class Solution{
    private static void mergeSort(int[] array,int left,int right) {
        if(left >= right) {
            return;
        }
        int mid = (left + right) >>> 1;
        mergeSort(array, left, mid);
        mergeSort(array, mid + 1, right);
        merge(array, left, right, mid);
    }

    //合并函数
    private static void merge(int[] array, int left, int right, int mid) {
        int[] temp = new int[right - left + 1];
        int index = 0;
        int i = left;
        int j = mid + 1;
        while (i <= mid && j <= right) {
            if(array[i] <= array[j]) {
                temp[index++] = array[i++];
            }else {
                temp[index++] = array[j++];
            }
        }

        while (i <= mid) {
            temp[index++] = array[i++];
        }
        while (j <= right) {
            temp[index++] = array[j++];
        }

        for(int k = 0; k < index; k++) {
            array[k + left] = temp[k];
        }
    }
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值