弄懂所有排序算法（C++）

最新推荐文章于 2024-05-18 21:23:27 发布

CClaris

最新推荐文章于 2024-05-18 21:23:27 发布

阅读量29

点赞数

分类专栏： C++ 文章标签：排序算法 c++ 算法

本文链接：https://blog.csdn.net/weixin_49520696/article/details/134472317

版权

C++ 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

快速排序（基于划分的思想）

// 该函数实现了快速排序算法
void quick_sort(vector<int> &nums, int l, int r) 
{

//1.定义一个出口（当l+1>=r时）
	  // 当l大于等于r时，结束排序
	  if (l + 1 >= r) {
		    return;
	  }


  // 设置首尾指针和关键元素
  int first = l, last = r - 1, key = nums[first];

//2.小的放左边
//3.大的放右边

  // 当first小于last时，执行循环
  while (first < last){
    // 移动尾，寻找小于key的元素
    while (first < last && nums[last] >= key) 
      --last;
    // 将小于key的元素放到数组的左边
    nums[first] = nums[last];    
    // 移动头，寻找大于key的元素
    while (first < last && nums[first] <= key) {
      ++first;
    }
    // 将大于key的元素放到数组的右边
    nums[last] = nums[first];
  }
//4.key放到正确位置
  // 把key放到正确的位置，此时，key左边的元素都小于它，右边的元素都大于它
  nums[first] = key;
//5.对左边元素递归
//6.对右边元素递归
  // 递归地对key的左边元素进行快速排序
  quick_sort(nums, l, first);
  
  // 递归地对key的右边元素进行快速排序
  quick_sort(nums, first + 1, r);
}

归并排序（基于合并的思想）


void merge_sort(vector<int> &nums, int l, int r, vector<int> &temp) {
    // 基本情况：如果待排序数组的长度小于等于1，那么不需要排序，直接返回
    if (l + 1 >= r) {
        return;
    }
//1.不断的进行划分，直到只剩一个元素
    // 分治排序的“分”步骤
    // 计算中点m，将数组一分为二，分别为[l, m)和[m, r)
    int m = l + (r - l) / 2;
    
    // 递归对左半部分进行排序
    merge_sort(nums, l, m, temp);
    // 递归对右半部分进行排序
    merge_sort(nums, m, r, temp);


//2.对左右两个子序列进行合并排序
    // 分治排序的“治”步骤
    // 开始合并两个已排序的子数组
    int p = l, q = m, i = l;
	while (p < m || q < r)
{         //左半边/右半边没处理完


        // 判断条件，如果右边的数组已经处理完，或者左边元素没有处理完并且左边值小于右边值
        if (q >= r || (p < m && nums[p] <= nums[q])) {
            // 将左边（小的）的当前元素复制到临时数组中
            temp[i++] = nums[p++];
        } else {
            // 否则，将右边（大的）的当前元素复制到临时数组中
            temp[i++] = nums[q++];
        }
//向临时数组中从小到大的放序列
    }
    
    // 将排序后的元素从临时数组复制回原数组
    for (i = l; i < r; ++i) {
        nums[i] = temp[i];
    }
}

插入排序（从头到尾不断往前插入）

插入排序是一种简单的排序算法，它的工作原理是通过构建有序序列，对未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用 in-place 排序（即只需用到 O(1) 的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

主要思路：
默认从第一个元素开始往右挨个看，每个元素向左逐个对比，直到向右走完所有元素。

void insertion_sort(vector<int>&nums, int n) 
{ 
		for (int i = 0; i < n; ++i) 
		{ 
				for (int j = i; j > 0 && nums[j] < nums[j-1]; --j) 
			    { 
				   swap(nums[j], nums[j-1]);
			     } 
		} 
}

冒泡排序（一次冒一个泡（最大/最小数））

冒泡排序被这样命名是因为，随着排序过程的进行，最大的元素（如果是升序排序）或者最小的元素（如果是降序排序）就像水中的"气泡"一样，慢慢"浮"到数组的顶端或者尾部。

在冒泡排序的每一轮排序过程中，都会通过两两比较并交换位置，使得当前最大（或最小）的元素移动到正确的位置。这个过程就像是气泡在水中不断上浮的过程，因此这种排序算法被称为"冒泡排序"。

