数据结构学习笔记排序 (快速，计数排序，表排序，桶排序，基数排序)

最新推荐文章于 2025-08-18 21:25:39 发布
转载 最新推荐文章于 2025-08-18 21:25:39 发布 · 106 阅读 · 0
文章标签：

#数据结构与算法

本文深入讲解了计数排序、快速排序、基数排序等经典排序算法的原理与实现，并提供了详细的代码示例。针对不同场景讨论了算法的选择及优化策略。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

layout: post
title: 数据结构学习笔记排序 (快速，表排序，基数排序)
date: 2017-05-20
tag: 数据结构和算法
---

计数排序：
该算法于1954年由 Harold H. Seward 提出。它是一个不需要比较的，类似于桶排序的线性时间排序算法。该算法是对已知数量范围的数组进行排序。其时间复杂度为O(n)，适用于小范围集合的排序。计数排序是用来排序0到100之间的数字的最好的算法。比如100万学生参加高考，我们想对这100万学生的数学成绩（假设分数为0到100）做个排序。
基本思想：对于给定的输入序列中的每一个元素x，确定该序列中值小于x的元素的个数 。一旦有了这个信息，就可以将x直接存放到最终的输出序列的正确位置上。它创建一个长度为这个数据范围的数组C，C中每个元素记录要排序数组中对应记录的出现个数。 

算法的步骤如下：
1.找出待排序的数组中最大和最小的元素
2.统计数组中每个值为i的元素出现的次数，存入数组C的第i项
3.对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）
4.反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个 元素就将C(i)减去1

目录

  • TOC
    {:toc}

快速排序

  • 不稳排序
  • 采用分而治之思想
  • 最好的情况：每次主元正好中分，T(N)=O(NlogN)
  • 最坏情况：每次主元一边倒，T(N)=O(N*N)
  • 选主元 的方法有很多，这里用 取头、中、尾的中位数。

R8F7i4u.png

  • 快速排序的之所以快：在于每次对于主元一次就可以放到指定位置
  • 小规模数据的处理：
    • 快速排序的问题：用递归……
    • 对小规模的数据（例如N不到100）可能还不如插入排序快
    • 当递归的数据规模充分小，则停止递归，直接调用简单排序（例如插入排序）在程序中定义一个Cutoff的阈值

Qsort实现

  • C:qsort();C:sort()；当时自定义的数据结构时，需要自定义实现比较函数
  • 快速排序 - 直接调用库函数

#include<stdio.h>
#define ElementType int 
void InsertionSort(ElementType A[], int N)
{
    int i;
    for (int P = 1; P<N; P ++ )
    {
        ElementType temp = A[P];//取出未排序序列中的第一个元素
        for (i = P; i >0 && A[i - 1] > temp; i--)
        {
            /* code */
            A[i] = A[i - 1]; //依次与已排序序列中元素比较并右移
        }
        A[i] = temp;
    }
}

//快速排序
ElementType Median3(ElementType A[], int Left, int Right)
{
    int Center = (Left + Right) / 2;
    int temp;
    if (A[Left] > A[Center])
    {
        temp = A[Left];
        A[Left] = A[Center];
        A[Center] = temp;
    }
    if (A[Left] > A[Right])
    {
        temp = A[Left];
        A[Left] = A[Right];
        A[Center] = temp;
    }
    if (A[Center] > A[Right])
    {
        temp = A[Center];
        A[Center] = A[Right];
        A[Right] = temp;
    }
    /*此时A[Left]<=A[Center]<=A[Right]*/
    temp = A[Center];
    A[Center] = A[Right - 1];
    A[Right - 1] = temp; //将基准Pivot藏到右边
    //只需要考虑A[Left+1]...到A[Right-2]的元素
    return A[Right - 1];
}

