Day33-数据结构与算法-排序

最新推荐文章于 2022-04-04 20:51:05 发布
最新推荐文章于 2022-04-04 20:51:05 发布
阅读量420 收藏
点赞数
分类专栏： 数据结构与算法 Java 文章标签： 快速排序 堆排序 归并排序 希尔排序 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38205875/article/details/111180909
版权

title: Day33-数据结构与算法-排序
date: 2020-11-30 18:21:36
author: 子陌

  1. 常用的经典数据结构（例如：二叉树、哈希表、Trie等）
  2. 更高级的数据结构（例如：图、并查集、跳表、布隆过滤器等）与各种算法（例如：排序、KMP、贪心、分治、动态规划等）
  3. 刷题LeetCode和算法真题（海量数据处理、字符串处理）

第二季

常用的经典数据结构

10大排序算法

十大排序算法

  • 以上表格是基于数组进行排序的一般性结论
  • 冒泡、选择、插入、归并、快速、希尔、堆排序，属于比较排序（Comparison Sorting）

排序算法的稳定性

  • 如果相等的两个元素，在排序前后的相对位置保持不变，那么这是稳定的排序算法
    • 排序前：5，1，3a，4，7，3b
    • 稳定排序：1，3a，3b，4，5，7
    • 不稳定排序：1，3b，3a，4，5，7
  • 对自定义对象进行排序时，稳定性会影响最终的排序效果

原地算法（In-place Algorithm）

  • 不依赖额外的资源或者依赖少数的额外资源，仅仅依靠输出来覆盖输入
  • 空间复杂度为O(1)的都可以认为是原地算法

非原地算法（Not-In-place or Out-of-place）

排序公共基类抽取

package com.zimo.算法.排序.基类;

import java.text.DecimalFormat;

/**
 * 抽象排序基类
 *
 * @author Liu_zimo
 * @version v0.1 by 2020/12/1 16:49
 */
public abstract class Sort<E extends Comparable<E>> implements Comparable<Sort<E>> {
    protected E[] array;  // 排序数组
    private int cmpCount;       // 比较次数
    private int swapCount;      // 交换次数
    private long time;          // 耗时

    private DecimalFormat fmt = new DecimalFormat("#.00");
	// 提供外部使用排序
    public void sort(E[] array){
        if (array == null || array.length < 2){
            return;
        }
        this.array = array;
        long start = System.currentTimeMillis();
        sort();
        time = System.currentTimeMillis() - start;
    }
	// 子类排序算法实现
    protected abstract void sort();

    protected int cmp(int i1, int i2){
        cmpCount++;
        return array[i1].compareTo(array[i2]);
    }
    protected int cmp(E v1, E v2){
        cmpCount++;
        return v1.compareTo(v2);
    }

    protected void swap(int i1, int i2){
        swapCount++;
        E tmp = array[i1];
        array[i1] = array[i2];
        array[i2] = tmp;
    }

    private String numberString(int number){
        if (number < 10000) return "" + number;
        if (number < 100000000) return fmt.format(number / 10000.0) + "万";
        return fmt.format(number / 100000000.0) + "亿";
    }

    @Override
    public String toString() {
        String timeStr ="耗时: " + (time / 1000.0) + "s(" + time + "ms)";
        String compareCountStr = "比较: " + numberString(cmpCount);
        String swapCountStr = "交换: " + numberString(swapCount);
        return "【" + getClass().getSimpleName() + "】\n"
                + timeStr + "\t"
                +compareCountStr +"\t "+swapCountStr + "\n"
                +"----------------------------------------------------";
    }
}

冒泡排序（Bubble Sort）

冒泡排序也叫做起泡排序，冒泡排序属于稳定的排序算法，稍有不慎，稳定的算法可能写成不稳定的排序算法（如果a <= b交换就是不稳定的），冒泡排序属于in-place

  • 执行流程
    1. 从头开始比较每一对相邻元素，如果第一个比第二个(大/小)，就交换他们的位置
      • 执行一轮后，最末尾的那个元素就是最(大/小)元素
    2. 忽略1中曾经找到的最(大/小)元素，重复执行步骤1，直到全部有序

优化：（标记交换位置）

  1. 如果序列已经完全有序，可以提前终止冒泡排序
  2. 如果序列尾部已经局部有序，可以记录最后一次交换的位置，减少比较次数
package com.zimo.算法.排序.冒泡排序;

/**
 * 冒泡排序
 *
 * @author Liu_zimo
 * @version v0.1 by 2020/12/1 10:47
 */
public class BubbleSort {
    public static int[] sort(int[] arr){
        if (arr == null || arr.length < 2){
            return arr;
        }
        int length = arr.length;
        for (int i = length - 1; i > 0; i--) {
            int sortedIndex = 1;  // 初始值为完全有序时候用，就不会进入if，索引不会覆盖，一轮扫描直接结束
            for (int j = 1; j <= i; j++) {
                if (arr[j] < arr[j - 1]){
                    arr[j] = arr[j] ^ arr[j - 1];
                    arr[j - 1] = arr[j] ^ arr[j - 1];
                    arr[j] = arr[j] ^ arr[j - 1];
                    sortedIndex = j; // 记录最后一次交换的位置
                }
            }
            i = sortedIndex;
        }
        return arr;
    }
}

