十大排序算法

​​​​​​​1 冒泡排序

1.1 算法描述

  • 比较相邻的元素。如果第二个比第一个小,就交换它们两个;
  • 对每一对相邻元素作同样的工作,从最后一个到当前批次的开始下标i,这样在最上面元素会是最小的数;
  • 针对所有的元素重复以上的步骤,除了最后一个;
  • 下标i+1,重复步骤1~3,直到排序完成

1.2 算法分析

1.2.1 时间复杂度

  • 平均:O(n2)
  • 最优:O(n) 已经排好序
  • 最坏:O(n2)

1.2.2 空间复杂度

    O(1)

1.2.3 稳定性

    稳定

1.3 算法实现

/**
     * 冒泡排序
     *
     * @param array
     * @return
     */
    public void bubbleSort(int[] array) {
        boolean isChange = true;
        for (int i = 0; i < array.length - 1 && isChange == true; i++) {
            isChange = false;
            for (int j = array.length - 1; j > i; j--) {
                if (array[j] < array[j - 1]) {
                    isChange = true;
                    array[j] = array[j] + array[j - 1];
                    array[j - 1] = array[j] - array[j - 1];
                    array[j] = array[j] - array[j - 1];
                }
            }
        }
    }

2 选择排序

2.1 算法描述

  • 下标i从0开始到length-1结束,选择出最小的下标和i进行交换;
  • 下标i+1,重复步骤1,直到i=length-2

2.2 算法分析

2.2.1 时间复杂度

  • 平均:O(n2)
  • 最优:O(n2)
  • 最坏:O(n2)

2.2.2 空间复杂度

    O(1)

2.2.3 稳定性

    不稳定:[3,3,1]。第一个3会到第二个3后面

2.3 算法实现

    /**
     * 选择排序
     *
     * @param array
     * @return
     */
    public void selectionSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[minIndex] > array[j]) {
                    minIndex = j;
                }
            }
            int temp=array[i];
            array[i] = array[minIndex];
            array[minIndex] = temp;
        }
    }

3 插入排序

3.1 算法描述

  • 从第一个元素开始,该元素可以认为已经被排序;
  • 取出下一个元素A,在已经排序的元素序列中从后向前扫描;
  • 如果该元素(已排序)大于元素A,将该元素移到下一位置;
  • 重复步骤3,直到找到已排序的元素小于或者等于新元素的位置;
  • 将新元素插入到该位置后;
  • 重复步骤2~5。

3.2.1 时间复杂度

  • 平均:O(n2)
  • 最优:O(n) 已经排好序
  • 最坏:O(n2)

3.2.2 空间复杂度

    O(1)

3.2.3 稳定性

    稳定

3.3 算法实现

    /**
     * 插入排序
     *
     * @param array
     * @return
     */
    public void insertionSort(int[] array) {
        for (int i = 1; i < array.length; i++) {
            int j = i;
            int temp = array[i];
            for (; j > 0; j--) {
                if (temp >= array[j - 1]) {
                    break;
                }
                array[j] = array[j - 1];
            }
            array[j] = temp;
        }
    }

4 希尔排序

4.1 算法描述

  • 插入排序在小范围数组和已经排好序的数组效果最好,所以希尔排序使用了缩小增量排序
  • 选择增量gap=length/2,缩小增量继续以gap = gap/2的方式,这种增量选择我们可以用一个序列来表示,{n/2,(n/2)/2...1},称为增量序列
  • 根据增量间隔来依次分组进行插入排序
  • 如gap=5,从第6个数n开始对{n-5,n-5-5,....1}进行插入排序,直到n=length

4.2.1 时间复杂度

  • 平均:O(n1.3)
  • 最优:O(n) 已经排好序,第一次间隔为1
  • 最坏:O(n2)

4.2.2 空间复杂度

    O(1)

4.2.3 稳定性

    不稳定:[1,3,3,1]。第一个3会到第二个3后面

4.3 算法实现

    /**
     * 希尔排序
     *
     * @param array
     * @return
     */
    public void shellSort(int[] array) {
        int length = array.length / 2;
        for (; length > 0; length = length / 2) {
            for (int i = length; i < array.length; i++) {
                int j = i;
                int temp = array[i];
                for (; j >= length; j -= length) {
                    if (temp >= array[j - length]) {
                        break;
                    }
                    array[j] = array[j - length];
                }
                array[j] = temp;
            }
        }
    }

5 归并排序

5.1 算法描述

  • 把长度为n的输入序列分成两个长度为n/2的子序列;
  • 对这两个子序列分别继续进行n/2拆分,直到长度为1;
  • 将两个排序好的子序列,从各自的最左端进行比较,把最小的放到新数组里面,等比较完成后再复制到原数组相应的位置。

