数据结构与算法之排序（你不得不知道的排序算法）

已于 2023-05-21 23:57:34 修改
阅读量225 收藏 2
点赞数 1
分类专栏： 数据结构与算法 C++学习专栏 编程之美 文章标签： 排序算法 算法 数据结构
于 2023-05-15 23:12:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45541762/article/details/130694806
版权

数据结构与算法之排序（经典排序算法）

1、冒泡排序

代码分析：

这段代码实现了冒泡排序算法，其时间复杂度为 O ( n 2 ) O(n^2) O(n2)。冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复地进行直到没有再需要交换的元素，也就是说该数列已经排序完成。

在这段代码中，bubbleSort函数中的外层循环执行了n次，内层循环执行了n-1次，因此总的时间复杂度为 O ( n 2 ) O(n^2) O(n2)。虽然冒泡排序的时间复杂度较高，但是它实现简单，对于小规模的数据排序效果还是不错的。

代码解读：

这段代码实现了冒泡排序算法。冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复地进行直到没有再需要交换的元素，也就是说该数列已经排序完成。

在这段代码中，swap函数实现了两个元素的交换，bubble函数实现了一次冒泡排序，bubbleSort函数则是对整个数组进行冒泡排序。其中，bubble函数返回一个布尔值，表示是否进行了交换操作，如果没有进行交换操作，说明数组已经排好序了，可以直接退出循环。

在main函数中，首先输出了原始数组，然后调用bubbleSort函数对数组进行排序，最后输出排序后的数组。可以看到，排序后的数组是按照从小到大的顺序排列的。

值得注意的是，这段代码中使用了模板类，可以对不同类型的数组进行排序。同时，使用了STL中的foreach函数，可以方便地对数组进行遍历输出。

#include <iostream>
#include <algorithm>

template<class T>
void swap (T& a, T& b)
{
    T temp = a;
    a = b;
    b = temp;
}

template<class T>
bool bubble (T a[], int n)
{
    bool swapped = false;
    for (int i = 0; i < n - 1; ++i)
    {
        if (a[i] > a[i+1])//如果数组已经是排序的话，则排序就终止了
        {
            swap(a[i], a[i+1]);
            swapped = true;
        }
    }
    return swapped;
}

template<class T>
void bubbleSort(T a[], int n)
{
    for (int i = n; i > 1 && bubble(a, i); --i); //最后只剩一个数字就是排好序的，故到a>1即可
}
void Show(const int& v)
{
    std::cout << v << " ";
}

int main()
{
    int arr[]{ 6, 5, 8, 4, 3, 1 };
    for (auto x : arr)
        std::cout << x << " ";
    //std::for_each(arr, arr + sizeof(arr) / sizeof(int), Show);
    std::cout << "\n";
    bubbleSort(arr, sizeof(arr) / sizeof(int));
    std::for_each(arr, arr + sizeof(arr) / sizeof(int), Show);
    std::cout << std::endl;
    return 0;
}

2、桶排序

#include<iterator>
#include<iostream>
#include<vector>
using std::vector;

/*****************
桶排序：将值为i的元素放入i号桶，最后依次把桶里的元素倒出来。
桶排序序思路：
1. 设置一个定量的数组当作空桶子。
2. 寻访序列，并且把项目一个一个放到对应的桶子去。
3. 对每个不是空的桶子进行排序。
4. 从不是空的桶子里把项目再放回原来的序列中。
假设数据分布在[0，100)之间，每个桶内部用链表表示，在数据入桶的同时插入排序，然后把各个桶中的数据合并。
*****************/


const int BUCKET_NUM = 10;

struct ListNode{
    explicit ListNode(int i=0):mData(i),mNext(NULL){}
    ListNode* mNext;
    int mData;
};

ListNode* insert(ListNode* head,int val){
    ListNode dummyNode;
    ListNode *newNode = new ListNode(val);
    ListNode *pre,*curr;
    dummyNode.mNext = head;
    pre = &dummyNode;
    curr = head;
    while(NULL!=curr && curr->mData<=val){
        pre = curr;
        curr = curr->mNext;
    }
    newNode->mNext = curr;
    pre->mNext = newNode;
    return dummyNode.mNext;
}


ListNode* Merge(ListNode *head1,ListNode *head2){
    ListNode dummyNode;
    ListNode *dummy = &dummyNode;
    while(NULL!=head1 && NULL!=head2){
        if(head1->mData <= head2->mData){
            dummy->mNext = head1;
            head1 = head1->mNext;
        }else{
            dummy->mNext = head2;
            head2 = head2->mNext;
        }
        dummy = dummy->mNext;
    }
    if(NULL!=head1) dummy->mNext = head1;
    if(NULL!=head2) dummy->mNext = head2;

    return dummyNode.mNext;
}

