数据结构之排序

排序方法稳定性总结 文章目录前言一、排序算法稳定性是什么?二、各个算法解析1.选择排序2.冒泡排序3.插入排序4. 归并排序5.快速排序6.堆排序7.桶排序思想的算法总结 前言 这次将介绍各种排序算法的稳定性和一些小结论 一、排序算法稳定性是什么? 它说的是,当一个排序算法对一个数组排序的时候,两个相同的数,在排序后相对位置有没有发生变化。没有则稳定 二、各个算法解析 1.选择排序 选择排序算法是不稳定的,它是先遍历一次数组,找到一个最小值,和已排好序的边界后一个元素交换。这个交换的步骤就让选择排序变得不稳定。如果交换过. 阅读详情

目录

一、概念

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.桶排序

过程分析如图所示:

【数据结构】七大排序算法(超详细) 本文详细介绍了数据结构中的七大排序算法 阅读详情

相关推荐

数据结构之——拓补排序和并查集

1.拓补排序 1.有向无环图 如果一个有向图的任意顶点都无法通过一些有向边回到自身,那么称这个有向图为有向无环图(Airected Acyclic Graph,ADG)。 2.拓补排序 拓补排序是将有向无环图G的所有顶点排成一个线性序列,使得对图G中的任意两个顶点u、v,如果存在边u->v,那么在序列中u一定在v前面。这个序列称为拓补排序。 以下图数学专业的某几门课程学习先后顺序为例,可以获知, “数学分析”是“复变函数”、“常微分方程”、“计算方法”的先导课程,“复变函数”是“实变函数”和“泛函函数

xiaoyong5854的博客 995

数据结构——【排序】详解

一. 排序💨 1.1 基本概念 排序(sorting)又称分类,就是将一组任意序列得数据元素按一定得规律进行排列(按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作),使之成为有序序列。 平时的上下文中,如果提到排序,通常指的是排升序(非降序)。 通常意义上的排序,都是指的原地排序(in place sort)。 1.2 稳定性 定义:数组 arr 中有若干元素,其中 A元素和 B元素相等,并且 A元素在 B元素前面,如果使用某种排序算法排序后,能够保证 A元素依然在 B元素的前面,可

Lucky_mzc的博客 1万+

【自考】数据结构之排序

入排序:将记录分为有序和无序区,让无序区中的记录依次插入到有序区中,并保持有序。 交换排序:两两比较待排序记录,当记录之间键值出现逆序时,则互换位置。 选择排序:每次从待排序记录中选取键值最小或最大的记录放在适当的位置。 归并排序:将两个或两个以上的有序表合并成一个有序

Dwyane 1984

数据结构——排序

数据结构Java 排序简单排序(冒泡、插入、选择),高级排序(希尔、递归、快速),排序的稳定性

m0_51530927的博客 4248

【数据结构 — 排序 — 选择排序】

数据结构 — 排序 — 选择排序

qq_73900397的博客 4586

【数据结构排序算法系列】数据结构八大排序算法

排序算法在计算机应用中随处可见,如Windows操作系统的文件管理中会自动对用户创建的文件按照一定的规则排序(这个规则用户可以自定义,默认按照文件名排序)因此熟练掌握各种排序算法是非常重要的,本博客将对数据结构中常见的八大排序算法进行详细的讲解。 写在前面的话:首先要明白在学习同类型的排序算法时,一定要明白任何相同领域存在的东西一定是竞争之后的结果,所以对于相同类型的排序之所以能够存在多种被人熟

(* ̄︶ ̄) 10万+

数据结构中的所有排序

所有数据结构中的基本排序,你都能在这里找到

2301_77213660的博客 1771

数据结构之九大排序(JAVA)

最近面临实习面试,由于自己准备投开发岗,据了解在面试中对于数据结构的考察是很重要的,其中对于查找、排序的算法考察尤为重要,所以又重回当年学习的数据结构好好复习。参考:《数据结构》 严蔚敏版、《考研数据结构》及各排序总结博客,整理出适合自己的排序总结以供参考 http://www.open-open.com/lib/view/open1453126714683.html http://www

Aka丶的博客 9468

数据结构中常见的几种排序算法

    数据结构中常见的几种排序算法 快速排序 目录 数据结构中常见的几种排序算法 快速排序 插入排序 希尔排序 归并排序 堆排序 选择排序 冒泡排序 基数排序 快速排序 基本思想: 基准分割法  a) 通过一趟排序将要排序的数据分割成独立的两部分其中一部分所有的数据要比另外的一部分数据都要小  b) 按照此方法对这两部分数据进行快速排序  案例:3 6...

qq_39380590的博客 1万+

数据结构实验六排序

数据结构实验六排序 #include #include #define Maxsize 100 using namespace std; typedef int KeyType; typedef int InfoType; typedef struct { KeyType key; InfoType otherinfo; } RedType; typ

而濡木染 3567

手把手教你为STM32设备生成自定义MAC地址(基于芯片ID的5种算法对比)

本文详细介绍了基于STM32芯片ID生成自定义MAC地址的5种算法,包括直接截取、异或折叠、CRC32哈希、自定义混合运算及SHA-256摘要。通过对比分析各算法的计算复杂度、唯一性及适用场景,帮助嵌入式开发者根据项目规模与资源,选择最合适的方案,确保设备MAC地址的唯一性与合规性。

weixin_29170327的博客 528

数据结构—排序

在数据结构中,排序是一种将数据元素重新排列的过程,通常是为了使它们按照特定的顺序(如升序或降序)组织起来。排序在计算机科学中非常重要,下面是一些常见的数据结构排序方法和它们的特点。

2302_81258662的博客 1579

LightTools手动创建菲涅尔透镜的5个实用技巧(附详细步骤图)