5.2.1 时间复杂度

  • 平均:O(nlogn)
  • 最优:O(nlogn)
  • 最坏:O(nlogn)

5.2.2 空间复杂度

    O(n) 递归需要的栈帧,不用递归就是 O(1)

5.2.3 稳定性

    稳定

5.3 算法实现

    /**
     * 归并排序
     *
     * @param array
     * @return
     */
    public void mergeSort(int[] array) {
        mergeSort(0, array.length - 1, array, new int[array.length]);
    }

    public void mergeSort(int start, int end, int[] array, int[] temp) {
        if (end > start) {
            int mid = (start + end) / 2;
            mergeSort(start, mid, array, temp);
            mergeSort(mid + 1, end, array, temp);
            int left = start;
            int right = mid + 1;
            for (int i = start; i <= end; i++) {
                if (left > mid) {
                    temp[i] = array[right++];
                } else if (right > end) {
                    temp[i] = array[left++];
                } else if (array[left] <= array[right]) {
                    temp[i] = array[left++];
                } else {
                    temp[i] = array[right++];
                }
            }
            for (int i = start; i <= end; i++) {
                array[i] = temp[i];
            }
        }
    }

6 快速排序

6.1 算法描述

  • 从数列中挑出一个元素,称为 “基准”(pivot),通常是第一个;
  • 定义第一个为左下标,最后一个为右下标,从右下标开始向左移动依次与基准比较,找到第一个小于基数的下标,移动左下标找到第一个大于基数的下标,交换左右下标的数值,直到左下标等于又下标,此时这个基数就处于中间位置,即它的左边都小于等于它,右边都大于等于它;
  • 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列分别进行1-2

6.2.1 时间复杂度

  • 平均:O(nlogn)
  • 最优:O(nlogn)
  • 最坏:O(n2)

6.2.2 空间复杂度

    O(nlogn) 递归需要的栈帧,不用递归就是 O(1)

6.2.3 稳定性

    不稳定:[3,3,1] 第一个3会到第二个3后面

6.3 算法实现

    /**
     * 快速排序
     *
     * @param array
     * @return
     */
    public void quickSort(int[] array) {
        quickSort(0, array.length - 1, array);
    }

    public void quickSort(int start, int end, int[] array) {
        if (start >= end) {
            return;
        }
        int left = start;
        int right = end;
        while (right > left) {
            while (right > left && array[right] >= array[start]) {
                right--;
            }
            while (right > left && array[left] <= array[start]) {
                left++;
            }
            if (right > left) {
                array[right] = array[right] + array[left];
                array[left] = array[right] - array[left];
                array[right] = array[right] - array[left];
                right--;
            }
        }
        if (start != left) {
            array[start] = array[start] + array[left];
            array[left] = array[start] - array[left];
            array[start] = array[start] - array[left];
        }
        quickSort(start, left - 1, array);
        quickSort(left + 1, end, array);
    }

7 堆排序

7.1 算法描述

  • 构建堆结构(以最大堆为例,最小堆反过来即可),即a[i]>=a[2i+1]&&a[i]>=a[2i+2]
  • 按照二叉树定义,非叶子结点对应的叶子结点是2i+1和2i+2,同样节点n反过来求他的父节点,就可以用这个公式2i+1=n,如果求出来的是整数那么n就是左节点,如果是小数就是右节点;
  • 先从最后一位的下标通过上述公式反求出最后一个非叶子节点,然后和他的左右节点找出最大的换到那个节点数,如果进行了交换,那就对交换的节点进行堆调整,就是对这个节点的左右节点这接着进行此步骤,然后下标减1,直到到0
  • 然后把第一个也就是最大的和最后一个e进行交换,再将数组的0到e-1位继续进行2-4

7.2.1 时间复杂度

  • 平均:O(nlogn)
  • 最优:O(nlogn)
  • 最坏:O(nlogn)

7.2.2 空间复杂度

    O(1)

7.2.3 稳定性

    不稳定:[3,3,1] 第一个3会到第二个3后面

7.3 算法实现

    /**
     * 堆排序
     *
     * @param array
     * @return
     */
    public void heapSort(int[] array) {
        int length = array.length;
        for (int a = length - 1; a > 0; a--) {
            for (int i = (a - 1) / 2; i >= 0; i--) {
                heapSort(array, i, a);
            }
            swap(array, 0, a);
        }

    }

    public void heapSort(int[] array, int i, int end) {
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        if (left > end) {
            return;
        }
        int maxIndex = right <= end && array[right] > array[left] ? right : left;
        if (array[i] < array[maxIndex]) {
            swap(array, i, maxIndex);
            heapSort(array, maxIndex, end);
        }
    }

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