void BucketSort(int n,int arr[]){
    vector<ListNode*> buckets(BUCKET_NUM,(ListNode*)(0));
    for(int i=0;i<n;++i){
        int index = arr[i]/BUCKET_NUM;
        ListNode *head = buckets.at(index);
        buckets.at(index) = insert(head,arr[i]);
    }
    ListNode *head = buckets.at(0);
    for(int i=1;i<BUCKET_NUM;++i){
        head = Merge(head,buckets.at(i));
    }
    for(int i=0;i<n;++i){
        arr[i] = head->mData;
        std::cout << arr[i] << " ";
        head = head->mNext;
    }
    std::cout << std::endl;
}


int main()
{
    int a[] = {56, 89, 24, 6, 18, 5, 1, 99, 63};
    BucketSort(sizeof(a)/sizeof(int), a);
    return 0;
}

3、插入排序

#include <iostream>
#include <algorithm>
template<class T>
void insert(T a[], int n, const T& x)
{
    int i;
    for (i = n - 1; i >= 0 && x < a[i]; --i)
        a[i + 1] = a[i];
    a[i + 1] = x;//因为退出for循环之后i已经减了1
}

template<class T>
void insertionSort(T a[], int n)
{
    for (int i = 1; i < n; ++i)
    {
        T t = a[i];
        insert(a, i, t);//依次插入到恰好比下一个数字小的地方
    }
}

void Show(const int& v)
{
    std::cout << v << " ";
}

int main()
{
    int arr[]{ 6, 5, 8, 4, 3, 1 };
    for (auto x : arr)
        std::cout << x << " ";
    //std::for_each(arr, arr + sizeof(arr) / sizeof(int), Show);
    std::cout << "\n";
    insertionSort(arr, sizeof(arr) / sizeof(int));
    std::for_each(arr, arr + sizeof(arr) / sizeof(int), Show);
    std::cout << std::endl;
    return 0;
}

4、归并排序

递归版：

//完整代码

#include <iostream>

using namespace std;

template<typename T>
void merge_sort_recursive(T arr[], T reg[], int start, int end) {
    if (start >= end)
        return;
    int len = end - start, mid = (len >> 1) + start;
    int start1 = start, end1 = mid;
    int start2 = mid + 1, end2 = end;
    merge_sort_recursive(arr, reg, start1, end1);
    merge_sort_recursive(arr, reg, start2, end2);
    int k = start;
    while (start1 <= end1 && start2 <= end2)
        reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
    while (start1 <= end1)
        reg[k++] = arr[start1++];
    while (start2 <= end2)
        reg[k++] = arr[start2++];
    for (k = start; k <= end; k++)
        arr[k] = reg[k];
}
//整數或浮點數皆可使用,若要使用物件(class)時必須設定"小於"(<)的運算子功能
template<typename T>
void merge_sort(T arr[], const int len) {
    T *reg = new T[len];
    merge_sort_recursive(arr, reg, 0, len - 1);
    delete[] reg;
}
void showAges(const int& age)
{
    std::cout << age << '\t';
}
void Test1()
{
    int ages[] = { 10, 9, 45, 30, 28, 90, 38, 30, 30, 45, 45 };
    merge_sort(ages, sizeof(ages) / sizeof(int));
    std::cout << "The sorted ages is:\n";
    for (auto x : ages)
        showAges(x);
    //    std::cout << x << '\t';

}
int main()
{
    Test1();
    return 0;
}

迭代版：

//完整代码

#include <iostream>

using namespace std;

/*****************
    迭代版
*****************/
//整數或浮點數皆可使用,若要使用物件(class)時必須設定"小於"(<)的運算子功能
template<typename T>
void merge_sort(T arr[], int len) {
    T* a = arr;
    T* b = new T[len];
    for (int seg = 1; seg < len; seg += seg) {
        for (int start = 0; start < len; start += seg + seg) {
            int low = start, mid = min(start + seg, len), high = min(start + seg + seg, len);
            int k = low;
            int start1 = low, end1 = mid;
            int start2 = mid, end2 = high;
            while (start1 < end1 && start2 < end2)
                b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
            while (start1 < end1)
                b[k++] = a[start1++];
            while (start2 < end2)
                b[k++] = a[start2++];
        }
        T* temp = a;
        a = b;
        b = temp;
    }
    if (a != arr) {
        for (int i = 0; i < len; i++)
            b[i] = a[i];
        b = a;
    }
    delete[] b;
}