冒泡排序的一个特点是越小（或越大）的元素会经由交换慢慢“浮”到数列的顶端，故名冒泡排序。
冒泡：最大或最小的一个个的冒到水上
主要步骤：
1.冒出一个泡（从第一个开始，向右）
2.进行冒泡操作（将一个泡层层的冒出，向右）

void bubble_sort(vector &nums, int n)
{
	bool swapped; 
	for (int i = 1; i < n; ++i) 
	{
		swapped = false; 
		for (int j = 1; j < n - i + 1; ++j)  //（每次都必须从第一个开始往后捋，这样才能每次捋出一个最大/最小的） 
							 //后部分值为冒上去的最大的值（已经有序）
		{
			if (nums[j] < nums[j-1]) 
			{ 
				swap(nums[j], nums[j-1]); 
				swapped = true;
			}
		}
		if (!swapped) 
			break;
	}
}

鸡尾酒排序（双冒泡法）

思路：冒泡排序为从前往后捋，鸡尾酒排序为前后一起捋

void cocktail_sort(vector<int>&nums)
{
	int start = 0, end = nums.size()-1;
	bool swaped = true;
	while (swaped)
	{
		swaped = false;
		for (int i = start; i < end; ++i)
		{
			if (nums[i] > nums[i + 1])
			{
				swap(nums[i], nums[i + 1]);
				swaped = true;
			}
		}

		if (!swaped)
			break;
		swaped = false;
		end--;
		for (int i = end; i > start; --i)
		{
			if (nums[i] < nums[i-1])
			{
				swap(nums[i - 1], nums[i]);
				swaped = true;
			}
		}
		start++;

	}
}

选择排序（不断挑最小）

选择排序是一种简单直观的排序算法，其基本思想是从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余的未排序元素中寻找到最小（或最大）元素，然后放到已排序的序列的末尾。以此类推，持续进行此过程，直到全部待排序的数据元素排完。
注意
选择排序的效率较低，因为它每次都要从未排序的部分扫描最小或者最大元素，然后进行交换，这样会导致大量的比较和交换操作。

操作思路：
1.从左向右一个个元素挨个拿出来
2.对于拿出来的元素，挨个向右对比找到比拿出元素还小的（找最小的过程，必须有一个索引来锁定住最小的变量）
3.对于找出的较小元素与拿出元素交换位置

void selection_sort(vector &nums, int n) 
{
	int mid;
	for (int i = 0; i < n - 1; ++i)     //最后一个元素没有必要在排序
	{
		mid = i;
		for(int j = i + 1; j < n; ++j)    //找到最小的单个元素
		{
			if (nums[j] < nums[mid]) 
				mid = j;
		}
		swap(nums[mid], nums[i]);
	}
}

快速选择

例子

题目描述
在一个未排序的数组中，找到第 k 大的数字。
输入输出样例
输入一个数组和一个目标值 k，输出第 k 大的数字。题目默认一定有解。
Input: [3,2,1,5,6,4] and k = 2
Output: 5
题解
快速选择一般用于求解 k-th Element 问题，可以在 O(n) 时间复杂度，O(1) 空间复杂度完成求解工作。快速选择的实现和快速排序相似，不过只需要找到第 k 大的枢（pivot）即可，不需要对其左右再进行排序。与快速排序一样，快速选择一般需要先打乱数组，否则最坏情况下时间复杂度为 O(n 2 )，我们这里为了方便省略掉了打乱的步骤。

这是快速排序算法的一个变种，用于在未排序的数组中查找第 k 个最大（或最小）的元素。
快速选择的基本思想与快速排序类似，都是选择一个“基准”元素，然后将数组分为两部分：一部分的元素都比基准小，另一部分的元素都比基准大。
但与快速排序不同的是，我们只需要处理与 k 有关的那一部分。

这种方法的平均时间复杂度是 O(n)。但在最差情况下，它可能会退化到 O(n^2)。为了防止这种情况发生，通常会使用随机化技巧。

1.进行折半选择，比目标值大就向左，比目标值小就向右
2.使用一个快速选择算法，随便定一个基准，然后把小的放左边大的放右边

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        int l = 0, r = nums.size() - 1, mid, target = nums.size() - k;
        while (l < r) {
            mid = quick(nums, l, r);
            if (mid == target)
                return nums[mid];
            else if (mid < target)
                l = mid + 1;
            else
                r = mid - 1;
        }
        return nums[l];
    }

    int quick(vector<int>& nums, int l, int r) {
        int i = l + 1, j = r;
        while (i <= j) {
            while (i <= j && nums[i] <= nums[l]) // find smaller than l
                ++i;
            while (i <= j && nums[j] >= nums[l]) // find larger than l
                --j;
            if (i < j) swap(nums[i], nums[j]);
        }
        swap(nums[l], nums[j]);
        return j;
    }
};