8 计数排序

8.1 算法描述

  • 找出待排序的数组中最大和最小的元素的差值n,构建长度为n+1的数组C;
  • 数组中的值i,存入数组C的第i-最小值项,每出现一次,在C相应位置加1;
  • 遍历数组C,将不为0的下标作为值,放到原数组中,C的值是多少,就往原数组里面添加几次C的下标
  • 缺点是数据离散程度大的话,会浪费很大资源,而且不能比较小数,差值n不能大余int的最大值

8.2.1 时间复杂度

  • 平均:O(n+k)
  • 最优:O(n+k)
  • 最坏:O(n+k)

8.2.2 空间复杂度

    O(n+k)

8.2.3 稳定性

    稳定

8.3 算法实现

    /**
     * 计数排序
     *
     * @param array
     * @return
     */
    public void countingSort(int[] array) {
        int min = array[0], max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] < min) {
                min = array[i];
            } else if (array[i] > max) {
                max = array[i];
            }
        }
        int length = max - min + 1;
        int[] temp = new int[length];
        for (int item : array) {
            temp[item - min]++;
        }
        int index = 0;
        for (int i = 0; i < temp.length; i++) {
            while (temp[i] > 0) {
                temp[i]--;
                array[index++] = i + min;
            }
        }
    }

9 桶排序

9.1 算法描述

  • 设置一个定量的数组当作空桶,桶的范围是最大值和最小值的差值除桶数量;
  • 遍历输入数据,并且把数据一个一个放到对应的桶里去;
  • 对每个不是空的桶进行插入排序;
  • 从不是空的桶里把排好序的数据拼接起来。

9.2.1 时间复杂度

  • 平均:O(n+k)
  • 最优:O(n) 都在一个桶内,并且已经排好序(插入排序的最优)
  • 最坏:O(n2) 都在一个桶内,并且已经是倒序(插入排序的最坏)

9.2.2 空间复杂度

    O(n+k)

9.2.3 稳定性

    稳定

9.3 算法实现

    /**
     * 桶排序
     *
     * @param array
     * @return
     */
    public void bucketSort(int[] array) {
        int bucketNum = 3;
        LinkedList[] linkedList = new LinkedList[bucketNum];
        int min = array[0], max = array[0];
        for (int item : array) {
            if (item < min) {
                min = item;
            } else if (item > max) {
                max = item;
            }
        }
        int bucketSize = (max - min) / bucketNum + 1;
        for (int item : array) {
            int bucketIndex = (item - min) / bucketSize;
            if (linkedList[bucketIndex] == null) {
                linkedList[bucketIndex] = new LinkedList();
            }
            LinkedList list = linkedList[bucketIndex];
            Iterator<Integer> iterator = list.iterator();
            int index = 0;
            while (iterator.hasNext()) {
                if (item < iterator.next()) {
                    break;
                }
                index++;
            }
            list.add(index, item);
        }
        int index = 0;
        for (int i = 0; i < linkedList.length; i++) {
            LinkedList<Integer> list = linkedList[i];
            if (list == null) {
                continue;
            }
            for (int item : list) {
                array[index++] = item;
            }
        }
    }

10 基数排序

10.1 算法描述

  • 设置0-19,20个数组(包括负数),
  • 先按照个位先排序,然后重新赋值到原数组;
  • 再按照高位排序,然后再重新赋值到原数组;
  • 依次类推,直到最高位。
  • 缺点:不支持小数

10.2.1 时间复杂度

  • 平均:O(n*k)
  • 最优:O(n*k)
  • 最坏:O(n*k) 

10.2.2 空间复杂度

    O(n+k)

10.2.3 稳定性

    稳定

10.3 算法实现

    /**
     * 基数排序
     *
     * @param array
     * @return
     */
    public void radixSort(int[] array) {
        int max = 0;
        for (int item : array) {
            item = item >= 0 ? item : -item;
            if (item > max) {
                max = item;
            }
        }

        LinkedList[] linkedList = new LinkedList[20];
        int down = 1;
        while (down <= max) {
            for (int item : array) {
                int remain = item / down % 10;
                int index = item >= 0 ? 10 + remain : 9 + remain;
                if (linkedList[index] == null) {
                    linkedList[index] = new LinkedList();
                }
                linkedList[index].add(item);
            }
            down *= 10;
            int index = 0;
            for (LinkedList linked : linkedList) {
                if (linked != null) {
                    Iterator<Integer> iterator = linked.iterator();
                    while (iterator.hasNext()) {
                        array[index++] = iterator.next();
                        iterator.remove();
                    }
                }
            }
        }
    }

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值