各种排序之快速排序,计数排序,桶排序

一、快速排序

通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。

算法实现

  1. 在数组中选择一个数,分别从数组的两端扫描数组,

  2. 从后半部分开始,如果发现有元素比该基准点的值小,就交换位置

  3. 然后从前半部分开始扫描,发现有元素大于基准点的值,继续交换位置

  4. 如此往复循环,让这个点左边都比他小,右边都比他大

之后继续采用递归的方式分别对前半部分和后半部分排序,当前半部分和后半部分均有序时该数组就自然有序了。

复杂度

代码示例

#include <iostream>
#include<vector>
using namespace std;

void quickSort(vector<int>& nums, int low, int high) {
	int i = low, j = high, temp;
	if (i < j) {
		temp = nums[low];
		while (i < j) {
			while (i < j && nums[j] > temp) --j;
			if (i < j) nums[i++] = nums[j];
			while (i < j && nums[i] < temp) ++i;
			if (i < j) nums[j--] = nums[i];
		}
		nums[i] = temp; for (int i : nums)cout << i << ' '; cout << endl;
		quickSort(nums, low, i - 1);
		quickSort(nums, j + 1, high);
	}
}


int main(int argc, const char* argv[]) {
	vector<int>vec = { 5,2,1,7,3,9,8,4,6 };
	int n = vec.size();
	quickSort(vec, 0, n-1);
	return 0;
}

输出结果

 

二、计数排序

计数排序是将输入的数据值转化为键存储在额外开辟的数组空间中。计数排序算法不是基于元素比较,而是利用数组下标来确定元素的正确位置。

算法实现

1. 找出待排序的数组中最大和最小的元素

2.统计数组中每个值为i的元素出现的次数,存入数组C的第i项

3.对所有的计数累加(从C中的第一个元素开始,每一项和前一项相加)

4.反向填充目标数组:将每个元素i放在新数组的第C(i)项,每放一个元素就将C(i)减去1

复杂度

 

 代码示例

#include <iostream>
#include<vector>
using namespace std;

void countSort(vector<int>& arr) {//计数,计算每个数字出现的次数,用count数组保存
    int len = arr.size();
    if (len == 0) return;
    int max = arr[0], min = arr[0];
    for (int i = 1; i < len; i++) { //算出数组最大最小值
        if (arr[i] > max) max = arr[i];
        if (arr[i] < min) min = arr[i];
    }

    int size = max - min + 1; 
    vector<int>count(size, 0);
    for (int i = 0; i < len; i++)//计算每个数字出现的次数
        count[arr[i] - min]++;   
    for (int i = 1; i < size; i++)
        count[i] += count[i - 1]; //计算每个数字及它前面的数组总共出现的次数
    
    vector<int>psort(len, 0);
    for (int i = len - 1; i >= 0; i--) {//比如遍历到原数组的3,它和它前面一共有3个数,
                                    //所以count[arr[i] - min]=3,排在第三个,下标2.
        psort[count[arr[i] - min]-1] = arr[i]; for (int i : psort)cout << i << ' '; cout << endl;
        count[arr[i] - min]--; 
    }  
    for (int i = 0; i < len; i++) {
        arr[i] = psort[i];
    }
}

int main(int argc, const char* argv[]) {
	vector<int>vec = { 5,2,1,7,3,9,8,4,6 };
	int n = vec.size();
    countSort(vec);
	return 0;
}

输出结果

三、桶排序

桶排序的原理是划分多个范围相同的区间,每个子区间自排序,最后合并,是计数排序的扩展版本。计数排序可以看成每个桶只存储相同元素,而桶排序每个桶存储一定范围的元素,通过映射函数,将待排序数组中的元素映射到各个对应的桶中,对每个桶中的元素进行排序,最后将非空桶中的元素逐个放入原序列中。

算法实现

  1. 根据待排序集合中最大元素和最小元素的差值范围和映射规则,确定申请的桶个数;

  2. 遍历待排序集合,将每一个元素移动到对应的桶中;

  3. 对每一个桶中元素进行排序,并移动到已排序集合中。

复杂度

空间复杂度为O(N+M),时间复杂度为O(nlog(n / m+1)),当桶的数量m接近数据个数n时,时间复杂度接近O(n)

代码示例

#include <iostream>
#include<vector>
using namespace std;

