数据结构之排序

最新推荐文章于 2024-07-22 02:01:15 发布
最新推荐文章于 2024-07-22 02:01:15 发布
阅读量1.2k 收藏 3
点赞数
分类专栏： 数据结构 文章标签： 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Poem_coder/article/details/124115303
版权

目录

一、概念

1.排序

2.稳定性

3.常见基于比较的排序总览

二、插入排序

三、希尔排序

四、选择排序

五、堆排序

六、冒泡排序

七、快速排序

八、归并排序

九、其他非基于比较的排序

一、概念

1.排序

排序：就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。通常意义上的排序，都是指的原地排序(in place sort)

2.稳定性

两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序算法

3.常见基于比较的排序总览

二、插入排序

1.原理：整个区间被分为①有序区间②无序区间，每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入。
过程如图所示：就拿12 5 9 4 10这组数据为例

 2.代码实现

import java.util.Arrays;

public class TestDemo {
    public static void insertSort(int[] arr) {
        for(int i = 1; i < arr.length; i++) {
            int tmp = arr[i];
            int j = i-1;
            for(; j >= 0; j--){
                if(arr[j] > tmp){//第九行
                    arr[j+1] = arr[j];
                }else{
                    //arr[j+1] = tmp;只要j回退到的时候遇到了比tmp还小的元素就结束比较
                    break;
                }
            }
            arr[j+1] = tmp;//j<0的情况
        }
    }
    public static void main(String[] args) {
        int[] arr = {12, 5, 9, 4, 10};
        insertSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}
  • 3.最坏时间复杂度：O(n^2)     平均时间复杂度（指所有可能的输入实例均以等概率出现的情况下，该算法的运行时间）：O(n^2)
【最好的情况是O(n)，即数据有序的时候】→对于直接插入排序来说，数据越有序，越快；因此，直接插入排序有时候又用于排序的优化上
  •    空间复杂度：O(1)
  •    稳定性：如果第九行没有=号就是稳定的，有=号就是不稳定的，但是一个稳定的排序可以实现为不稳定的排序，但是本身就不稳定的排序不可以实现为稳定排序，所以我们仍然认为插入排序时稳定的

4.折半插入排序

举个例子：