选择排序（Selection Sort）

  • 执行流程
    1. 从序列中找出最(小/大)的那个元素，然后与最(头/尾)的元素交换位置
      • 执行一轮后，最(头/尾)的那个元素就是最(小/大)的元素
    2. 忽略1中曾经找到的最(小/大)元素，重复执行步骤1
  • 选择排序的交换次数要远远少于冒泡排序，平均性能优于冒泡排序
  • 最好、最坏、平均时间复杂度：O(n²)，空间复杂度：O(1)，属于不稳定排序（链表排序除外）

优化：（堆）

  • 使用堆来选择最大值
package com.zimo.算法.排序.选择排序;

/**
 * 选择排序
 *
 * @author Liu_zimo
 * @version v0.1 by 2020/12/1 14:32
 */
public class SelectionSort {
    public static int[] sort(int[] arr){
        if (arr == null || arr.length < 2){
            return arr;
        }
        int length = arr.length;
        for (int i = length - 1; i > 0; i--) {
            int maxIndex = 0;
            for (int j = 1; j <= i; j++) {
                if (arr[maxIndex] <= arr[j]){   // 为了使算法稳定，这里使用<=
                    maxIndex = j; // 记录最大的位置索引
                }
            }
            int tmp = arr[i];
            arr[i] = arr[maxIndex];
            arr[maxIndex] = tmp;
        }
        return arr;
    }
}

堆排序（Heap Sort）

  • 堆排序可以认为是对选择排序的一种优化
  • 执行流程
    1. 对序列进行原地建堆（heapify）
    2. 重复执行以下操作，直到堆的元素数量为1
      • 交换堆顶元素与尾元素
      • 对的元素数量减1
      • 对0位置进行1次siftDown操作
  • 最好、最坏、平均时间复杂度：O(nlogn)，空间复杂度：O(1)，属于不稳定排序

堆排序

package com.zimo.算法.排序.堆排序;

/**
 * 堆排序
 *
 * @author Liu_zimo
 * @version v0.1 by 2020/12/1 15:16
 */
public class HeapSort {
    private static int heapSize;   // 堆的剩余数量
    public static int[] sort(int[] arr){
        if (arr == null || arr.length < 2){
            return arr;
        }
        heapSize = arr.length;
        // 原地建堆
        for (int i = (heapSize >> 1) - 1; i >= 0; i--){
            siftDown(i, arr);
        }
        while (heapSize > 1){
            int tmp = arr[0];   // 交换堆顶和尾部元素
            arr[0] = arr[heapSize - 1];
            arr[heapSize - 1] = tmp;
            heapSize--; 
            siftDown(0, arr);
        }
        return arr;
    }
	// 自下而上的下滤
    private static void siftDown(int index, int[] elements) {
        Integer element = elements[index];
        int half = heapSize >> 1;
        while(index < half) {
            int childIndex = (index << 1) + 1;
            Integer childElement = elements[childIndex];
            int rightIndex = childIndex + 1;
            if (rightIndex < heapSize && elements[rightIndex] > childElement){
                childElement = elements[childIndex = rightIndex];
            }
            if (element >= childElement)break;
            elements[index] = childElement;
            index = childIndex;
        }
        elements[index] = element;
    }
}

二分搜索（Binary Search）

  • 确定一个元素在数组中的位置：

    1. 如果是无序数组，从0开始遍历搜索，平均时间复杂度：O(n)
    2. 如果是有序数组，可以使用二分搜索，最坏时间复杂度：O(logn)

  • 假设在[begin，end)范围内搜索某个元素v，mid == （begin + end）/ 2

    1. 如果 v < m，去[begin，mid)范围内二分搜索
    2. 如果 v > m，去[mid + 1，end)范围内二分搜索
    3. 如果 v == m，直接返回mid
    4. 当begin == end时，查找失败

  • 区间设计成左闭右开时，end - begin就可以得到区间元素个数

  • 如果存在多个重复值，返回值不确定

package com.zimo.算法;

/**
 * 二分查找
 *
 * @author Liu_zimo
 * @version v0.1 by 2020/12/2 16:30
 */
public class BinarySearch {
    public static int indexOf(int[] array, int v){
        if (array == null || array.length == 0) return -1;
        // 设计成左闭右开时， end - begin就是区间元素的数量
        int begin = 0;
        int end = array.length;
        while (begin < end){
            int mid = (begin + end) / 2;
            if (v < array[mid]){
                end = mid;
            }else if (v > array[mid]){
                begin = mid + 1;
            }else {
                return mid;
            }
        }
        return -1;
    }
}

插入排序（Insertion Sort）

类似扑克牌的排序

  • 执行流程
    1. 在执行过程中，插入排序会将序列分为2部分
      • 头部是已经排好序的，尾部是待排序的
    2. 从头开始扫描每一个元素
      • 每当扫描到一个元素，就将它插入到头部合适的位置，使得头部数据依然保持有序