void Qsort(ElementType A[], int Left, int Right)
{
    /*核心递归函数*/
    int Pivot, CutOff=1000, Low, High;
    int temp;
    if (CutOff <= Right - Left)
    { //如果序列元素充分多，进入快排
        Pivot = Median3(A, Left, Right); //选基准，返回中位数
        Low = Left;
        High = Right - 1;
        while (1) //将序列中比基准小的移动到基准左边，大的移动到右边
        {
            while (A[++Low]<Pivot);
            while (A[--High]>Pivot);
            if (Low < High)
            {
                temp = A[Low];
                A[Low] = A[High];
                A[High] = temp;
            }
            else
                break;
        }
        temp = A[Low];
        A[Low] = A[Right - 1];
        A[Right - 1] = temp; //将基准换到正确的位置，快速排序之所以快，就在于一次性将元素的位置放到正确的位置

        Qsort(A, Left, Low - 1); //递归解决左边
        Qsort(A, Low + 1, Right); //递归解决右边  
    }
    else
    { 
        InsertionSort( A+Left, Right-Left+1);  //元素太少，用简单排序
    }
}

void QuickSort(ElementType A[], int N)
{
    Qsort(A, 0, N - 1); //统一接口,排序子问题的左右下标
}

int main(int argc, char const *argv[])
{
    int a[] = { 34, 8, 64, 51, 32, 21 };
    QuickSort(a, 6);
    for (int i = 0; i < sizeof(a) / sizeof(int); ++i)
    {
        /* code */
        printf("%d ", a[i]);
    }
    return 0;
}
  • 用的较多的快速排序
//快速排序 O(N*log(N))
#include <math.h>
class QuickSort {
public:
    int* quickSort(int* A, int n) {
        // write code here
        quickSort(A, 0, n - 1);
        return A;
    }
    void quickSort(int* A, int low, int high)
    {
        if (low <= high)
        {
            int part = partition(A, low, high);
            quickSort(A, low, part - 1);
            quickSort(A, part + 1, high);
        }
        return;
    }

    int partition(int* A, int low, int high)
    {
        int privotKey = A[low];    //基准元素
        while (low < high)
        {        //从表的两端交替地向中间扫描
            while (low < high  && A[high] >= privotKey) 
                --high;  //从high 所指位置向前搜索，至多到low+1 位置。将比基准元素小的交换到低端
            swap(&A[low], &A[high]);
            while (low < high  && A[low] <= privotKey) 
                ++low;
            swap(&A[low], &A[high]);
        }
        return low;
    }
};

快速排序的非递归实现

  • 主要是将第一层每个子序列的左右边界用栈存储起来，然后在一层取出边界，再做partition,再存储下一层的边界
    void quickSort2(double* a, int left, int right)  
    {  
        stack<int> t;  
        if(left<right)  
        {  
            int p = partition(a, left, right);  
      
            if (p-1>left)  
            {  
                t.push(left);  
                t.push(p-1);  
            }  
            if (p+1<right)  
            {  
                t.push(p+1);  
                t.push(right);  
            }  
      
            while(!t.empty())  
            {  
                int r = t.top();  
                t.pop();  
                int l = t.top();  
                t.pop();  
      
                p = partition(a, l, r);  
      
                if (p-1>l)  
                {  
                    t.push(l);  
                    t.push(p-1);  
                }  
                if (p+1<r)  
                {  
                    t.push(p+1);  
                    t.push(r);  
                }  
      
            }  
        }  
    }

表排序

  • 表排序适合就是数据本身容量大，交换代价比较大，我们只需要对其下标进行操作

8KDgnON.png

基数排序

桶排序

  • N>>M时，复杂度：T(N,M)=O(M+N);M>>N桶排序不合理

27bo1Xq.png

基数排序

  • M>>N时，T(N)=O(P(N+B)),B->Bucket,P->趟数

OK16sFY.png

  • LSD(Least Significant Digit)次为优先
  • MSD(Most Significant Digit)主位优先
  • LSD和MSD适合不同的场合，速度不一样

LSD基数排序实现

#include<stdio.h>
#include <stdlib.h>

typedef int ElementType;
//基数排序，次为优先

//假设元素最多有MaxDigit个关键字，基数全部是同样的Tadix
#define MaxDigit 4
#define  Radix 10

//桶元素节点
typedef struct Node *PtrToNode;
struct Node
{
    int key;
    PtrToNode next;
};

//桶头节点
struct HeadNode
{
    PtrToNode head, tail;
};

typedef struct HeadNode Bucket[Radix];

int GetDigit(int X, int D)
{
    //默认次位D=1,主位D<=MaxDigit
    int d, i;
    for (i = 1; i <= D;i++)
    {
        d = X%Radix;
        X /= Radix;
    }
    return d;
}