桶排序

桶排序是一个分发式的排序算法，它将数组分成多个区间（或“桶”），然后对每个桶中的数据进行排序。最后，再将所有桶的数据按桶的顺序连接起来，得到排序后的序列。它通常用在输入数据是均匀分布的场合。

以下是桶排序的基本思想：

确定桶的数量: 根据数据的特性和分布范围，确定要创建的桶的数量。
分配到桶中: 遍历输入数据，将每个数据放到对应的桶中。数据应该被分配到范围内对应的桶。例如，如果数据范围是[0,100)并且我们有10个桶，那么数字范围[0,10)的数据将被放入第一个桶，范围[10,20)的数据放入第二个桶，以此类推。
排序每个桶: 对每个桶中的数据进行排序。这可以使用其他排序算法，如插入排序。
合并桶: 一旦所有的桶都被排序，就按照桶的顺序将数据合并回一个数组。

性质与用途:

桶排序是一个线性时间的排序算法，当满足以下条件时：
- 输入数据是均匀分布的。
- 桶的数量与输入数据的数量是线性关系。
桶排序适用于待排序数据可以均匀、独立地分布到各个桶中的场合。
在实际应用中，桶排序可以用来分布大量数据，如通过IP地址进行排序、按照地理位置进行排序等。

示例:

假设有一个数组：[4.5, 0.84, 3.25, 2.18, 0.5]，我们想使用桶排序对其进行排序。

由于数组中的所有数字都是在0到5之间的，我们可以使用5个桶。
将这些数字分配到对应的桶中：
- 0.5和0.84放入第一个桶。
- 无数字在1和2之间，所以第二个桶为空。
- 2.18放入第三个桶。
- 3.25放入第四个桶。
- 4.5放入第五个桶。
对每个桶中的数字进行排序（这里每个桶的数字数量很少，所以不需要额外排序）。
合并所有桶中的数据，得到排序后的数组：[0.5, 0.84, 2.18, 3.25, 4.5]。

注意：在实际应用中，选择桶的数量和桶的大小是关键。太少或太多的桶都可能导致算法效率降低。

例子

给定一个数组，求前 k 个最频繁的数字。

输入是一个数组和一个目标值 k。输出是一个长度为 k 的数组。
Input: nums = [1,1,1,1,2,2,3,4], k = 2
Output: [1,2]
顾名思义，桶排序的意思是为每个值设立一个桶，桶内记录这个值出现的次数（或其它属性），然后对桶进行排序。针对样例来说，我们先通过桶排序得到四个桶 [1,2,3,4]，它们的值分别为 [4,2,1,1]，表示每个数字出现的次数。

vector<int> topKFrequent(vector<int>& nums, int k) {
  
    unordered_map<int, int> counts;
 
    int max_count = 0;

    //  从数组中找频率
    for (const int & num : nums) {
        max_count = max(max_count, ++counts[num]);
    }

    // 桶排序的核心部分
    // 创建一个桶的数组
    vector<vector<int>> buckets(max_count + 1);   //为了使索引和桶数相对应，所以+1

//将对应频率的数字放入桶中，填充完后桶即为有序（利用空间来排序（通过频率与空间顺序的结合））
    // 填充桶，buckets[p.second]表示出现次数为p.second的所有元素
    for (const auto & p : counts) {
        buckets[p.second].push_back(p.first);
    }

    // 用于存放结果的数组
    vector<int> ans;

//拿出桶来
    // 从出现次数最高的桶开始，取出前k个桶的所有元素
    for (int i = max_count; i >= 0 && ans.size() < k; --i) {
        for (const int & num : buckets[i]) {
            ans.push_back(num);
            if (ans.size() == k) {
                break;
            }
        }
    }

    return ans;
}

Sort Characters By Frequency

Given a string s, sort it in decreasing order based on the frequency of the characters. The frequency of a character is the number of times it appears in the string.

Return the sorted string. If there are multiple answers, return any of them.

Example 1:

Input: s = “tree”
Output: “eert”
Explanation: ‘e’ appears twice while ‘r’ and ‘t’ both appear once.
So ‘e’ must appear before both ‘r’ and ‘t’. Therefore “eetr” is also a valid answer.