package com.zimo.算法.排序.插入排序;

/**
 * 插入排序
 *
 * @author Liu_zimo
 * @version v0.1 by 2020/12/2 14:03
 */
public class InsertionSort {
    public static int[] sort(int[] arr){
        if (arr == null || arr.length < 2){
            return arr;
        }
        for (int i = 1; i < arr.length; i++) {
            int current = i;
            for (int j = current - 1; j >= 0; j--) {
                if (arr[current] < arr[j]){
                    int tmp = arr[current];
                    arr[current] = arr[j];
                    arr[j] = tmp;
                    current--;
                }
            }
        }

        return arr;
    }
}

插入排序 - 逆序对（Inversion）

  • 数组<2,3,8,6,1>的逆序对为：<2,1> <3,1> <8,1> <6,1>，共5个逆序对
  • 插入排序的时间复杂度与逆序对的数量成正比关系
    • 逆序对的数量越多，插入排序的时间复杂度就越高
  • 最坏、平均时间复杂度：O(n²)
  • 最好时间复杂度：O(n)
  • 空间复杂度：O(1)
  • 属于稳定排序
  • 当逆序对的数量极少时，插入排序的效率特别高
    • 甚至速度比O(nlogn)级别的快速排序还要快
  • 数据量不是特别大的时候，插入排序的效率也是非常好的

优化一：（挪动优化）

  • 将交换转为挪动
    1. 先将待插入的元素备份
    2. 头部有序数据中比待插入元素大的，都朝尾部方向挪动1个位置
    3. 将待插入元素放到最终核实的位置
for (int i = 1; i < arr.length; i++) {
    int current = i;
    int element = arr[current];     	// 把要插入的元素缓存下来
    for (int j = current - 1; j >= 0; j--) {
        if (element < arr[j]){			// element一直往前比较
            arr[current--] = arr[j];	// 如果大先往后挪
        }
    }
    arr[current] = element;				// 全部比较晚再覆盖
}

优化二：（二分搜索优化）

  • 在元素v的插入过程中，可以先二分搜索出最合适的插入位置，然后再将元素v插入
  • 要求二分搜索返回的插入位置：第一个大于v的元素位置
package com.zimo.算法.排序.插入排序;

import com.zimo.算法.排序.基类.Sort;

/**
 * 插入排序 - 重构（二分查找优化版）
 *
 * @author Liu_zimo
 * @version v0.1 by 2020/12/2 17:13
 */
public class InsertionSortRe1<E extends Comparable<E>> extends Sort<E> {
    @Override
    protected void sort() {
        for (int i = 1; i < array.length; i++) {
            E element = array[i];
            int insertIndex = search(i);
            for (int j = i; j > insertIndex; j--){
                array[j] = array[j-1];
            }
        }
    }

    private int search(int index){
        int begin = 0;
        int end = index;
        while (begin < end){
            int mid = (begin + end) >> 1;
            if (cmp(array[index], array[mid]) < 0){
                end = mid;
            }else{
                begin = mid + 1;
            }
        }
        return begin;
    }
    @Override
    public int compareTo(Sort<E> eSort) {
        return 0;
    }
}
  • 使用了二分搜索后，只是减少了比较次数，但是插入排序的平均时间复杂度依然是O(n²)

归并排序（Merge Sort）

  • 1945年由约翰·冯诺依曼（John von Neumann）首次提出

  • 执行流程

    1. 不断地将当前序列平均分割成2个子序列

      直到不能再分割（序列中只剩1个元素）

    2. 不断地将2个子序列合并成一个有序序列

      直到最终只剩下1个有序序列

归并排序

归并排序 - merge细节

  • 需要merge的2组序列在于同一个数组中，并且是挨在一起的
  • 为了更好地完成merge操作，最好将其中1组序列备份出来，比如[begin，mid)
  • 左边先结束，不用做任何操作
  • 右边先结束，把左边剩下的挪到数组中去

归并排序-merge

package com.zimo.算法.排序.归并排序;

import com.zimo.算法.排序.基类.Sort;

/**
 * 归并排序
 *
 * @author Liu_zimo
 * @version v0.1 by 2020/12/2 18:26
 */
public class MergeSort<E extends Comparable<E>> extends Sort<E> {
    private E[] leftArray;  // 直接开辟最大的左边数组，循环利用，避免merge重复开销
    @Override
    protected void sort() {
//        leftArray = (E[]) new Object[array.length >> 1];
        leftArray = (E[]) new Comparable[array.length >> 1];    // 数组必须具备可比较性
        divide(0, array.length);
    }

    /**
     * 对[begin,end)范围的数据进行归并排序(拆分)
     * @param begin
     * @param end
     */
    private void divide(int begin, int end) {
        if (end - begin < 2) return;
        int mid = (begin + end) >> 1;   // 对数组进行拆分
        divide(begin, mid);             // [begin, leng/2)
        divide(mid, end);               // [leng/2, end)
        merge(begin, mid, end);
    }