int LSDRadixSort(ElementType A[], int N)
{
    int D, Di, i;
    Bucket B;
    PtrToNode temp, p, List = NULL;

    for (i = 0; i < Radix;i++) /* 初始化每个桶为空链表 */
    {
        B[i].head = B[i].tail = NULL;
    }

    for (i = 0; i < N; i++)   /* 将原始序列逆序存入初始链表List */
    {
        temp = (PtrToNode)malloc(sizeof(struct Node));
        temp->key = A[i];
        temp->next = List;
        List = temp;
    }
    for (D = 1; D <= MaxDigit;D++) /* 对数据的每一位循环处理 */
    {  /* 下面是分配的过程 */
        p = List;
        while (p)
        {
            Di = GetDigit(p->key, D); //获取当前元素的当前位数字
            //从List中摘除
            temp = p;
            p = p->next;
            //插入B[Di]号的桶尾
            temp->next = NULL;
            if (B[Di].head==NULL)
            {
                B[Di].head = B[Di].tail = temp;
            }
            else
            {
                B[Di].tail->next = temp;
                B[Di].tail = temp;
            }
        }
        //下面是收集的过程
        List = NULL;
        for (Di = Radix - 1; Di >= 0;Di--)  /* 将每个桶的元素顺序收集入List */
        {
            if (B[Di].head)  //如果桶不为空
            {
                //整桶插入List表头中
                B[Di].tail->next = List;
                List = B[Di].head;
                B[Di].head = B[Di].tail = NULL; //清空桶
            }
        }
    }
    //将List倒入A[]并释放空间
    for (i = 0; i < N;i++)
    {
        temp = List;
        List = List->next;
        A[i] = temp->key;
        free(temp);
    }
    return 0;
}

int main()
{
    int a[] = {34,8,64,51,32,21};
    LSDRadixSort(a,6);
    for (int i = 0; i < 6;i++)
    {
        printf("%d ", a[i]);
    }
    return 0;
}

MSD基数排序实现

#include <stdio.h> 
#include <stdlib.h>

typedef int ElementType;

/* 基数排序 - 主位优先 */
 
/* 假设元素最多有MaxDigit个关键字，基数全是同样的Radix */
 
#define MaxDigit 4
#define Radix 10
 
/* 桶元素结点 */
typedef struct Node *PtrToNode;
struct Node{
    int key;
    PtrToNode next;
};
 
/* 桶头结点 */
struct HeadNode {
    PtrToNode head, tail;
};
typedef struct HeadNode Bucket[Radix];
  
int GetDigit ( int X, int D )
{ /* 默认次位D=1, 主位D<=MaxDigit */
    int d, i;
     
    for (i=1; i<=D; i++) {
        d = X%Radix;
        X /= Radix;
    }
    return d;
}
 
void MSD( ElementType A[], int L, int R, int D )
{ /* 核心递归函数: 对A[L]...A[R]的第D位数进行排序 */
     int Di, i, j;
     Bucket B;
     PtrToNode tmp, p, List = NULL; 
     if (D==0) return; /* 递归终止条件 */
      
     for (i=0; i<Radix; i++) /* 初始化每个桶为空链表 */
         B[i].head = B[i].tail = NULL;
     for (i=L; i<=R; i++) { /* 将原始序列逆序存入初始链表List */
         tmp = (PtrToNode)malloc(sizeof(struct Node));
         tmp->key = A[i];
         tmp->next = List;
         List = tmp;
     }
     /* 下面是分配的过程 */
     p = List;
     while (p) {
         Di = GetDigit(p->key, D); /* 获得当前元素的当前位数字 */
         /* 从List中摘除 */
         tmp = p; p = p->next;
         /* 插入B[Di]号桶 */
         if (B[Di].head == NULL) B[Di].tail = tmp;
         tmp->next = B[Di].head;
         B[Di].head = tmp;
     }
     /* 下面是收集的过程 */
     i = j = L; /* i, j记录当前要处理的A[]的左右端下标 */
     for (Di=0; Di<Radix; Di++) { /* 对于每个桶 */
         if (B[Di].head) { /* 将非空的桶整桶倒入A[], 递归排序 */
             p = B[Di].head;
             while (p) {
                 tmp = p;
                 p = p->next;
                 A[j++] = tmp->key;
                 free(tmp);
             }
             /* 递归对该桶数据排序, 位数减1 */
             MSD(A, i, j-1, D-1);
             i = j; /* 为下一个桶对应的A[]左端 */
         } 
     } 
}
 