void showAges(const int& age)
{
    std::cout << age << '\t';
}
void Test1()
{
    int ages[] = { 10, 9, 45, 30, 28, 90, 38, 30, 30, 45, 45 };
    merge_sort(ages, sizeof(ages) / sizeof(int));
    std::cout << "The sorted ages is:\n";
    for (auto x : ages)
        showAges(x);
    //    std::cout << x << '\t';

}
int main()
{
    Test1();
    return 0;
}

5、快速排序

#include <iostream>
#include <algorithm>
#include <exception>
#include <cstdlib>
#include <ctime>//time
template<class T>
void swap(T* a, T* b)//注意用指针构造交换函数时，交换的是指针指向的值
{
    T temp = *a;
    *a = *b;
    *b = temp;
}
int RandomInRange(int st, int en)
{
    srand(unsigned(time(0)));//把当前时间作为随机数种子
    return st + rand() % (en - st + 1);
}
int Partition(int data[], int length, int start, int end)
{
    if (data == nullptr || length <= 0 || start < 0 || end >= length)
    {
        throw "Invalid Parameters";
    }
    int index = RandomInRange(start, end);
    swap(&data[index], &data[end]);
    int small = start - 1;
    for (index = start; index < end; ++index)
    {
        if (data[index] < data[end])//当条件不成立时index增加，small不变
        {
            ++small;
            if (small != index)
                swap(&data[index], &data[small]);
        }
    }
    ++small;
    swap(&data[small], &data[end]);
    return small;//返回的结果是左边比data[end]小，右边比data[end]大的数
}

void QuickSort(int data[], int length, int start, int end)
{
    if (start == end)
        return;
//**********************************这部分是判断数组是否已经按升序排好序，排好的话就直接终止，这样就防止出现最糟糕的情况
    bool sorted = true;   //《剑指offer》p81
    for (int i = start; i < end; ++i)
    {
        if (data[i] > data[i + 1])//如果数组已经是排序的话，则排序就终止了
        {
            sorted = false;
        }
    }
    if (sorted)
        return;
//****************************************************************************************
    int index = Partition(data, length, start, end);
    if (index > start)
        QuickSort(data, length, start, index - 1);
    if (index < end)
        QuickSort(data, length, index + 1, end);
}

void Show(const int& v)
{
    std::cout << v << " ";
}

int main()
{
    int arr[]{ 6, 5, 8, 4, 3, 1 };
    for (auto x : arr)
        std::cout << x << " ";
    //std::for_each(arr, arr + sizeof(arr) / sizeof(int), Show);
    std::cout << "\n";
    QuickSort(arr, sizeof(arr) / sizeof(int), 0, sizeof(arr) / sizeof(int) - 1);
    std::for_each(arr, arr + sizeof(arr) / sizeof(int), Show);
    return 0;
}

6、选择排序

#include <iostream>
#include <algorithm>
template<class T>
void swap (T& a, T& b)
{
    T temp = a;
    a = b;
    b = temp;
}
template<class T>
void selectionSort(T a[], int n)
{
    bool sorted = false;
    for (int size = n; !sorted && (size > 1); size--)
    {
        int indexOfMax = 0;
        sorted = true;
        for (int i = 1; i < size; ++i)
        {
            if (a[indexOfMax] <= a[i])
                indexOfMax = i;
            else
                sorted = false;//无序的
        }
        swap (a[indexOfMax], a[size - 1]);//如果是无序的，则每次循环将最大值放在最后一位
    }
}


void Show(const int& v)
{
    std::cout << v << " ";
}

int main()
{
    int arr[]{ 6, 5, 8, 4, 3, 1 };
    for (auto x : arr)
        std::cout << x << " ";
    //std::for_each(arr, arr + sizeof(arr) / sizeof(int), Show);
    std::cout << "\n";
    selectionSort(arr, sizeof(arr) / sizeof(int));
    std::for_each(arr, arr + sizeof(arr) / sizeof(int), Show);
    return 0;
}

桶排序的一个示例（《剑指offer》中的一个问题）

后面会补充剑指offer相关的内容

#include <iostream>
#include <exception>