    /**
     * 将 [begin, mid)和[mid, end)范围的序列合并成一个有序序列（合并）
     * @param begin
     * @param mid
     * @param end
     */
    private void merge(int begin, int mid, int end) {
        int leftIndex = 0, leftEnd = mid - begin;   // 左边数组（基于leftArray）
        int rightIndex = mid, rightEnd = end;       // 右边数组
        int currentIndex = begin;                   // array索引

        // 备份左边的数组
        for (int i = leftIndex; i < leftEnd; i++) {
            this.leftArray[i] = this.array[begin + i];
        }

        // 如果左边没结束，就继续操作
        while (leftIndex < leftEnd){
            if (rightIndex < rightEnd && cmp(array[rightIndex], leftArray[leftIndex]) < 0){
                array[currentIndex++] = array[rightIndex++];      // 拷贝右边数组到array
            }else {
                array[currentIndex++] = leftArray[leftIndex++]; // 拷贝左边数组到array
            }   // 如果cmp位置改为 <= 0 会失去稳定性
        }
    }

    @Override
    public int compareTo(Sort<E> eSort) {
        return 0;
    }
}
  • 归并排序花费的时间
    • T(n) = 2 * T(n/2) + O(n)
    • T(1) = O(1)
    • T(n)/n = T(n/2)/(n/2) + O(1)
  • 令S(n) = T(n) / n
    • S(1) = O(1)
    • S(n) = S(n/2) + O(1) = S(n/4) + O(2) = S(n/8) + O(3) = S(n/2k) + O(k) = S(1) + O(logn) = O(logn)
  • 由于归并排序总是平均分割子序列，所以最好、最坏、平均时间复杂度都是O(nlogn)，属于稳定排序
  • 从代码上不难看出：归并排序的空间复杂度是O(n/2 + logn) = O(n)
递推式复杂度
T(n) = T(n / 2) + O(1)O(logn)
T(n) = T(n - 1) + O(1)O(n)
T(n) = T(n / 2) + O(n)O(n)
T(n) = 2 * T(n / 2) + O(1)O(n)
T(n) = 2 * T(n / 2) + O(n)O(nlogn)
T(n) = T(n - 1) + O(n)O(n²)
T(n) = 2 * T(n - 1) + O(1)O(2n)
T(n) = 2 * T(n - 1) + O(n)O(2n)

快速排序（Quick Sort）

1960年由查尔斯·安东尼·理查德·霍尔（Charles Antony Richard Hoare），昵称为东尼·霍尔（Tony Hoare）

  • 执行流程
    1. 从序列中选择一个轴点元素（pivot）
      • 假设每次选择0位置的元素为轴点元素
    2. 利用pivot将序列分割成2个子序
      • 将小于pivot的元素放在pivot前面（左侧）
      • 将大于pivot的元素防止pivot后面（右侧）
      • 等于pivot的元素放哪边都可以
    3. 对子序列进行1，2操作
      • 直到不能再分割（子序列中只剩下1个元素）
  • 快速排序的本质
    • 逐渐将每个元素都转换成轴点元素

快速排序

快速排序 - 执行流程

快速排序-轴点构造

快速排序 - 轴点相等的元素

轴点相等的元素

  • 如果序列中的所有元素都与轴点元素相等，利用目前的算法实现，轴点元素可以将序列分割成2个均匀的子序列
package com.zimo.算法.排序.快速排序;

import com.zimo.算法.排序.基类.Sort;

/**
 * 快速排序
 *
 * @author Liu_zimo
 * @version v0.1 by 2020/12/9 15:22:59
 */
public class QuickSort<E extends Comparable<E>> extends Sort<E> {

    @Override
    protected void sort() {
        sort(0, array.length);
    }

    /**
     * 对[begin, end)范围的元素进行快速排序
     * @param begin
     * @param end
     */
    private void sort(int begin, int end){
        if (end - begin < 2) return;
        // 确定轴点的位置
        int pivotIndex = pivotIndex(begin, end);
        // 对子序列进行排序
        sort(begin, pivotIndex);
        sort(pivotIndex + 1, end);
    }

    /**
     * 构造出[begin, end)范围的轴点元素
     * @return 返回轴点元素的最终位置
     */
    private int pivotIndex(int begin, int end){
        // 优化一：将轴点随机化，原先固定begin位置就是轴点
        // [0,1) * (end - begin) + begin = [0 + begin, (end-begin) + begin)
        int random = (int) Math.random() * (end - begin) + begin;
        swap(begin, random);

        // 备份begin位置的元素
        E pivot = array[begin];
        end--;

        while (begin < end){
            while (begin < end) {
                // 从右往左
                if (cmp(pivot, array[end]) < 0) {    // 右边元素 > 轴点元素
                    end--;
                } else {     // 右边元素 <= 轴点元素
                    this.array[begin++] = array[end];
                    break;  // 交替执行
                }	// 如果条件变成 <= 切割出来的轴点会导致不均匀
            }
            while (begin < end) {
                // 从左往右
                if (cmp(pivot, array[begin]) > 0) {  // 左边元素 < 轴点元素
                    begin++;
                } else {     // 左边元素 >= 轴点元素
                    this.array[end--] = array[begin];
                    break;  // 交替执行
                }	// 如果条件变成 >= 切割出来的轴点会导致不均匀
            }
        }
        // 将轴点元素翻入最终位置
        array[begin] = pivot;
        // 返回轴点元素的位置begin或者end
        return begin;
    }