void MSDRadixSort( ElementType A[], int N )
{ /* 统一接口 */
    MSD(A, 0, N-1, MaxDigit); 
}

int main()
{
    int a[] = {34,8,64,51,32,21};
    MSDRadixSort(a, 6);
    for(int i = 0; i < 6; i++)
        printf("%d ",a[i]);
    return 0;
}
  • 多关键排序时候，先MSD,在LSD

总结

95vwg0n.png

Reference

数据结构（邓俊辉）学习笔记】排序 1——快速排序：算法A
weixin_44399845的博客
09-04 1353
快速排序：算法A
基本数据结构，排序算法，算法学习工具
12-27
7. **计数排序**、**桶排序**和**基数排序**：适用于特定类型的数据，可以达到线性时间复杂度O(n)。 最后，算法学习工具是辅助我们理解和实践这些概念的重要资源。例如： 1. **在线编程平台**：如LeetCode、Hacker...
数据结构-计数排序
LiuKe369的博客
07-27 555
【题目来自灰灰考研】 Counting sort基本思想：  对于给定的输入序列中的每一个元素x，确定该序列中值小于x的元素的个数 。一旦有了这个信息，就可以将x直接存放到最终的输出序列的正确位置上。它创建一个长度为这个数据范围的数组C，C中每个元素记录要排序数组中对应记录的出现个数。  下面以示例来说明这个算法：  假设要排序的数组为 A = {1,0,3,1,0,1,1}这里最大值为3，最...
指针链表入门，最简单的博客。
qq_62429806的博客
03-21 1620
链表入门，小白快来
数据结构中的L=(List)malloc(sizeof(PtrToNode))；是什么意思
cwindyc的博客
07-11 5073
sizeo函数（https://baike.baidu.com/item/sizeof/6349467#2） 用于计算数据（包括数组、变量、类型、结构体等）所占用的内存空间，用字节数表示。在L=(List)malloc(sizeof(PtrToNode));中，sizeof是对定义的结构体PtrToNode取总字节数。 malloc函数（https://baike.baidu.com/item/malloc%E5%87%BD%E6%95%B0/8582146?fromtitle=malloc&fro
(C语言)实现主位优先的基数排序及基本原理(含测试用例)
执念斩长河
05-03 369
本博文源于浙江大学《数据结构》，今天跟随姥姥学习基数排序，基数排序是一种在桶排序算法推广下的排序算法，可用在多关键字排序，其主要思想无非是这些：
数据结构--排序（下） 快排、桶排、基数排序、各种排序比较
ACMer
02-07 824
快速排序 O（nlogn） 快排和归并排序都是采用分治的思想，快排的方法是先从一个序列中选一个主元出来，然后把序列根据主元分成左右两部分，左边比主元小，又边比主元大， 分出来的两部分在分别递归用同样的方法处理。 第一步：选主元 采取取 头 中 尾 的中位数作为主元，最后把主元放到倒数第二的位置，也就是n-1的位置。 ElementType Median3(ElementType A[] , int...
数据结构排序学习笔记.pdf
08-17
非比较排序包括计数排序（CountingSort）、桶排序（BucketSort）和基数排序（RadixSort）。计数排序适用于一定范围内的整数排序，在这种排序中，算法的复杂度是线性的。桶排序是一种分布式排序算法，它将元素分布到...
深入解析：基数排序算法在数据结构学习中的应用
资源摘要信息:"数据结构学习笔记排序算法：基数排序" 基数排序（Radix Sort）是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表示字符串（如电话号码...
数据结构学习笔记（附超详细代码实现），数据结构c/c++代码与原理讲解
11-10
内省排序、计数排序、基数排序和桶排序则是基于分配的排序算法，这些算法在处理特定数据时，比比较排序更为高效。 最后，线性表的储存实现及操作中还包括了静态链表、块状链表和大整数处理等内容。静态链表是用数组...
MOOC 数据结构 | 10. 排序（下）
明朗晨光的专栏
07-09 1821
1. 快速排序 算法概述 分而治之 1. 随便挑一个数（65）作为主元(pivot)，以65为枢纽，将原集合分为两大块，左边的数字全部小于65， 右边的数字全部大于65 ---- “分”。 2. 然后递归地治理左边，递归地治理右边； 3. 将三块结果放到一个数组里。 伪码描述： void Quicksort(ElementType A[], int N) { if ( N...
【LeetCode】二叉树相关算法题
qq_45795794的博客
08-15 489
结构含义节点结构二叉树由节点组成， 每个节点包含一个数据元素和最多两个子节点：左子节点和右子节点根节点树的顶部节点称为根节点，是访问整个树的起点叶节点没有子节点的节点成为叶节点子树每个节点及其后代构成一个子树。
数据结构初阶：详解二叉树（二）：堆
2302_80761497的博客
08-18 525
堆是一种特殊的完全二叉树，分为大根堆和小根堆。堆的实现通常采用顺序结构的数组存储，通过向上调整和向下调整算法维护堆的性质。文章详细介绍了堆的初始化、入堆、出堆、取堆顶元素等基本操作，并提供了完整的C语言实现代码。重点讲解了堆排序的两种实现方式：使用向上调整建堆和向下调整建堆，分析比较了它们的时间复杂度。最后探讨了TOP-K问题的解决方案，提出利用堆结构高效处理大数据量下的前K大/小元素查询问题，给出了具体实现代码。堆结构在排序和优先级队列等场景中具有重要应用价值。
Python自学08-常用数据结构之列表
星哥玩云
08-15 251
本文介绍了Python中最常用的数据结构之一——列表(List)。列表是一个可变、有序的集合，可存储任意类型元素，支持增删改查等操作。文章详细讲解了列表的基本用法，包括元素访问、添加、删除、修改和切片操作，并提供了常用方法速查表。重点介绍了优雅的列表推导式写法，以及性能优化建议，如使用deque提升增删效率、区分深浅拷贝等。列表作为Python编程基础，掌握其灵活应用能显著提升代码效率和可读性。
Java集合Map与Stream流：Map实现类特点、遍历方式、Stream流操作及Collections工具类方法
FUYY'S BLOG
08-15 734
Stream流是Java 8引入的处理集合数据的高级工具，它不是数据结构，而是数据处理管道，可以对集合、数组等数据源进行高效的聚合操作（如过滤、排序、统计等）。
LwIP 核心流程总结
最新发布
flyflyfly12345的博客
08-18 728
主要内容参照，整理出来自用。
LeetCode 面试经典 150_数组/字符串_最后一个单词的长度（19_58_C++_简单）(反向遍历)
huayimenghan的博客
08-14 650
LeetCode 面试经典 150_数组/字符串_最后一个单词的长度（19_58_C++_简单） 题目描述： 给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个单词的长度。 单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
HDFS Kerberos认证问题排查与解决
明月朗，潇水寒
08-18 399
摘要：项目集成带Kerberos认证的HDFS时出现"Message stream modified (41)"认证错误。经排查发现是客户端krb5.conf配置的renew_lifetime=7d与KDC主体设置的Maximum renewable life=0冲突导致。解决方案是删除客户端配置中的renew_lifetime参数，使客户端不再申请票据续期。深入分析表明，Hadoop生态更依赖自动重认证而非票据续期机制，建议服务主体禁止续期而客户端避免配置renew_lifetime。
--- 哈希表和哈希冲突 ---
hadage233的博客
08-18 280
实现：在哈希表中储存的是一个链表，当冲突的元素就直接储存再这个链表中，再查找时就先通过哈希函数找到这个链表，再遍历这个链表来获取到元素，因为冲突的次数一般都是常熟级的，所以遍历这个链表的时间也可以近似忽略，所以搜索还是O(1) 的复杂度。再删除元素的时候，采用的是标志位的伪删除法，因为使用线性探测法，一个哈希地址对应的有可能是多个元素，而这其他的元素，要基于这个哈希地址来往后查找，如果这个位置被删除了，那么就表示这里就没有元素，而和他冲突的元素也就不存在了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值