【文末送书】十大排序算法及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]);
            }
        }
    }
}

选择排序（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]);
    }
}

插入排序（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;
    }
}

快速排序（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);
    }
}

归并排序（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);
    }
}

堆排序（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);
    }
}

计数排序（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]--;
        }
    }
}

桶排序（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];
        }
    }
}

基数排序（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);
    }
}

希尔排序（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;
        }
    }
}

图书推荐 -《算法秘籍》

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

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

“算法+数据结构=程序”（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、前缀和、动态规划、并查集、其他经典算法等知识。本书内容丰富，实用性强，通过示例练习和问题分析等方式，详细讲解了与算法有关的知识点。本书附赠视频讲解二维码，以及源代码。

在这里插入图片描述