    @Override
    public int compareTo(Sort<E> eSort) {
        return 0;
    }
}

优化：（随机选择轴点，降低左右两边数量不均匀）

  • 轴点元素分割出来的子序列嫉妒不均匀
    • 导致出现最坏的时间复杂度O(n²)

时间复杂度

  • 在轴点左右元素数量比较均匀的情况下，同时也是最好的情况
    • T(n) = 2 * T(n/2) + O(n) = O(nlogn)
  • 如果轴点左右元素数量极度不均匀，最坏情况
    • T(n) = T(n - 1) ＋ O(n) = O(n²)
  • 为了降低最坏情况的出现概率，一般采取的做法是
    • 随机选择轴点元素
  • 最好、平均时间复杂度：O(nlogn)
  • 最坏时间复杂度：O(n²)
  • 由于递归调用的缘故，空间复杂度：O(logn)

希尔排序（Shell Sort）

  • 1959年由唐纳德·希尔（Donald Shell）提出
  • 希尔排序把序列看作是一个矩阵，分成m列，逐列进行排序
    • m从某个整数逐渐减为1
    • 当m为1时，整个序列将完全有序
  • 因此，希尔排序也被称为递减增量排序(Diminishing Increment Sort)
  • 矩阵的列数取决于步长序列（step sequence）
    • 比如，如果步长序列为{1，5，19，41，109，…}，就代表一次分成109列、41列、19列、5列、1列进行排序
    • 不同的步长序列，执行效率也不同

希尔排序 - 实例

  • 希尔本人给出的步长序列是(n / 2k)，比如n为16时，步长序列是{1，2，4，8}

希尔排序

  • 不难看出，从8列变为1列的过程中，逆序对的数量在逐渐减少

    • 因此希尔排序底层一般使用插入排序对每一列进行排序，也很多资料认为希尔排序是插入排序的改进版

  • 假设元素在第col列、第row行，步长（总列数）是step

    • 那么这个元素在数组中的索引是col + row * step

希尔排序 - 实现

  • 最好情况是步长序列只有1，且序列几乎有序，事件复杂度为O(n)
  • 空间复杂度为O(1)
  • 不属于稳定排序
  • 希尔本人给出的步长序列，最坏情况事件复杂度是O(n²)
package com.zimo.算法.排序.希尔排序;

import com.zimo.算法.排序.基类.Sort;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 希尔排序
 *
 * @author Liu_zimo
 * @version v0.1 by 2020/12/11 10:22:58
 */
public class ShellSort<E extends Comparable<E>> extends Sort<E> {

    @Override
    protected void sort() {
        List<Integer> stepSequence = shellStepSequence();
        for (Integer step: stepSequence) {
            sort(step);
        }
    }

    /**
     * 分成step列进行排序
     * @param step
     */
    private void sort(int step){
        for (int col = 0; col < step; col++) {  // 对第col列进行排序
            for (int begin = col + step; begin < array.length; begin+=step) {  // 插入排序算法
                int cur = begin;
                while (cur > col && cmp(cur, cur - step) < 0){
                    swap(cur, cur - step);
                    cur -= step;
                }
            }
        }
    }
    // 希尔给出的步长序列 n / 2^k ， 最坏情况O(n²)
    private List<Integer> shellStepSequence(){
        List<Integer> list = new ArrayList<>();
        int step = array.length;
        while ((step >>= 1) > 0){
            list.add(step);
        }
        return list;
    }
    // 目前最好的步长
    private List<Integer> bestStepSequence(int count){  // count：数据规模 array.length,最坏情况O(n的1.33..次方)
        List<Integer> list = new ArrayList<>();
        int k = 0, step = 0;
        while (true){
            if (k % 2 == 0){
                int pow = (int) Math.pow(2, k >> 1);
                step = 1 + 9 * (pow * pow - pow);
            }else {
                int pow1 = (int) Math.pow(2, (k - 1) >> 1);
                int pow2 = (int) Math.pow(2, (k + 1) >> 1);
                step = 1 + 8 * pow1 * pow2 - 6 * pow2;
            }
            if (step >= count) break;
            list.add(0, step);
            k++;
        }
        return list;
    }

    @Override
    public int compareTo(Sort<E> eSort) {
        return 0;
    }
}
  • 目前已知最好的步长序列，最坏情况事件复杂度是O(n4/3)，1986年由Robert Sedgewick提出
    • K（整数）从0开始
      • K为偶数：9(2k - 2k/2) + 1
      • K为奇数：8 + 2k - 6 · 2(k + 1) / 2 + 1
    • 1，5，19，41，109