void SortAges(int ages[], int length)
{
	if (ages == nullptr || length <= 0)
		return;
	const int oldestAge = 99;
	int timesOfAge[oldestAge + 1];
	for (int i = 0; i < oldestAge; ++i)
		timesOfAge[i] = 0;
	for (int i = 0; i < length; ++i)
	{
		int age = ages[i];
		if (age < 0 || age > oldestAge)
			throw new std::exception("age out og range");
		++timesOfAge[age];
	}
	int index = 0;
	for (int i = 0; i <= oldestAge; ++i)
	{
		for (int j = 0; j < timesOfAge[i]; ++j)
		{
			ages[index] = i;
			++index;
		}
	}
}
void showAges(const int& age)
{
	std::cout << age << '\t';
}
void Test1()
{
	int ages[] = { 10, 9, 45, 30, 28, 90, 38, 30, 30, 45, 45 };
	SortAges(ages, sizeof(ages) / sizeof(int));
	std::cout << "The sorted ages is:\n";
	for (auto x : ages)
		showAges(x); 
	//	std::cout << x << '\t';
	
}
int main()
{
	Test1();
	return 0;
}
笑着的程序员
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【华为OD机试真题 2022&2023】真题目录 已支持（C++&Java&python）100%通过率
笑着的程序员的博客
04-05 7621
已支持（C++&Java&python）100%通过率 超详细代码注释 代码深度解读
数据结构之排序算法
m0_62761692的博客
02-12 1060
一.排序算法 就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。 1.比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。 选择排序、冒泡排序、插入排序、希尔排序、归并排序、堆排序、快速排序 2.非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。 计数排序、桶排序、基数排序 3.稳定：如果a原本在b前面，而a==b，排序之后
【数据结构初阶】八大排序算法+时空复杂度
The porters of knowledge
12-10 4424
1.5万字排序，面试官看后，直呼小伙子有前途。
Java 【数据结构】常见排序算法实用详解（上） 插入排序/希尔排序/选择排序/堆排序【贤者的庇护】
最新发布
2302_79806056的博客
05-03 1730
在学习了插入排序、希尔排序、堆排序和选择排序之后，我对这些经典的排序算法有了更深入的理解和反思。插入排序插入排序是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。简单易懂，稳定，对于小规模数据或者基本有序的数据效果较好。尽管插入排序简单，但对于大规模数据的排序效率较低，时间复杂度为 O(n^2)。在数据量较大时，不太适用。了解和掌握各种排序算法的原理、特点和实现方法，能够在实际应用中选择合适的排序算法，并对算法进行优化，提高程序的性能。
数据结构与算法-排序算法（希尔排序）
weixin_43265151的博客
03-11 252
1.介绍 欢迎访问我的个人博客(点击进入) 希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因D.L.Shell于1959年提出而得名。 希尔排序也是插入排序的一种，是对插入排序的一种升级，解决了在插入排序过程中，元素交换次数过多的问题（当插...
排序算法总结（数据结构排序算法）
li951527983的博客
03-21 3041
数据结构排序算法大总结（C语言），总结整理直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序，简单选择排序、堆排序、归并排序、基数排序九大排序算法以及外排序的算法思想，结合图片演示原理，含源码。
重庆理工大学数据结构实验报告+源码+实验数据 内部排序算法的性能分析详尽分析了不同排序算法的优劣，并有20张可视化图对比。
06-01
个人资源，仅供参考不得传播。 ⑴ 编程实现内部排序算法：编程实现直接插入排序，希尔...⑸ 建议测试你的系统所能实现内部排序算法的数据规模上限，并针对这一问题，在报告中提出如何解决超大规模数据排序问题的思路。
数据结构与算法C#语言描述(中文)
12-23
但是，市面上尚无用C#语言讲述数据结构和算法的图书，广大C#程序员不得不将自 己转换C++或Java描述的数据结构，费时费力，而且容易出错。 　本书填补了这一空白。而且更加难能可贵的是，作者基于自己多年的教学和...
上班时间刷leetcode-a-plan:前端工程师的数据结构与算法的学习计划
06-30
不得不说，从零开始学习数据结构和算法，对于非科班出身的程序员来说，还是存在一定困难。我觉得最大的困难是缺乏一个行之有效的学习思路。这个项目希望通过我，由浅入深的学习数据结构和算法给大家一个借鉴，祝福每...
不得不看211重点大学的数据结构课件
12-08
对于211重点大学的学生来说，掌握数据结构的知识至关重要，因为它是计算机科学与技术、软件工程等专业基础的重要组成部分。本课件集合了多个章节的内容，旨在全面而深入地讲解数据结构的基础理论和实际应用。 一、...
algorithms-and-data-structures:技术面试的数据结构和算法准备。 因此，我是一名PHP人士，我不得不使用PHP重新创建这些类以重复CS主题。
05-24
排序算法 桶分类 气泡排序 选择排序 贝壳排序 插入排序 插入排序与数组 合并排序 快速排序 测验 其他课程未完成。 其他要包括的内容： 技术堆栈：应该安装PHP，Composer以及Bower和Grunt 状态：非常非常阿尔法 ...
史上最全的整数分解方法（包含经典的分苹果问题）
笑着的程序员的博客
06-07 7915
整数分解方法总结 题目描述： 给定一个正整数，我们可以定义出下面的公式： N=a[1]+a[2]+a[3]+...+a[m]; a[i]>0,1<=m<=N; 对于一个正整数，求解满足上面公式的所有算式组合 对于整数4： 4 = 4； 4 = 3+1； 4 = 2+2； 4 = 2+1+1； 4 = 1+1+1+1； 所有可能的分解输出（有重复） 方法一： #include <iostream> using namespace std; const int Size = 20
关于cin.peek()用法的总结
笑着的程序员的博客
08-25 7601
关于cin.peek()用法的总结 cin.peek()的返回值是一个char型的字符，其返回值是指针指向的当前字符，但它只是观测 指针停留在当前位置并不后移；如果要访问的字符是文件结束符，则函数值是EOF（-1） #include<iostream> using namespace std; int main() { int sum = 0; int c; while (cin >> c) { sum += c; while (cin.peek() == ' ') {
C++中关于count的用法总结
笑着的程序员的博客
07-15 5815
C++中关于count的用法总结 下面是关于字符串中count的两种用法，STL容器，数组的用法类似 #include <iostream> #include <string> #include <algorithm> //count using namespace std; int main() { string m = "1233445"; //int n = count(m.data(), m.data()+m.size(),'3'); i
一篇文章带你对全排列从入门到精通
笑着的程序员的博客
07-18 5024
从n个数中选取m个数的组合及全排列 题目描述： 给定两个整数n、m,输出从(1,2,…,n)中选出m个数的所有组合。 输入： 每个测试文件含有多个数据，输入两个整数n,m(0<m<=n<=10)。输入到文件末尾结束。 输出： 输出对应的组合数，每个组合中的数字由小到大排列，对于每组数据的所有组合按字典序排序 /下面这个组合代码能够满足字典排序输出 #include <iostream> using namespace std; int n, m, lst[10] = {0};
【C++代码之美】你不得不知道的经典代码
笑着的程序员的博客
04-27 4657
斐波那契数列（Fibonacci sequence），又称黄金分割数列，因数学家莱昂纳多·斐波那契（Leonardo Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……
最大公约数和最小公倍数的经典求法（C++）及例题实战练习
笑着的程序员的博客
06-07 3321
最大公约数和最小公倍数的经典求法（C++） 最小公倍数：数论中的一种概念，两个整数公有的倍数成为他们的公倍数，其中一个最小的公倍数是他们的最小公倍数，同样地，若干个整数公有的倍数中最小的正整数称为它们的最小公倍数 求最小公倍数算法： 最小公倍数=两整数的乘积÷最大公约数 辗转相除法 #include <iostream> using namespace std; int main() { int m, n, a, b, c; cout << "Input two i
关于stringstream中clear()用法的进一步总结
笑着的程序员的博客
08-18 3118
关于stringstream中clear()用法的进一步总结 clear()到底能不能清除流的状态： 大家看一下： #include <iostream> #include <sstream> using namespace std; int main() { stringstream stream; int first, second,third; stream << "123";//插入字符串 stream >> first
codeblocks简单的背景及字体设置（及默认工作路径设置）
笑着的程序员的博客
05-23 2620
codeblocks简单的背景及字体设置（及默认工作路径设置） 一、字体设置 二、代码背景设置 三、光标宽度及颜色设置 四、左侧行号颜色、背景及行号与代码块之间背景设置 五、默认工作路径设置 最后效果 ...
学习教程：data_structures_数据结构：2022.pdf
07-01
8. 堆：一种特殊的树形数据结构，满足堆属性（最大堆或最小堆），常用于优先队列和排序算法（如堆排序）。 9. 散列表（字典）：通过键值对存储数据，提供快速的查找、插入和删除操作。 10. 字符串：用于处理文本...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

笑着的程序员

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

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

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

打赏作者

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

抵扣说明：

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

余额充值