本文详细介绍了在LightTools中手动创建菲涅尔透镜的5个核心技巧,包括理解旋转体与折线原理、高效构建多齿轮廓、编辑优化、坐标系定位以及属性设置与验证。通过分步图解和实用策略,帮助用户突破内置工具限制,实现对非标准齿形和复杂光学设计的完全掌控,提升建模精度与仿真效率。

onion的博客 777

数据结构-排序

介绍了数据结构插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序、计数排序,并对其介绍思想、特性、时间和空间复杂度,同时用c语言实现该算法的

wrrtx的博客 1546

用InVEST做碳中和规划?手把手教你计算城市碳储量与热岛效应

本文详细介绍了如何利用InVEST模型进行城市碳中和规划的科学评估。通过手把手教学,演示了如何使用该模型的碳存储与城市热岛缓解模块,从数据准备、模型运行到结果解读,量化评估不同规划方案下的碳储量变化与热岛效应缓解潜力,为城市规划者提供科学的决策依据。

weixin_29201313的博客 823

OpenBCI脑电数据处理实战:用MNE库从Raw对象到可视化分析全流程

本文提供了使用MNE-Python库处理OpenBCI脑电数据的完整实战指南。从通过BrainFlow库获取原始数据流、创建核心的Raw对象,到进行工频滤波、带通滤波等关键预处理步骤,最后实现时域信号、功率谱密度及地形图等多种专业可视化分析,手把手教你完成脑机接口数据处理的全流程。

gin88的博客 372

数据结构:七种排序及总结

归并排序的思想是通过二分找中间值,[left,中间值] ,[中间值+1,right]两个序列再二分,直到left>=中间值,然后通过递归返回原来的函数栈帧进行排序,因为只有logn个函数栈帧,每次栈帧内最坏排n个数据。序保持不变,即在原序列中,r[i]=r[j],且r[i]在r[j]之前,而在排序后的序列中,r[i]仍在r[j]之前,则称这种排。从i=0开始遍历,每次i之前的序列都是有序的,通过判断当前i的值能够在i之前哪个位置,找到后直接插入,第一个循环是n,第二个循环最坏是n,所以是最大n^2。

jjj_mmm的博客 2311

当我们谈论Unidbg时我们在谈什么

文章目录一、前言二、使用Unidbg的工作量是什么三、补环境补的是什么3.1 运行环境缺失3.2 上下文缺失四、Unidbg 不是所有情况下最优的解决方案五、Unidbg在大多数情况下是好的方案六、Unidbg和风控无关七、尾声 一、前言 这是一篇漫谈Unidbg的文章,我对Unidbg的使用和理解都还很浅,日后会更新或修改看法,欢迎大佬指点,也期待同侪讨论。 二、使用Unidbg的工作量是什么 我们常规使用Frida + IDA的动静态分析中,工作可能是这样的 找线索→Frida Hook验证→验证成功继

lilac的博客 5790

数据结构内排序题库

网络课课后题 1、已知一组元素的排序码为(46,74,16,53,14,26,40,38,86,65,27,34),利用直接插入排序的方法(第一个数字不用插入),写出第四次向前面有序表插入一个元素后的排列结果。 解析 未插入元素前,排列结果为46 74 16 53 14 26 40 38 86 65 27 34 第一次插入74,结果为 46 74 16 53 14 26 40...

闲狗的博客 1万+

图解移动机器人中的运动规划(Motion Planning),附几十种规划算法

运动规划是移动机器人的核心理论和工程技术之一,本文作为教程先导,解析了运动规划的两大组件——路径规划和轨迹规划。欢迎感兴趣的同学订阅专栏!

FRIGIDWINTER的博客 4万+

芒果YOLOv8改进160:姿态估计Head篇:即插即用|轻量化非对称多级压缩LOADH旋转检测头,原创改进适配YOLOv8高效检测头,检测头新颖改进,全网首发独一份

芒果YOLOv8改进159:OBB旋转检测头Head篇:即插即用|轻量化非对称多级压缩LOADH旋转检测头,原创改进适配YOLOv8高效检测头,检测头新颖改进,全网首发独一份

包括YOLOv5、YOLOv7、YOLOv8等模型改进 814

数据结构之基础排序

排序即是使一串记录按照其中的某个或某些关键字大小,递增或递减排列起来的操作,其目的是提高数据的组织性以便后续的各类操作,在基础的排序算法学习中,我们会学习下面几种排序算法思想,跟着呱呱一起来学习吧!好啦,基础的排序我们就学习到这里啦,数据结构的学习离不开画图的理解,如果你在学习排序时也感觉头昏昏的,除了勤加练习,也别忘了画图好好理解哦,呱呱祝大家都能称为巨code!归并排序是建立在归并操作上的一种有效的排序算法,是采用分治法的典型应用,其将已有的子序列合并,得到完全有序的序列;

2401_87277188的博客 713

【NVMEM子系统】二、NVMEM驱动框架

该子系统整体架构不算太大,还是比较容易去理解的,下面我们一起去一探究竟!,该子系统主要用于实现EEPROMEfuse等非易失存储器的统一管理。在早期,像EEPROM驱动是存放于目录下,由于没有做到好的抽象,每次需要去访问相应内存空间,都需要去复制几乎一样的代码,去注册sysfs,这是一个相当大的抽象泄露。NVMEM子系统就是为了解决以往的抽象泄露问题。

Donge's Blog 1715

数据结构——堆排序

数据结构——堆排序 求点赞收藏评论关注!!! 感谢各位大佬!!!

2301_80401288的博客 2313

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

上一篇: 数据结构之优先级队列(堆)
下一篇: 数据结构之泛型总结
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值