计数排序（Counting Sort）

  • 之前学习的冒泡、选择、插入、归并、快速、希尔、堆排序，都是基于比较的排序
    • 平均时间复杂度目前最低是O(nlogn)
  • 计数排序、桶排序、基数排序，都不是基于比较的排序
    • 它们是典型的用空间换时间，在某些时候，平均时间复杂度可以比O(nlogn)更低
  • 计数排序于1954年由Harold H.Seward提出，适合对一定范围内的整数进行排序
  • 计数排序的核心思想
    • 统计每个整数在序列中出现的次数，进而推导出每个整数在有序序列中的索引

计数排序最简单的实现

计数排序简单实现

protected void sort() {
    // 找出最大值
    int max = array[0];
    for (int i = 1; i < array.length; i++) {
        if (array[i] > max) max = array[i];
    }
    // 开辟内存空间,存储每个整数出现次数
    int[] counts = new int[1 + max];
    // 统计每个整数出现的次数
    for (int i = 0; i < array.length; i++) {
        counts[array[i]]++;
    }
    // 根据整数的出现次数，对整数进行排序
    int index = 0;
    for (int i = 0; i < counts.length; i++) {
        if (counts[i] > 0) {
            while (counts[i]-- > 0) {
                array[index++] = i;
            }
        }
    }
}
  • 该版本的实现存在以下几个问题
    • 无法对负整数进行排序
    • 极其浪费内存空间
    • 是个不稳定的排序
    • 只能对整数进行排序
    • …

计数排序改进版

  • 优化：
    • 内存空间：min - max
    • 对负整数进行排序

计数排序优化

package com.zimo.算法.排序.计数排序;

import com.zimo.算法.排序.基类.Sort;

/**
 * 计数排序 - 改进版
 *      1. 优化内存空间
 *      2. 可以对负数进行排序
 *      3. 是个稳定的排序
 *
 * @author Liu_zimo
 * @version v0.1 by 2020/12/11 15:33
 */
public class CountingSortRe extends Sort<Integer> {

    @Override
    protected void sort() {
        // 找出最大值和最小值
        int max = array[0];
        int min = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) max = array[i];
            if (array[i] < min) min = array[i];
        }
        // 开辟内存空间,存储次数
        int[] counts = new int[max - min + 1];
        // 统计每个数出现的次数
        for (int i = 0; i < array.length; i++) {
            counts[array[i] - min]++;
        }
        // 累加次数
        for (int i = 1; i < counts.length; i++) {
            counts[i] += counts[i-1];
        }
        // 从后往前遍历元素，将它放到有序数组中的合适位置（从后往前修复排序稳定）
        int[] newArray = new int[array.length];
        for (int i = array.length - 1; i >= 0; i--) {
            int count = --counts[array[i] - min];
            newArray[count] = array[i];
        }
        // 将有序数组复制到array中
        for (int i = 0; i < newArray.length; i++) {
            array[i] = newArray[i];
        }
    }

    @Override
    public int compareTo(Sort<Integer> integerSort) {
        return 0;
    }
}
  • 最好、最坏、平均时间复杂度：O(n + k)
  • 空间复杂度：O(n + k)
  • k是整数的取值范围

计数排序对自定义对象进行排序

  • 如果自定义对象可以提供用以排序的整数类型，依然可以使用计数排序（例如：Person.age按人的年龄进行排序）

基数排序（Radix Sort）

  • 基数排序非常适合用于整数排序（尤其是非负整数)，因此只演示对非负整数进行基数排序
  • 执行流程：依次对个位数、十位数、百位数、千位数、万位数…进行排序(从低位到高位)
  • 个位数、十位数、百位数的取值范围都是固定的0~9，可以使用计数排序对它们进行排序

基数排序

package com.zimo.算法.排序.基数排序;

import com.zimo.算法.排序.基类.Sort;

/**
 * 基数排序
 *
 * @author Liu_zimo
 * @version v0.1 by 2020/12/14 14:48
 */
public class RadixSort extends Sort<Integer> {
    @Override
    protected void sort() {
        // 找出最大值
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) max = array[i];
        }
        for (int divider = 1; divider <= max; divider *= 10) {
            countingSort(divider);
        }
    }

    private void countingSort(int devider){
        // 开辟内存空间,存储次数 0 - 9 min = 0
        int[] counts = new int[10];
        // 统计每个数出现的次数
        for (int i = 0; i < array.length; i++) {
            counts[array[i] / devider % 10]++;
        }
        // 累加次数
        for (int i = 1; i < counts.length; i++) {
            counts[i] += counts[i-1];
        }
        // 从后往前遍历元素，将它放到有序数组中的合适位置（从后往前修复排序稳定）
        int[] newArray = new int[array.length];
        for (int i = array.length - 1; i >= 0; i--) {
            int count = --counts[array[i] / devider % 10];
            newArray[count] = array[i];
        }
        // 将有序数组复制到array中
        for (int i = 0; i < newArray.length; i++) {
            array[i] = newArray[i];
        }
    }

    @Override
    public int compareTo(Sort<Integer> integerSort) {
        return 0;
    }
}
  • 最好、最坏、平均时间复杂度：O(d * (n + k))，d是最大值的位数，k是进制。属于稳定排序
  • 空间复杂度：O(n + k)，k是进制

基数排序另一种思路

基数排序1