void bucketSort(vector<int>&nums)
{
    int i, j, n = nums.size(), max = nums[0];
    for (int& i : nums)if (i > max)max = i;//求最大值
    vector<int>buckets(max, 0);

    // 1. 计数
    for (i = 0; i < n; i++)
        buckets[nums[i]-1]++;
    for (int i : buckets)cout << i << ' '; cout << endl;
    // 2. 排序
    for (i = 0, j = 0; i < max; i++)
    {
        while ((buckets[i]--) > 0)
            nums[j++] = i+1;
    }for (int i : nums)cout << i << ' ';
}

int main(int argc, const char* argv[]) {
	vector<int>vec = { 5,2,1,7,3,9,8,4,6,7,3 };
    bucketSort(vec);
	return 0;
}

输出:

进阶版

#include<iterator>
#include<iostream>
#include<vector>
using namespace std;
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;
            head = head->mNext;
    }
}

图示过程

四、基数排序

原理是原理是将整数按位数切割成不同的数字,然后按每个位数分别比较。

算法实现

任何一个阿拉伯数的个位数上的基数都是以0~9来表示的。所以可以把0~9视为10个桶。

  1. 根据序列的各个位数的数字来进行分类,将其分到指定的桶中。

  2. 分类后从各个桶中,将这些数按照从编号0到编号9的顺序依次将所有数取出来。

  3. 得到的序列就是个位数上呈递增趋势的序列。

  4. 接下来对十位数、百位数也按照这种方法进行排序,最后就能得到排序完成的序列。

复杂度

 代码示例

#include <stdio.h>
#include <string.h>
 
/* 获取输入数字的索引值,dec指定数字的位数,3代表百位数,order指定需要获取哪一位的索引,1代表个位,2代表十位,3代表百位 */
int get_index(int num, int dec, int order)
{
    int i, j, n;
    int index;
    int div;
 
    /* 根据位数,循环减去不需要的高位数字 */
    for (i=dec; i>order; i--) {
        n = 1;
        for (j=0; j<dec-1; j++)
            n *= 10;
        div = num/n;
        num -= div * n;
        dec--;
    }
 
    /* 获得对应位数的整数 */
    n = 1;
    for (i=0; i<order-1; i++)
        n *= 10;
 
    /* 获取index */
    index = num / n;
 
    return index;
}
 
/* 进行基数排序 */
void radix_sort(int array[], int len, int dec, int order)
{
    int i, j;
    int index;     /* 排序索引 */
    int tmp[len];  /* 临时数组,用来保存待排序的中间结果 */
    int num[10];   /* 保存索引值的数组 */
    memset(num, 0, 10*sizeof(int));  /* 数组初始清零 */
    memset(tmp, 0, len*sizeof(int)); /* 数组初始清零 */
 
    if (dec < order) /* 最高位排序完成后返回 */
        return;
 
    for (i=0; i<len; i++) {
        index = get_index(array[i], dec, order);  /* 获取索引值 */
        num[index]++;  /* 对应位加一 */
    }
 
    for (i=1; i<10; i++)
        num[i] += num[i-1]; /* 调整索引数组 */
 
    for (i=len-1; i>=0; i--) {
        index = get_index(array[i], dec, order);  /* 从数组尾开始依次获得各个数字的索引 */
        j = --num[index];  /* 根据索引计算该数字在按位排序之后在数组中的位置 */
        tmp[j] = array[i]; /* 数字放入临时数组 */
    }
 
    for (i=0; i<len; i++)
        array[i] = tmp[i];  /* 从临时数组复制到原数组 */
 
    printf("the %d time\n", order);
    for (i=0; i<30; i++)
        printf("%d  ", array[i]);
    printf("\n");
 
    radix_sort(array, len, dec, order+1);/* 继续按高一位的数字大小进行排序 */
 
    return;
}
 
int main(int argc, char *argv[])
{
    int i;
    int array[30] = {258, 976, 515, 337, 359, 701, 916, 494, 303, 175,
                        677, 825, 131, 560, 147, 254, 759, 814, 917, 382,
                        452, 114, 873, 585, 881, 127, 819, 658, 461, 435};
 
    int len = 30;  /* 测试数据个数 */
    int dec = 3;   /* 数据位数,3代表3位数 */
    int order = 1; /* 排序的位数,1代表个位、2代表十位、3代表百位 */
 
    printf("before\n");
    for (i=0; i<30; i++)
        printf("%d  ", array[i]);
    printf("\n");
 
    /* 排序函数,从个位开始 */
    radix_sort(array, len, dec, order);
 
    printf("final\n");
    for (i=0; i<30; i++)
        printf("%d  ", array[i]);
    printf("\n");
 
    return 0;
}

  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值