【文末送书】十大排序算法C++代码实现

欢迎关注博主 Mindtechnist 或加入【智能科技社区】一起学习和分享Linux、C、C++、Python、Matlab，机器人运动控制、多机器人协作，智能优化算法，滤波估计、多传感器信息融合，机器学习，人工智能等相关领域的知识和技术。关注公粽号 《机器和智能》 回复关键词 “python项目实战” 即可获取美哆商城视频资源！

---

博主介绍：
CSDN优质创作者，CSDN实力新星，CSDN内容合伙人；
阿里云社区专家博主；
华为云社区云享专家；
51CTO社区入驻博主，掘金社区入驻博主，支付宝社区入驻博主，博客园博主。

---

算法与数据结构书籍推荐

• 十大排序算法
• • 冒泡排序（Bubble Sort）
  • 选择排序（Selection Sort）
  • 插入排序（Insertion Sort）
  • 快速排序（Quick Sort）
  • 归并排序（Merge Sort）
  • 堆排序（Heap Sort）
  • 计数排序（Counting Sort）
  • 桶排序（Bucket Sort）
  • 基数排序（Radix Sort）
  • 希尔排序（Shell Sort）
• 图书推荐 -《算法秘籍》

---

🎉🎉🎉🎉🎉 重磅福利 🎉🎉🎉🎉🎉
🎉本次送3套书 ，评论区抽3位小伙伴送书，中奖用户可在下列书单任选一本
🎉活动时间：截止到 2023-11-16 10:00:00
🎉抽奖方式：评论区随机抽奖。
🎉参与方式：关注博主、点赞、收藏，评论。
❗注意：一定要关注博主，不然中奖后将无效！
🎉通知方式：通过私信联系中奖粉丝。
💡提示：有任何疑问请私信公粽号 《机器和智能》

---

专栏：《前沿技术文献与图书推荐》

---

十大排序算法

以下是十种常见的排序算法及其C++代码实现：

冒泡排序（Bubble Sort）

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(arr[j], arr[j + 1]);
            }
        }
    }
}
1
2
3
4
5
6
7
8
9

选择排序（Selection Sort）

void selectionSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        swap(arr[i], arr[minIndex]);
    }
}
1
2
3
4
5
6
7
8
9
10
11

插入排序（Insertion Sort）

void insertionSort(int arr[], int n) {
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}
1
2
3
4
5
6
7
8
9
10
11

快速排序（Quick Sort）

int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = low - 1;
    for (int j = low; j <= high - 1; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(arr[i], arr[j]);
        }
    }
    swap(arr[i + 1], arr[high]);
    return i + 1;
}

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

归并排序（Merge Sort）