protected void sort() {
    // 找出最大值
    int max = array[0];
    for (int i = 1; i < array.length; i++) {
        if (array[i] > max) max = array[i];
    }
    //桶数组
    int[][] buckets = new int[10][array.length];
    //每个桶的元素数量
    int[] bucketSizes = new int[buckets.length];
    for (int divider = 1; divider <= max; divider *= 10){
        for (int i = 0; i < array.length; i++){
            int no = array[i] / divider % 10;
            buckets[no][bucketSizes[no]++] = array[i];      // 将数组元素放到对应的桶里面
        }
        int index = 0;
        for (int i = 0; i < buckets.length; i++){
            for (int j =0; j < bucketSizes[i];j++){
                array[index++] = buckets[i][j];     // 桶里面取出数据放到数组中
            }
            bucketSizes[i] = 0;
        }
    }
}
  • 空间复杂度是O(kn + k)，时间复杂度是O(dn)
  • d是最大值的位数，k是进制

桶排序（Bucket Sort）

  • 执行流程
    1. 创建一定数量的桶（比如用数组、链表作为桶)
    2. 按照一定的规则（不同类型的数据，规则不同），将序列中的元素均匀分配到对应的桶
    3. 分别对每个桶进行单独排序
    4. 将所有非空桶的元素合并成有序序列
  • 元素在桶中的索引
    • 元素值 * 元素数量

桶排序

package com.zimo.算法.排序.桶排序;

import com.zimo.算法.排序.基类.Sort;

import java.util.LinkedList;
import java.util.List;

/**
 * 桶排序
 *
 * @author Liu_zimo
 * @version v0.1 by 2020/12/14 17:10
 */
public class BucketSort extends Sort<Double> {
    @Override
    protected void sort() {
        //桶数组
        List<Double>[] buckets = new List[array.length];
        for (int i = 0; i <array.length; i++){
            int bucketIndex = (int) (array[i] * array.length);
            List<Double> bucket = buckets[bucketIndex];
            if (bucket == null){
                bucket = new LinkedList<>();
                buckets[bucketIndex] = bucket;
            }
            bucket.add(array[i]);
        }
        //对每个桶进行排序
        int index = 0;
        for (int i = 0; i < buckets.length; i++){
            if (buckets[i] == null) continue;
            buckets[i].sort(null);
            for (Double d : buckets[i]){
                array[index++] = d;
            }
        }
    }

    @Override
    public int compareTo(Sort<Double> sort) {
        return 0;
    }
}
  • 空间复杂度是：O(n + m)，m是桶的数量
  • 时间复杂度：O(n) + m * O((n/m) * log(n/m)) = O(n + n * log(n/m)) = O(n + n * logn - n * logm)
    • 因此为O(n + k)，k为n * logn - n * logm