Example 2:

Input: s = “cccaaa”
Output: “aaaccc”
Explanation: Both ‘c’ and ‘a’ appear three times, so both “cccaaa” and “aaaccc” are valid answers.
Note that “cacaca” is incorrect, as the same characters must be together.

Example 3:

Input: s = “Aabb”
Output: “bbAa”
Explanation: “bbaA” is also a valid answer, but “Aabb” is incorrect.
Note that ‘A’ and ‘a’ are treated as two different characters.

Constraints:

1 <= s.length <= 5 * 105
s consists of uppercase and lowercase English letters and digits.

 				  
class Solution {
public:
    string frequencySort(string s) {
        int max_count = 0;
        unordered_map<char,int> count;
        
        // 1. 遍历字符串s，计算每个字符出现的次数，并找到最大次数。
        for(char c : s) {
            max_count = max(max_count, ++count[c]);
        }

        // 2. 使用桶排序思想，创建一个大小为字符串s的长度+1的向量。
        vector<vector<char>> bucket(s.size() + 1);

        // 3. 根据每个字符出现的次数，将其放入对应的桶中。
        for(auto &p : count) {
            bucket[p.second].push_back(p.first);
        }

        string ans;
        // 4. 从最大次数开始，按频率从高到低的顺序将字符添加到答案字符串中。
        for(int i = max_count; i > 0; --i) {
            int k = bucket[i].size() - 1;
            // 对于每个桶，考虑其中的每个字符。
            while(k >= 0) {
                int j = i;
                // 将每个字符重复i次，即它在字符串s中出现的次数。
                while(j-- > 0) {
                    ans += bucket[i][k];
                }
                k--;
            }
        }
        return ans;  // 返回重新排序后的字符串。
    }
};

Sort Colors

Given an array nums with n objects colored red, white, or blue, sort them in-place so that objects of the same color are adjacent, with the colors in the order red, white, and blue.

We will use the integers 0, 1, and 2 to represent the color red, white, and blue, respectively.

You must solve this problem without using the library’s sort function.

Example 1:

Input: nums = [2,0,2,1,1,0]
Output: [0,0,1,1,2,2]

Example 2:

Input: nums = [2,0,1]
Output: [0,1,2]

Constraints:

n == nums.length
1 <= n <= 300
nums[i] is either 0, 1, or 2.

希尔排序

它首先选择一个“增量”或“间隔”（在这个实现中，间隔是数组长度的一半，并在每次迭代中减半）。然后，它对间隔内的所有元素进行插入排序。这一过程重复，每次都将间隔减小，直到间隔为1，这时整个数组都被排序。

下面是您代码的基本步骤：

设置初始间隔为数组长度的一半。
对间隔内的所有元素进行插入排序。
将间隔减半并重复上述过程。
当间隔减少到1时，整个数组都被排序。

您的实现基于希尔排序的基本思想，使用了一个三层循环结构来实现。外部循环控制间隔的递减，中间循环遍历每个间隔组，而内部循环则是基于插入排序的元素交换。

这个实现采用的增量序列为最简单的“每次除以2”，但在实际应用中，有些其他的增量序列可能会导致更好的性能。不过这个实现已经很好地展示了希尔排序的基本思想。

思路：通过对序列分组然后分别对每组进行排序，再把拍好的序列进行嵌合，简单来说就是不断缩小所排元素的密度最终完成最序列的排序。

void shell_sort(std::vector<int>& nums)
	{
		int n = nums.size();
		for (int gap = n / 2; gap > 0; gap /= 2)
		{
			for (int i = gap; i < n; ++i)
			{
				for (int j = i; j >= gap && nums[j] < nums[j - gap]; j -= gap)
					std::swap(nums[j], nums[j - gap]);
			}
		}
	}

CClaris

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
弄懂所有排序算法（C++）

插入排序是一种简单的排序算法，它的工作原理是通过构建有序序列，对未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。选择排序是一种简单直观的排序算法，其基本思想是从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余的未排序元素中寻找到最小（或最大）元素，然后放到已排序的序列的末尾。冒泡排序被这样命名是因为，随着排序过程的进行，最大的元素（如果是升序排序）或者最小的元素（如果是降序排序）就像水中的"气泡"一样，慢慢"浮"到数组的顶端或者尾部。
复制链接

扫一扫