 代码实现：

public static void bsInsertSort(int[] array) {
    for (int i = 1; i < array.length; i++) {
        int v = array[i];
        int left = 0;
        int right = i;
        // [left, right)
        // 需要考虑稳定性
        while (left < right) {
            int m = (left + right) / 2;
            if (v >= array[m]) {
                left = m + 1;
           } else {
                right = m;
           }
       }
        // 搬移
        for (int j = i; j > left; j--) {
            array[j] = array[j - 1];
       }
       array[left] = v;
   }
}

三、希尔排序

1.原理：希尔排序(Shell's Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因 D.L.Shell 于 1959 年提出而得名。希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至 1 时，整个文件恰被分成一组，算法便终止（一般的初次取序列的一半为增量，以后每次减半，直到增量为1。）

注意：分组时，增量序列可以有各种取法，但是我们最好使增量序列中的值没有除1之外的公因子（增量序列不为1的排序称为预排序）

2.过程分析：

 3.代码实现（注意此代码和上面过程的分组不同，此代码的分组会简单很多）

import java.util.Arrays;

public class TestDemo {
    public static void shell(int[] arr,int gap){
        for(int i = gap; i < arr.length; i++){//其实此处如果写i+=5结果也是一样，但是我们需要最后一次的分组的组数为1，所以不能这么写
            int tmp = arr[i];
            int j = i - gap;
            for(; j >= 0; j -= gap){
                if(arr[j] > tmp){
                    arr[j+gap] = arr[j];
                }else{
                    break;
                }
            }
            arr[j + gap] = tmp;
        }
    }
    public static void shellSort(int[] arr){
        int gap = arr.length;//此处没有保证每组的组数都为素数
        while(gap > 1){
            shell(arr,gap);
            gap /= 2;
        }
        shell(arr,1);//保证最后一组是一组
    }
    /*public static void shellSort(int[] arr){
        int[] drr = {5, 3, 1};
        for(int i = 0; i < drr.length; i++){
            shell(arr,drr[i]);
        }
    }*/
    public static void main(String[] args) {
        int[] arr = {12,5,9,34,6,8,33,56,89,0,12,4,22,55,77};
        shellSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

4.时间复杂度：（和增量有关系）【不是说我们这个代码的时间复杂度是这个】在一定范围之内它是O(n^1.3~n^1.5)

空间复杂度：O(1)

稳定性：不稳定（在比较过程中发生了跳跃式的交换，那么就是不稳定的）

四、选择排序

1.原理：每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完 。

2.过程分析如下：

 3.代码实现

import java.util.Arrays;

public class TestDemo {
    public static void selectSort(int[] arr){
        int tmp, index;
        for(int i = 0; i < arr.length - 1; i++){
            index = i;
            for(int j = i + 1; j < arr.length; j++){
                if(arr[j] < arr[index]){
                    index = j;
                }
                tmp = arr[i];
                arr[i] = arr[index];
                arr[index] = tmp;
            }
        }
    }
    public static void main(String[] args) {
        int[] arr = {3, 5, 2, 8, 1};
        selectSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

4.时间复杂度：O(n^2)

空间复杂度：O(1)

稳定性：不稳定【6  7  6  2  8此时最小数据为2,2和6交换，6跑到6的后面，因此不稳定】

对数据的有序性不明感

5.双向选择排序

每一次从无序区间选出最小 + 最大的元素，存放在无序区间的最前和最后，直到全部待排序的数据元素排完 
public static void selectSortOP(int[] array) {
    int low = 0;
    int high = array.length - 1;
    // [low, high] 表示整个无序区间
    // 无序区间内只有一个数也可以停止排序了
    while (low <= high) {
        int min = low;
        int max = low;
        for (int i = low + 1; i <= max; i++) {
            if (array[i] < array[min]) {
                min = i;
           }
            if (array[i] > array[max]) {
                max = i;
           }
       }
        
        swap(array, min, low);
        if (max == low) {
            max = min;
       }
        swap(array, max, high);
   }
}
private void swap(int[] array, int i, int j) {
    int t = array[i];
    array[i] = array[j];
    array[j] = t; 
}

五、堆排序

之前我们在数据结构之优先级队列（堆）已经实现过堆排序，这里我们不再重复总结，此处我们总结一下它的时间复杂度、空间复杂度以及稳定性

时间复杂度：O(N*logN)

空间复杂度：O(1)

稳定性：不稳定

对数据的有序性不明感

六、冒泡排序

1.原理：在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序

2.过程分析：

 3.代码实现

import java.util.Arrays;

public class TestDemo {
    public static void bubbleSort(int[] arr){
        int tmp, flag;
        for(int i = 0; i < arr.length - 1; i++){
            flag = 1;
            for(int j = 0; j < arr.length - 1 - i; j++){
                if(arr[j] > arr[j+1]){
                    tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                    flag = 0;
                }
            }
            if(flag == 1){
                break;
            }
        }
    }
    public static void main(String[] args) {
        int[] arr = {7, 3, 66, -5, 22};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

4.时间复杂度：O(n^2)           最好的情况：O(n)【有序的情况】

空间复杂度：O(1)

稳定性：稳定

七、快速排序

1.原理：

（1）从待排序区间选择一个数，作为基准值 (pivot) ；
（2）Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可以包含相等的）放到基准值的右边；
（3）采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1 ，代表已经有序，或者小区间的长度 == 0 ，代表没有数据
2.过程分析：
（1） 挖坑法：

 

（2）Hoare 法:

①先找一个基准值，一般为第一个元素

②从后往前找第一个比基准值小的元素，从前往后找第一个比基准值大的元素，然后交换，用while循环直到找的两个位置相遇，交换基准值和相遇位置的元素

（3）前后遍历法

 3.代码实现

（1）挖坑法

import java.util.Arrays;

public class TestDemo {
    public static void quickSort(int[] arr,int left,int right){
        if(left >= right){
            return;
        }
        int pivot = partition(arr,left,right);//找到了基准
        quickSort(arr,left,pivot-1);
        quickSort(arr,pivot+1,right);
    }
    private static int partition(int[] arr,int start,int end){
        int tmp = arr[start];
        while(start < end){
            while(start < end && arr[end] >= tmp){//防止一直--下去，会有数组越界的问题，注意：此处不能不加等号，否则会出现死循环，如下图所示
                end--;
            }
            arr[start] = arr[end];
            while(start < end && arr[start] <= tmp){//防止一直++下去，会有数组越界的问题
                start++;
            }
            arr[end] = arr[start];
        }
        arr[start] = tmp;
        return start;
    }
    /*public static void test(int capacity){
        int[] arr = new int[capacity];
        for(int i = 0; i < arr.length; i++){
            arr[i] = i;
        }
        long start = System.currentTimeMillis();
        quickSort(arr,0, arr.length - 1);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }*/
    public static void main(String[] args) {
        int[] arr = {5, 1, 2, 4, 3, 6, 9, 7, 10, 8};
        quickSort(arr,0,arr.length - 1);
        //test(100_0000);
        System.out.println(Arrays.toString(arr));
    }
}

编译并运行该代码，输出如下：

 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

不加等号出现死循环的原因

此代码有一个问题，当我要排一百万个数据的时候，发生了栈溢出的错误（递归时开辟的栈太多了） 【我们可以将上面的代码的注释去掉运行一下】

 但是这也不妨碍我们计算待代码实现的快排的时间复杂度和空间复杂度

  • 时间复杂度：我们发现这个实现的过程和二叉树十分相似O(n*logn)【最好情况：每次都可以均匀的分割待排序序列】

O(n^2)【最坏情况：有序的时候】

  • 空间复杂度：O(logn)【最好情况】

O(n)【最坏情况-->单分支的一棵树】

  • 稳定性：不稳定

（2）Hoare 法:

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

（3）前后遍历法：

private static int partition(int[] array, int left, int right) { 
     int d = left + 1; 
     int pivot = array[left]; 
     for (int i = left + 1; i <= right; i++) { 
         if (array[i] < pivot) { 
             swap(array, i, d); 
             d++; 
         } 
     } 
     swap(array, d, left); 
 
     return d; 
}

4.针对栈溢出的代码优化：

基准值的选择：
①选择边上的（最左边的或最右边的）
②随机选择        缺点：有可能每次随机的数据作为基准的时候也会出现单分支的情况
③ 几数取中（例如三数取中）： array[left], array[mid], array[right] 大小是中间的为基准值
我们选择第三种方法来优化代码： 
import java.util.Arrays;

public class TestDemo {
    public static void quickSort(int[] arr,int left,int right){
        if(left >= right){
            return;
        }
        //优化如下：找到中间大小的值
        int midValIndex = findMidValIndex(arr,left,right);
        int tmp = arr[midValIndex];
        arr[midValIndex] = arr[left];
        arr[left] = tmp;
        //
        int pivot = partition(arr,left,right);//找到了基准
        quickSort(arr,left,pivot-1);
        quickSort(arr,pivot+1,right);
    }
    //优化部分：
    private static int findMidValIndex(int[] arr,int start, int end){
        int mid = start + ((end - start) >>> 1);
        if(arr[start] < arr[end]){
            if(arr[mid] < arr[start]){
                return start;
            }else if(arr[mid] > arr[end]){
                return end;
            }else{
                return mid;
            }
        }else{
            if(arr[mid] < arr[start]){
                return end;
            }else if(arr[mid] > arr[end]){
                return start;
            }else{
                return mid;
            }
        }
    }
    //
    private static int partition(int[] arr,int start,int end){
        int tmp = arr[start];
        while(start < end){
            while(start < end && arr[end] >= tmp){//防止一直--下去，会有数组越界的问题
                end--;
            }
            arr[start] = arr[end];
            while(start < end && arr[start] <= tmp){//防止一直++下去，会有数组越界的问题
                start++;
            }
            arr[end] = arr[start];
        }
        arr[start] = tmp;
        return start;
    }
    public static void test(int capacity){
        int[] arr = new int[capacity];
        for(int i = 0; i < arr.length; i++){
            arr[i] = i;
        }
        long start = System.currentTimeMillis();
        quickSort(arr,0, arr.length - 1);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    public static void main(String[] args) {
        int[] arr = {5, 1, 2, 4, 3, 6, 9, 7, 10, 8};
        quickSort(arr,0,arr.length - 1);
        test(100_0000);
        System.out.println(Arrays.toString(arr));
    }
}

编译并运行该代码，输出如下：

我们发现问题得以解决。

法二优化：我们可以在partition 过程中把和基准值相等的数也选择出来，移到跟前来，这样左右两边的递归次数就减少了

法三优化：利用直接插入排序越有序越快的规则来优化

import java.util.Arrays;

public class TestDemo {
    public static void insertSort(int[] arr,int start, int end){
        for(int i = 1; i <= end; i++){
            int tmp = arr[i];
            int j = i - 1;
            for(;j >= start; j--){
                if(arr[j] > tmp){
                    arr[j + 1] = arr[j];
                }else{
                    break;
                }
            }
            arr[j+1] = tmp;
        }
    }
    public static void quickSort(int[] arr,int left,int right){
        if(left >= right){
            return;
        }
        //如果区间内的某个数据在排序的过程中小于某个范围了，可以使用直接插入排序
        if(right - left + 1 <= 40000){
            //使用直接插入排序法
            insertSort(arr,left,right);
            return;
        }
        //优化如下：找到中间大小的值
        int midValIndex = findMidValIndex(arr,left,right);
        int tmp = arr[midValIndex];
        arr[midValIndex] = arr[left];
        arr[left] = tmp;
        //
        int pivot = partition(arr,left,right);//找到了基准
        quickSort(arr,left,pivot-1);
        quickSort(arr,pivot+1,right);
    }
    //优化部分：
    private static int findMidValIndex(int[] arr,int start, int end){
        int mid = start + ((end - start) >>> 1);
        if(arr[start] < arr[end]){
            if(arr[mid] < arr[start]){
                return start;
            }else if(arr[mid] > arr[end]){
                return end;
            }else{
                return mid;
            }
        }else{
            if(arr[mid] < arr[start]){
                return end;
            }else if(arr[mid] > arr[end]){
                return start;
            }else{
                return mid;
            }
        }
    }
    //
    private static int partition(int[] arr,int start,int end){
        int tmp = arr[start];
        while(start < end){
            while(start < end && arr[end] >= tmp){//防止一直--下去，会有数组越界的问题
                end--;
            }
            arr[start] = arr[end];
            while(start < end && arr[start] <= tmp){//防止一直++下去，会有数组越界的问题
                start++;
            }
            arr[end] = arr[start];
        }
        arr[start] = tmp;
        return start;
    }
    public static void test(int capacity){
        int[] arr = new int[capacity];
        for(int i = 0; i < arr.length; i++){
            arr[i] = i;
        }
        long start = System.currentTimeMillis();
        quickSort(arr,0, arr.length - 1);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    public static void main(String[] args) {
        int[] arr = {5, 1, 2, 4, 3, 6, 9, 7, 10, 8};
        quickSort(arr,0,arr.length - 1);
        test(100_0000);
        System.out.println(Arrays.toString(arr));
    }
}

编译并运行该代码，输出如下：

 5.非递归实现快排

利用栈。划分之后，把左右的数对都放到栈当中。前提：pivot左边有两个元素（pivot>left+1）;pivot的右边有两个元素（pivot < right-1）

如图所示：

import java.util.Arrays;
import java.util.Stack;
private static int partition(int[] arr,int start,int end){
        int tmp = arr[start];
        while(start < end){
            while(start < end && arr[end] >= tmp){//防止一直--下去，会有数组越界的问题
                end--;
            }
            arr[start] = arr[end];
            while(start < end && arr[start] <= tmp){//防止一直++下去，会有数组越界的问题
                start++;
            }
            arr[end] = arr[start];
        }
        arr[start] = tmp;
        return start;
    }

    public static void quickSort2(int[] arr){
        Stack<Integer> stack = new Stack<>();
        int left = 0;
        int right = arr.length - 1;
        int pivot = partition(arr,left,right);
        if(pivot > left + 1){//左边有两个元素
            stack.push(left);
            stack.push(pivot-1);
        }
        if(pivot < right -1){
            stack.push(pivot + 1);
            stack.push(right);
        }
        while(!stack.isEmpty()){
            right = stack.pop();
            left = stack.pop();
            pivot = partition(arr,left,right);
            if(pivot > left + 1){//左边有两个元素
                stack.push(left);
                stack.push(pivot-1);
            }
            if(pivot < right -1){
                stack.push(pivot + 1);
                stack.push(right);
            }
        }
    }
    public static void test(int capacity){
        int[] arr = new int[capacity];
        for(int i = 0; i < arr.length; i++){
            arr[i] = i;
        }
        long start = System.currentTimeMillis();
        quickSort2(arr);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    public static void main(String[] args) {
        int[] arr = {5, 1, 2, 4, 3, 6, 9, 7, 10, 8};
        quickSort2(arr);
        test(10_0000);
        System.out.println(Arrays.toString(arr));
    }
}

编译并运行该代码，输出如下：

八、归并排序

 1.原理：归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并

2.实现归并排序之前，我们先写一下合并两个有序数组的代码

import java.util.Arrays;
public class TestDemo {
    public static int[] arrayMerge(int[] arr1, int[] arr2){
        int[] arr = new int[arr1.length + arr2.length];
        int s1 = 0;
        int e1 = arr1.length-1;
        int s2 = 0;
        int e2 = arr2.length-1;
        int i = 0;
        while(s1 <= e1 && s2 <= e2){
            if(arr1[s1] <= arr2[s2]){
                arr[i++] = arr1[s1++];
            }else{
                arr[i++] = arr2[s2++];
            }
        }
        while(s1 <= e1){
            arr[i++] = arr1[s1++];
        }
        while(s2 <= e2){
            arr[i++] = arr2[s2++];
        }
        return arr;
    }
    public static void main(String[] args) {
        int[] arr1 = {0, 2, 4, 6};
        int[] arr2 = {1, 3, 5, 7};
        int[] ret = arrayMerge(arr1, arr2);
        System.out.println(Arrays.toString(ret));
    }
}

3.归并排序的过程分析

4.代码实现

import java.util.Arrays;

public class TestDemo {
    public static void mergeSort(int[] arr, int low, int high){
        if(low >= high){
            return;
        }
        int mid = low +((high - low) >>> 1);
        mergeSort(arr,low,mid);
        mergeSort(arr,mid+1,high);
        merge(arr,low,mid,high);
    }
    public static void merge(int[] arr, int low, int mid, int high){
        int i = 0;
        int[] mergeArr = new int[high - low + 1];
        int s1 = low;
        int e1 = mid;
        int s2 = mid + 1;
        int e2 = high;
        while(s1 <= e1 && s2 <= e2){
            if(arr[s1] <= arr[s2]){//第21行代码
                mergeArr[i++] = arr[s1++];
            }else{
                mergeArr[i++] = arr[s2++];
            }
        }
        while(s1 <= e1){//第27行代码
            mergeArr[i++] = arr[s1++];
        }
        while(s2 <= e2){//第30行代码
            mergeArr[i++] = arr[s2++];
        }
        for(int j = 0; j < i; j++){
            arr[j + low] = mergeArr[j];
        }
    }
    public static void main(String[] args) {
        int[] arr = {10, 6, 7, 1, 3, 9, 4, 2};
        mergeSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
}

编译并运行该代码，输出如下：

[1, 2, 3, 4, 6, 7, 9, 10]

5.时间复杂度：O(n * log(n))

空间复杂度：O(n)

稳定性：稳定 （关键看第21、27、30行代码有没有取等号，若没有取等号则不稳定）

6.非递归实现归并排序

思想和递归相类似，只不过是用循环来实现

public class TestDemo {
    public static void merge(int[] arr, int low, int mid, int high){
        int i = 0;
        int[] mergeArr = new int[high - low + 1];
        int s1 = low;
        int e1 = mid;
        int s2 = mid + 1;
        int e2 = high;
        while(s1 <= e1 && s2 <= e2){
            if(arr[s1] <= arr[s2]){
                mergeArr[i++] = arr[s1++];
            }else{
                mergeArr[i++] = arr[s2++];
            }
        }
        while(s1 <= e1){
            mergeArr[i++] = arr[s1++];
        }
        while(s2 <= e2){
            mergeArr[i++] = arr[s2++];
        }
        for(int j = 0; j < i; j++){
            arr[j + low] = mergeArr[j];
        }
    }
    public static void mergeSort2(int[] arr){
        int gap = 1;//每组的数据个数
        while(gap < arr.length){
            //数组每次都要遍历，确定归并的区间
            for (int i = 0; i < arr.length; i += gap*2) {
                int left= i;
                int mid = left + gap - 1;
                if(mid >= arr.length){//防止越界
                    mid = arr.length - 1;
                }
                int right = mid + gap;
                if(right >= arr.length){
                    right = arr.length - 1;
                }
                //下标确定后进行合并
                merge(arr,left,mid,right);
            }
            gap *= 2;
        }
    }
    public static void main(String[] args) {
        int[] arr = {10, 6, 7, 1, 3, 9, 4, 2}; 
        mergeSort2(arr);
        System.out.println(Arrays.toString(arr));
    }
}

编译并运行该代码，输出如下：

[1, 2, 3, 4, 6, 7, 9, 10]

7.海量数据排序的问题

前提：内存只有 1G ，需要排序的数据有 100G
因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序（外部排序：排序过程需要在磁盘等外部存储进行的排序）
过程：
（1）先把文件切分成 200 份，每个 512 M
（2）分别对 512 M 排序，因为内存已经可以放的下，所以任意排序方式都可以
（3）进行 200 路归并，同时对 200 份有序文件做归并过程，最终结果就有序了

九、其他非基于比较的排序

1.计数排序

代码实现：

import java.util.Arrays;

public class TestDemo {
    public static void countingSort(int[] arr){
        int maxVal = arr[0];
        int minVal = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] < minVal){
                minVal = arr[i];
            }
            if(arr[i] > maxVal){
                maxVal = arr[i];
            }
        }
        int[] count = new int[maxVal - minVal + 1];
        for (int i = 0; i < arr.length; i++) {
            int index = arr[i];
            count[index-minVal]++;//为了空间的合理使用
        }
        int indexArr = 0;
        for (int i = 0; i < count.length; i++) {
            while(count[i] > 0){
                arr[indexArr] = i + minVal;
                count[i]--;//拷贝一个，个数也就少一个
                indexArr++;
            }
        }
    }
    public static void main(String[] args) {
        int[] arr = {2,5,3,0,2,3,0,3};
        countingSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

编译并运行，输出如下：

[0, 0, 2, 2, 3, 3, 3, 5] 

时间复杂度：O(n)

空间复杂度：O(m)      m:当前数据的范围，如：900~919 范围为20

稳定性：不稳定 ，但是本质是稳定的（我们可以再引入一个数组进行操作）

2.基数排序

原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数，如图所示：

 

 我们可以把一个个的框框看成链表或者队列

3.桶排序

过程分析如图所示：

数据结构—排序
AI_ELF的博客
09-10 2071
排序方法平均情况最好情况最坏情况辅助空间稳定性冒泡排序O(N2N^2N2O(N)O(N2N^2N2O(1)稳定简单选择排序O(N2N^2N2O(N2N^2N2O(N2N^2N2O(1)不稳定直接插入排序O(N2N^2N2O(N)O(N2N^2N2O(1)稳定希尔排序O(NlogNlogNlogN∽\backsim∽O(N2N^2N2O(N1.3N^{1.3}N1.3O(N2N^2N2O(1)
【数据结构之排序系列】直接插入排序，冒泡排序，直接选择排序，堆排序，希尔排序
胡坚涛的博客
01-30 1765
排序算法章节在校招方面考察是相对比较频繁的，所以本章中所学习的所有排序算法需要引起很大的重视。需要掌握各种排序算法的时间复杂度
数据结构——排序
m0_51530927的博客
01-07 4070
数据结构Java 排序简单排序（冒泡、插入、选择），高级排序（希尔、递归、快速），排序的稳定性
数据结构--排序
草根学僧
08-14 1249
冒泡void bubble_sort(vector<int>& v){ int size = v.size(); int flag = 0; for (int i = 0; i < size-1;++i){ for (int j = i + 1; j < size;++j){ if (v[i]>v[j])
数据结构_排序
cute_shuai的博客
05-23 958
常见排序 1.插入排序：直接插入排序，希尔排序 2.选择排序：选择排序，堆排序 3.交换排序：冒泡排序，快速排序 4.归并排序：归并排序 插入排序 直接插入排序：元素越接近有序，时间效率越高 最优情况：O(N） 最差情况：O(N^2) 空间复杂度：O(1) 是一种稳定的排序算法 static void swap(int* a, int* b) { int c = *a...
c语言 数据结构 快速排序算法
04-28
c语言版本的数据结构的快速排序算法，适用于新手学习
数据结构之排序（9种）
齐梦星空
03-01 3125
概览 插入排序 直接插入排序 将数组分为两部分，前半部分有序，后半部分无序，依次从后面取数据，插入到前面指定位置。 def insertSort(nums): size = len(nums) for i in range(1, size): temp = nums[i] # 待排序的数据 count = i-1 # 代表前面有count个数据...
数据结构（Java）：七大排序算法【详解】
2401_83595513的博客
07-22 2366
七大排序算法——多方法、多实现、多优化、多细节【1.3w字详解】
数据结构学习笔记排序算法：基数排序
最新发布
09-17
数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数...
数据结构 排序
梦想之深邃
10-03 1422
知识要点： 1、插入排序法(含折半插入排序法)、选择排序法、泡排序法（冒泡排序）、快速排序法、 堆积排序法（堆排序）、归并排序、基数排序等排序方法排序的原理、规律和特点； 2、各种排序算法的时空复杂度的简单分析。 排序的稳定性：排序后不改变原序列中相同元素的相对顺序，则此排序方法是稳定的，反之是不稳定的；                          一般情况下，排序的稳定性与其效率...
数据结构：排序
2402_82667241的博客
07-09 2365
排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。内部排序：数据元素全部放在内存中的排序。外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不断地在内外存之间移动数据的排序。排序的运用：一、常见的排序算法。
数据结构：排序（1）
blexsantos的博客
10-25 1419
王争数据结构11笔记 1、冒泡排序、插入排序、选择排序是基于比较的排序。时间复杂度为。 2、快排，归并排序也是基于比较的排序。时间复杂度为 3、桶排序、计数排序、基数排序不是基于比较的排序，其时间复杂度为 4、冒泡排序BS:一次冒泡会让至少一个元素移动它应该在的位置，重复n次之后就完成了n个数据的排序工作。     每次冒泡就是把从左至右的数据中第一个相邻关系发生异常的数据摆放到正确的位...
【数据结构】排序
2301_80277275的博客
03-25 1403
各种排序(冒泡、插入、希尔、选择、堆、快速、归并、计数)的分析+代码+动图
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值