void merge(int arr[], int l, int m, int r) {
    int n1 = m - l + 1;
    int n2 = r - m;
    int L[n1], R[n2];
    for (int i = 0; i < n1; i++) {
        L[i] = arr[l + i];
    }
    for (int j = 0; j < n2; j++) {
        R[j] = arr[m + 1 + j];
    }
    int i = 0, j = 0, k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

void mergeSort(int arr[], int l, int r) {
    if (l < r) {
        int m = l + (r - l) / 2;
        mergeSort(arr, l, m);
        mergeSort(arr, m + 1, r);
        merge(arr, l, m, r);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

堆排序（Heap Sort）

void heapify(int arr[], int n, int i) {
    int largest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    if (left < n && arr[left] > arr[largest]) {
        largest = left;
    }
    if (right < n && arr[right] > arr[largest]) {
        largest = right;
    }
    if (largest != i) {
        swap(arr[i], arr[largest]);
        heapify(arr, n, largest);
    }
}

void heapSort(int arr[], int n) {
    for (int i = n / 2 - 1; i >= 0; i--) {
        heapify(arr, n, i);
    }
    for (int i = n - 1; i >= 0; i--) {
        swap(arr[0], arr[i]);
        heapify(arr, i, 0);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

计数排序（Counting Sort）

void countingSort(int arr[], int n) {
    int maxVal = *max_element(arr, arr + n);
    int minVal = *min_element(arr, arr + n);
    int range = maxVal - minVal + 1;
    int count[range] = {0};
    for (int i = 0; i < n; i++) {
        count[arr[i] - minVal]++;
    }
    int index = 0;
    for (int i = 0; i < range; i++) {
        while (count[i] > 0) {
            arr[index++] = i + minVal;
            count[i]--;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

桶排序（Bucket Sort）

void bucketSort(float arr[], int n) {
    float maxVal = *max_element(arr, arr + n);
    float minVal = *min_element(arr, arr + n);
    float range = maxVal - minVal;
    int bucketSize = range / n + 1;
    vector<vector<float>> buckets(n);
    for (int i = 0; i < n; i++) {
        float index = (arr[i] - minVal) / bucketSize;
        buckets[(int)index].push_back(arr[i]);
    }
    int index = 0;
    for (int i = 0; i < n; i++) {
        sort(buckets[i].begin(), buckets[i].end());
        for (int j = 0; j < buckets[i].size(); j++) {
            arr[index++] = buckets[i][j];
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

基数排序（Radix Sort）

void countingSortForRadix(int arr[], int n, int exp) {
    int output[n];
    int count[10] = {0};
    for (int i = 0; i < n; i++) {
        count[(arr[i] / exp) % 10]++;
    }
    for (int i = 1; i < 10; i++) {
        count[i] += count[i - 1];
    }
    for (int i = n - 1; i >= 0; i--) {
        output[count[(arr[i] / exp) % 10] - 1] = arr[i];
        count[(arr[i] / exp) % 10]--;
    }
    for (int i = 0; i < n; i++) {
        arr[i] = output[i];
    }
}

void radixSort(int arr[], int n) {
    int maxVal = *max_element(arr, arr + n);
    for (int exp = 1; maxVal / exp > 0; exp *= 10) {
        countingSortForRadix(arr, n, exp);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

希尔排序（Shell Sort）

void shellSort(int arr[], int n) {
    for (int gap = n / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < n; i++) {
            int temp = arr[i];
            int j;
            for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
                arr[j] = arr[j - gap];
            }
            arr[j] = temp;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

图书推荐 -《算法秘籍》

数据结构和算法是计算机科学的基石，是计算机的灵魂，要想成为计算机专业人员，学习和掌握算法是十分必要的。不懂数据结构和算法的人不可能写出效率更高的代码。计算机科学的很多新行业都离不开数据结构和算法作为基石，比如大数据、人工智能等。底层开发中也需要使用非常多的数据结构和算法知识，以保证底层系统的稳定性和高效性。

计算机科学家尼古拉斯·沃斯在计算机领域有一句人尽皆知的名言：

“算法+数据结构=程序”（Algorithms+Data Structures=Programs）

所以数据结构和算法是程序员必须掌握的技能。尤其是到一些大公司面试的时候，算法更是一个少不了的环节，熟练掌握数据结构和算法，可以开拓我们的视野，提高我们的逻辑思维能力，在写代码和分析官方源码的时候也非常有帮助。学习数据结构和算法的一个好处就是：学完之后知识基本不会过时，可以永远为我们所用。大家都知道程序员需要不停地学习，因为知识更新太快，记得在笔者（博哥）上大学和后来开始工作的时候，非常喜欢研究官方源码和框架，如痴如醉，但很遗憾，现在很多框架都已被淘汰了，没被淘汰的也被更新得面目全非，然后还要不停地学习其他新的框架。笔者一直在思考，能不能学习一种永不过时的知识。后来就接触了数据结构和算法，这一接触就是好多年，学的那么多知识依然没有过时。比如KMP算法是在1977年被联合发表的，那么多年过去了，这种算法依然没有被淘汰，如果是一个框架，基本上很难保证那么多年还能存在，就算存在也会有大量的更新，还是需要不停地学习。

写书的初衷及过程
笔者（博哥）具有10多年的开发经验，2017年开始做算法试题并在公众号发布试题讲解，经常游走在全球30多个算法网站之间，累计做题2000多道，对算法试题有自己独特的解题思路和技巧。

笔者写这本书的初衷是希望能够帮助更多的程序员快速学习算法，我们都知道算法在整个IT行业算是比较难的，之前有很过程序员通过公众号加笔者微信，请教关于算法的题，刚开始笔者一一进行了回复，后来随着咨询量越来越大，笔者意识到大家迫切地需要算法相关知识的系统指导。结合笔者过往的写作和从业经历，便着手写一本算法书籍，希望能欧帮助大家更好地学习算法，于是这本《算法秘籍》就诞生了。

这本书的知识覆盖范围全面，总共分为13个章节，先是详细介绍了常见的八大数据结构。后面都是我们比较常见的算法题，其中包括了二叉树的Morris遍历，KMP算法，马拉车算法等经典题型。

关于数据结构，大家普遍认为难度较大的可能就是图了，本书对图的分类，图的表示方式，图的遍历，以及图的各种经典算法比如迪杰斯特拉算法，普里姆算法，拓扑排序等都有大量介绍。

本书的内容

本书以Java为描述语言，介绍了计算机编程中常用的数据结构和算法，主要内容如下。

第1章：主要介绍了8种数据结构，包括数组、链表、队列、栈、散列表、树、堆、图，然后每种数据结构又有细分，比如介绍树的时候有完全二叉树、满二叉树、二叉搜索树、AVL树、红黑树、字典树、哈夫曼树、线段树、笛卡儿树等。图的介绍中也有一些经典的算法，比如迪杰斯特拉算法、弗洛伊德算法、普里姆算法和克鲁斯卡尔算法等。
第2章：介绍了几种经典排序算法，以及它们的稳定性分析。
第3章：主要介绍了一些位运算和常见操作符，还有一些简单的操作和使用技巧，如有限状态机和相关示例讲解。
第4章：介绍了和树有关的知识，比如树的遍历方式，包括DFS遍历、Morris遍历，以及BFS遍历等。
第5章：分析了递归的原理和示例练习，可以把它看作是对一棵树的DFS遍历。
第6章：主要介绍了回溯算法的使用，然后得出回溯算法的使用模板，以及一些经典示例，还有一些重复问题和不符合条件的修剪分支。
第7章：主要介绍贪心算法的使用和存在的不足。
第8章：分别介绍了相向双指针、同向双指针和快慢双指针的使用技巧，还有滑动窗口的介绍和使用模板，以及大小可变窗口、固定窗口、只增不减窗口等。
第9章：主要介绍了BFS和DFS的使用模板和示例练习。
第10章：主要介绍了一维前缀和与二维前缀和的使用。
第11章：介绍动态规划和一些经典问题的讲解，如背包问题、组合与排列问题等。
第12章：通过三国人物的故事，生动形象地介绍了并查集的使用、并查集优化、并查集路径压缩以及合并优化等。
第13章：介绍了其他一些经典算法，比如KMP算法、马拉车算法、算术表达式的运算、牛顿迭代法求平方根、Base64编码等。

联合推荐

算法是编程的基石。本书以生动的案例，结合作者的丰富经验，诠释了算法学习的直观与趣味性，对算法感兴趣的开发者具有极高的参考价值。强烈推荐！

《算法秘籍》

王一博 著

购买链接： 双十一限时五折，点击购买

算法是编程的基石，开发的核心。

本书包含55个二维码，300多分钟视频，100多个知识点，50多个示例，适合程序员、计算机专业相关师生，以及对算法感兴趣的读者。

这是一本关于数据结构和算法的书，以Java为描述语言，介绍了计算机编程中常用的数据结构和算法。全书共13章，讲述了常见的数据结构、排序算法、位运算、树、递归、回溯算法、贪心算法、双指针和滑动窗口、BFS和DFS、前缀和、动态规划、并查集、其他经典算法等知识。本书内容丰富，实用性强，通过示例练习和问题分析等方式，详细讲解了与算法有关的知识点。本书附赠视频讲解二维码，以及源代码。

---

❗❗❗重要❗❗❗☞关注下方公粽号 《机器和智能》 回复关键词 “python项目实战” 即可获取美哆商城视频资源！