柳子陌
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构与算法day19-希尔排序算法
深耕java的博客
01-21 1049
基本介绍
数据结构_day05_排序算法
12-21
排序算法是计算机科学中至关重要的概念，用于组织和优化数据，使得数据按照特定的顺序排列。在本节中，我们将探讨几种常见的排序算法，包括冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序以及二分查找...
cmp的值到底是0还是1还是-1的问题
weixin_33834910的博客
12-19 842
返回值不局限于这三个数返回负数，表示第一个参数小于第二个参数返回整数，表示第一个参数大于第二个参数返回0，表示他们相等 转载于:https://www.cnblogs.com/MaxElephant/p/10143368.html...
Day561.排序算法 -数据结构和算法Java
阿昌爱Java
03-18 1077
排序算法 一、排序算法介绍 二、判断算法效率的方式 三、算法的时间复杂度 1、时间频度 案例 2、时间复杂度
Day577.堆排序 -数据结构和算法Java
阿昌爱Java
04-04 1393
堆排序 一、介绍 二、基本思想 三、图解分析 四、代码实现 package com.achang.tree; import java.util.Arrays; /** * 堆排序（升序排列：采用大顶堆方案） */ public class HeapSort { public static void main(String[] args) { int[] arr = {4, 6, 8, 5, 9}; heapSort(arr);
Day565.快速排序 -数据结构和算法Java
阿昌爱Java
03-22 1636
快速排序 一、介绍 二、示意图 三、算法思路分析 四、代码实现 package com.achang.sort; import java.util.Arrays; /** * @Author Achang * @Date 2022/3/22 22:08 * 快速排序 **/ public class QuickSort { public static void main(String[] args) { int arr[] = {-9,78,0,23,-567,70
Day564.希尔排序 -数据结构和算法Java
阿昌爱Java
03-21 1049
希尔排序 1、介绍 插入排序Plus 2、基本思想 3、排序示意图 4、交换法代码实现 //交换法 public static void shellSort1(int arr[]) { int temp = 0; //整合 for (int gap = arr.length/2 ; gap > 0 ; gap /= 2) { for (int i = gap; i < arr.length; i++) {
Day563.插入排序 -数据结构和算法Java
阿昌爱Java
03-20 560
插入排序 一、插入排序介绍 二、排序思想 三、思路图 四、代码实现 public class InsertSort { public static void main(String[] args) { int[] arr = {3,2,1}; insertSort(arr); } public static void insertSort(int[] arr){ for (int i = 1; i < arr.lengt
数据结构与算法-C版(王卓)day01
杨丙寅
03-25 2384
数据结构与算法(王卓) 视频参考于B站：数据结构与算法基础（青岛大学-王卓）。笔记仅用于个人复习、专升本备考、考研复习。 第一章 绪论 1.1 数据结构的研究内容 早期，计算机主要用于数值计算。 例1，求解梁架结构中的应力。 例2，预报人口增长情况。 随着计算机应用领域的扩展，计算机被越来越多地用于非数值计算。 例1，学生学籍管理系统。 例2，人机对弈问题。 例3，文件系统的系统结构图。 例4，地图导航——求最短路径。 综上所述： 这些问题的共性是都无法用数学的公式或方程来描述，是一些“
Day562.冒泡排序&选择排序 -数据结构和算法Java
阿昌爱Java
03-19 1012
冒泡排序 一、基本介绍 二、流程图解 三、代码实现 /** * @Author Achang * @Date 2022/3/19 16:08 * 冒泡排序 **/ public class BubbleSort { public static void main(String[] args) { int arr[] = {3,9,-1,10,-2}; //临时变量 int temp = 0; boolean flag
Java数据结构与算法 day05 排序算法
杨丙寅
05-29 2291
文章目录第六章 排序算法排序算法介绍和分类算法的时间复杂度与空间复杂度时间复杂度常见的时间复杂度空间复杂度冒泡排序基本介绍排序过程代码实现选择排序基本介绍选择排序应用实例插入排序基本介绍插入排序应用实例 第六章 排序算法 本章源码：https://github.com/name365/Java-Data-structure 排序算法介绍和分类 排序也称排序算法 (Sort Algorithm)，排序是将一组数据，依指定的顺序进行排列的过程。 排序的分类： 内部排序：指将需要处理的所有数据都加载
day009常用数据结构与算法.doc
08-19
数据结构与算法是计算机科学的基础，对于理解和优化程序性能至关重要。在Java开发中，熟练掌握各种数据结构和算法能够帮助开发者编写出更加高效、可维护的代码，同时也是面试中的常见考察点。 首先，我们要理解数据...
驱动开发视频-数据结构和算法4
02-02
文件名"数据结构和算法day2下午1.wmv"表明了这是系列教程的第二部分，下午的课程。尽管具体内容未知，但可以推测这节课可能继续深入讲解数据结构，如树和图，或者开始介绍基础的算法，如排序和搜索，结合实例帮助...
数据结构_day01_算法引入
12-21
在标题"数据结构_day01_算法引入"中，我们可以理解这是关于数据结构和算法的初步学习，主要关注算法的引入。描述中的"最坏时间复杂度"提到了性能分析，这在算法设计中至关重要，因为它决定了程序在处理大量数据时的...
驱动开发视频-数据结构和算法5
02-02
本系列的“数据结构和算法day1下午2.wmv”文件可能是课程的一部分，涵盖了第一天下午的第二部分内容。在这一部分，讲师可能深入讲解了某种或几种数据结构，如数组、链表、栈或队列，以及基础算法，如递归、分治策略...
Day01-初识Java
欢迎来到Liu_zimo的博客
08-05 619
title: Day01-初识Java date: 2020-05-18 11:29:26 author:子陌 软件开发 软件：一系列按照指定顺序组织的计算机数据和指令集合。 常见的软件： 系统软件： 如：DOS、Windows、Linux等 应用软件： 如：扫雷、腾讯QQ、360安全卫士等 人机交互 软件的出现是实现人机之间更好的交互 交互方式： 图形化界面(GUI) 命令行方式(CLI) java语言概述 是SUN公司1995年推出的一门高级语言 是一种面向Inte.
Day73--Springboot
欢迎来到Liu_zimo的博客
06-02 531
title: Day73–Springboot date: 2021-05-19 13:50:02 author: Liu_zimo SpringBoot是所有基于Spring开发的项目的起点。SpringBoot其实不是什么新的框架，它默认配置了很多框架的使用方式，就像maven整合了所有的jar包，spring boot整合了很多的技术，提供了JavaEE的大整合。 spring 官方的网站:https://spring.io/ Spring Boot概述 一般把Spring Boot称为搭建程序的.
Day02-Java编程基础
欢迎来到Liu_zimo的博客
08-05 487
title: Day02-Java基础 date: 2020-05-18 14:10:22 author:子陌 Java程序开发-- Hello World 将Java代码编写到扩展名为.java的文件中 通过javac命令对该Java文件进行编译 通过java命令对生成的class文件进行运行 class Demo { public static void main(String[] args){ System.out.println("Hello World!"); .
路西法的刷题入门手册第六期
03-22
- 本章介绍了数据结构与算法的基本概念，包括如何衡量算法的性能，如何有效利用提供的仓库资源，以及提供了一些建议来指导高效刷题，这对于理解和应用后续章节的内容至关重要。 第二章 - 基础篇 - 在基础篇中，涵盖...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

柳子陌

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值