10种C++排序算法

最新推荐文章于 2024-06-06 09:34:24 发布
最新推荐文章于 2024-06-06 09:34:24 发布
阅读量3k 收藏 44
点赞数 25
分类专栏： 算法 《数据结构与算法之美》学习笔记 文章标签： 排序算法 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21201267/article/details/80993672
版权

文章目录

题目：LeetCode 912. 排序数组（10种排序）
下面博文，为早期学习写的，很不简洁，请参考上面题目的版本。

1.插入排序

/*
 * 1.插入排序
 * 每次在末尾插入一个数字，依次向前比较，类似与抓扑克牌(插入排序，每次左边的子序列都是有序的)
 */
void insertsort(size_t dsize, int *arr) //dsize是数组arr的长度
{
	if(dsize <= 1)	//预防特殊情况下后面代码失效
    {
        return;
    }
	for (size_t i = 0; i != dsize; ++i) 
	{
		for (size_t j = i; j > 0 && arr[j-1] > arr[j]; --j)
		//每次的子列都是有序的，判断条件可写在for(内)，否则不可（这么做减少运行次数）
		//每次和有序数组最后一个比较，向前搜索，直到找到位置停止
		{
			swap(arr[j-1], arr[j]);
		}
	}
}

/*
 时间复杂度分析
 最好情况：原数列有序，每次放在最后就好了，复杂度为n
 最坏情况：原数列倒序的，每次都要挪到最前面，1+2+...+n-1=n(n-1)/2
 */

2.冒泡排序

/*
 *2.冒泡排序，数从前向后冒泡比较，冒泡过程中，数列无序状态
 */
void bsort(size_t dsize, int *arr)
{
	if(dsize <= 1)	//预防特殊情况下后面代码失效
    {
        return;
    }
	bool arrisok = false;
	for(size_t i = 0; i != dsize; ++i)
	{	
		arrisok = true;
		for(size_t j=1;j <= dsize-1-i;++j)	//后面的数都排好了，所以j<=dsize-1-i,不减i,也可，但时间长
		{	
			if(arr[j-1]> arr[j])	
			//比较的过程中是无序的，判断条件写在for{}里
			//写在for()里会出现局部条件不满足就退出for循环了，以至于还未排序完
			{
				swap(arr[j-1],arr[j]);
				arrisok = false;  //如果交换过，则数组未完成排序
			}
		}
		if(arrisok == true)
		{
			return; //经过一轮冒泡后,数据没有发生交换则数据为有序，可退出函数，可减少12%时间（用自己的程序）
		}
	}
}

/*
 时间复杂度分析
 最好情况：原数列有序，复杂度为n
 最坏情况：原数列倒序的，每次都要从前挪到后面，n-1+n-2+...+1=n(n-1)/2
 */

3.选择排序

/*
 *3.选择排序,每次找出数值最小的下标，交换未排序区域第一个与最小的(与冒泡的区别，只交换一次)
 */
void selecsort(size_t dsize, int *arr)
{
	if(dsize <= 1)	//预防特殊情况下后面代码失效
    {
        return;
    }
	size_t mindex=0;
	for(size_t i =0; i!= dsize-1; ++i)
	{	
		mindex= i ;
		for(size_t j=i+1;j!=dsize;++j)
		{	
			if(arr[j]< arr[mindex])	//子列为无序的，判断条件写在for{}里
			{	
				mindex = j;		//记录下最小数的下标
			}
		}
		swap(arr[i],arr[mindex]);
	}
}

/*
 时间复杂度分析
 最好情况：（与最坏一样）
 最坏情况：每次都要从前到后比较，n-1+n-2+...+1=n(n-1)/2
 */

4.希尔排序

/*
 * 4.希尔排序，分组插入排序，相隔gap个数的都为一组，从第gap个数开始
 */
void shellsort(size_t dsize, int *arr)
{
	if(dsize <= 1)	//预防特殊情况下后面代码失效
    {
        return;
    }
	size_t gap = 1;
	size_t j=0;
	for(gap=dsize/2;gap> 0;gap /= 2)
	{	
		for(size_t i = gap;i < dsize;++i)
		{	
			for(j=i;int(j-gap)>=0 && arr[j-gap]> arr[j];j -= gap)	
			//int()转换类型，避免溢出，相当于分组的插入排序
			{
				swap(arr[j-gap],arr[j]);
			}
		}
	}
}

/*
 时间复杂度分析
[参考](https://blog.csdn.net/ginnosx/article/details/12263619)
 最好情况：
 最坏情况：
 */

5.归并排序

/*
 *5.归并排序，自顶向下，递归
 */
void merge(int *arr,size_t left,size_t mid,size_t right)
{
	int len = right - left + 1;
	int *temp = new int [len];  //数组较长时请用new，不然栈空间容易溢出
	size_t index = 0;
	size_t i = left, j = mid + 1;
	while(i <= mid && j <= right)
	{
		temp[index++] = arr[i]<= arr[j]? arr[i++]: arr[j++]; //对两边的数组从小到大放入临时空间
	}
	while(i <= mid)		//比较完后，左半边有没放进去的，直接写入
	{
		temp[index++]= arr[i++];
	}
	while(j <= right)	//比较完后，右半边有没有放进去的，直接写入
	{
		temp[index++]= arr[j++];
	}
	for(int k = 0;k< len;++k)
	{
		arr[left++ ]= temp[k];  //把有序的临时数组写入原来数组的起始位置
	}
	delete [] temp;  //释放空间
	temp = NULL;  //指针置空
}
void divide(int *arr,size_t left,size_t right)
{
	if(left == right)
    {   
	    return;
	}
    size_t mid = (left+right)/2;  //找出区间中部的数，将数组分段
    divide(arr,left,mid);  //递归调用，对左边继续分段；
    divide(arr,mid+1,right);  //递归调用，对右边继续分段；
	merge(arr,left,mid,right); //对左右两半进行排序合并成一小段有序的数组
}
void mergesort(size_t dsize, int *arr)
{
	if(dsize <= 1)	//预防特殊情况下后面代码失效
    {
        return;
    }
	size_t left = 0, right = dsize-1;
	divide(arr,left,right);
}

6.快速排序

/*
 1. 6.快速排序
 2. 对数组找出一个中间大小的合适哨兵，把小于哨兵的放左边，大于哨兵的放右边，中间是等于哨兵的
 3. 分别对左右递归调用快排
 */
size_t parr [2]; //全局变量，全局变量不好，长期占用内存，每个函数都可访问，容易被修改，函数间相互干扰
void selectmedianofthree(int *arr, size_t left, size_t right)  //找出中间大小的数做哨兵
{
        size_t mid = left + (right - left)/2;  //中部数据的下标
        if(arr[mid]>arr[right])  
        {
                swap(arr[mid],arr[right]);
        }
        if(arr[left]>arr[right])
        {
                swap(arr[left],arr[right]);
        }
        if(arr[mid]>arr[left])
        {
                swap(arr[mid],arr[left]);  //把中间大小的数值放到首位
        }
}
void partion(int *arr, size_t left, size_t right)  //数据分段
{
    selectmedianofthree(arr,left,right);  //找出中间大小的哨兵，让分段尽量均匀，提高效率
    size_t lessPnum = 0, largePnum=0;
    int pval = arr[left];  //中间大小的数赋值给哨兵
    int *temp = new int [right-left+1];  //开辟堆空间存放临时数组
    int tempLindex=0, tempRindex = right-left;  //临时数组的首末位下标
    for(int i = left+1; i <= right; ++i)
    {
        if(pval > arr[i]) //比哨兵小的放在左边，从左边首位往中间写入，记录下比哨兵小的有多少个
        {
            temp[tempLindex++] = arr[i];
            ++lessPnum;
        }
        if(pval < arr[i])  比哨兵大的放在右边，从右边末位中间写入，记录下比哨兵大的有多少个
        {
            temp[tempRindex--] = arr[i];
            largePnum++;
        }
    }
    for( ; tempLindex <= tempRindex; ++tempLindex)
    //中间还未被写入的位置，写入哨兵（哨兵可能是多个相同的值）
    {
        temp[tempLindex] = pval;
    }
    for(int i = left, j=0; i <= right; ++i)
    {
        arr[i] = temp[j++]; //把分好段的数组写回原数组{[小于哨兵的],[等于哨兵的],[大于哨兵的]}
    }
    delete [] temp; //释放临时数组
    temp = NULL;  //指针置空
    parr[0]=lessPnum;
    parr[1]=largePnum;  //可以采用被调用函数的参数引用回传给主函数
}
void qsort(int *arr, size_t left, size_t right, int deep)
{
	if(left >= right)
    {
        return;
    }
    else if(right-left == 1) 
    //只有两个数直接比较交换（也可以设置长度小于X（比如10），调用其他排序，如归并，减少不必要的调用快排）
    {
        if(arr[left]>arr[right])
        {        
        	swap(arr[left], arr[right]);
        }
    }
    else
    {
        partion(arr,left,right);  //数据分段，{[小于哨兵的],[等于哨兵的],[大于哨兵的]}
        size_t pl_index = left + parr[0];  //首位哨兵的下标
        size_t pr_index = right - parr[1];  //末位哨兵的下标
        if(pr_index == right && pl_index != left)  //哨兵群位于数组最右边，且左边还有数据
        {
	       qsort(arr,left,pl_index-1,deep); //只对左边非哨兵数据快排
        }
        else if(pl_index == left && pr_index != right)  //哨兵群位于数组最左边，且右边还有数据
        {       
			qsort(arr,pr_index+1,right,deep);  //只对右边非哨兵数据快排
        }
        else if(pl_index == left && pr_index == right) //全部是哨兵，两侧无数据，退出
        {
            return;
        }
        else  //两侧都有非哨兵数据，对两侧调用快排
        {
            qsort(arr,left,pl_index-1,deep);
            qsort(arr,pr_index+1,right,deep);
        }
    }
}
void quicksort(size_t dsize, int *arr)
{
	if(dsize <= 1)	//预防特殊情况下后面代码失效
    {
        return;
    }
	size_t left = 0, right = dsize-1;
	int deep = 0;  //可以打印显示出调用的层数
	qsort(arr,left,right,deep);
}

6.1.快速排序（改进）

/*
 * 6-1.快速排序(改进：不使用全局变量传递参数)
 * 对数组找出一个中间大小的合适哨兵，把小于哨兵的放左边，大于哨兵的放右边，中间是等于哨兵的
 * 分别对左右递归调用快排
 */
void selectmedianofthree(int *arr, size_t left, size_t right)  //找出中间大小的数做哨兵
{
        size_t mid = left + (right - left)/2;  //中部数据的下标
        if(arr[mid]>arr[right])  
        {
                swap(arr[mid],arr[right]);
        }
        if(arr[left]>arr[right])
        {
                swap(arr[left],arr[right]);
        }
        if(arr[mid]>arr[left])
        {
                swap(arr[mid],arr[left]);  //把中间大小的数值放到首位
        }
}
void partion(int *arr, size_t left, size_t right, size_t &lessPnum, size_t &largePnum)//数据分段
{
    selectmedianofthree(arr,left,right);  //找出中间大小的哨兵，让分段尽量均匀，提高效率
    int pval = arr[left];  //中间大小的数赋值给哨兵
    int *temp = new int [right-left+1];  //开辟堆空间存放临时数组
    int tempLindex=0, tempRindex = right-left;  //临时数组的首末位下标
    for(int i = left+1; i <= right; ++i)
    {
        if(pval > arr[i]) //比哨兵小的放在左边，从左边首位往中间写入，记录下比哨兵小的有多少个
        {
            temp[tempLindex++] = arr[i];
            ++lessPnum;
        }
        if(pval < arr[i])  比哨兵大的放在右边，从右边末位中间写入，记录下比哨兵大的有多少个
        {
            temp[tempRindex--] = arr[i];
            largePnum++;
        }
    }
    for( ; tempLindex <= tempRindex; ++tempLindex)
    //中间还未被写入的位置，写入哨兵（哨兵可能是多个相同的值）
    {
        temp[tempLindex] = pval;
    }
    for(int i = left, j=0; i <= right; ++i)
    {
        arr[i] = temp[j++]; //把分好段的数组写回原数组{[小于哨兵的],[等于哨兵的],[大于哨兵的]}
    }
    delete [] temp; //释放临时数组
    temp = NULL;  //指针置空
}
void qsort(int *arr, size_t left, size_t right, int deep)
{
	if(left >= right)
    {
        return;
    }
    else if(right-left == 1)
    //只有两个数直接比较交换（也可以设置长度小于X（比如10），调用其他排序，如归并，减少不必要的调用快排）
    {
        if(arr[left]>arr[right])
        {
            swap(arr[left], arr[right]);
        }
    }
    else if(right-left > 1 && right-left < 20)  //数组长度较小时，调用希尔排序，减少调用快排
    {
        size_t len = right - left + 1;
        shellsort(len, &arr[left]); //数组首地址为&arr[left]
    }
    else
    {
        size_t lessPnum = 0, largePnum=0;
        partion(arr,left,right,lessPnum,largePnum);  //数据分段，{[小于哨兵],[等于哨兵],[大于哨兵]}
        size_t pl_index = left + lessPnum;  //首位哨兵的下标
        size_t pr_index = right - largePnum;  //末位哨兵的下标
        if(pr_index == right && pl_index != left)  //哨兵群位于数组最右边，且左边还有数据
        {
	       qsort(arr,left,pl_index-1,deep); //只对左边非哨兵数据快排
        }
        else if(pl_index == left && pr_index != right)  //哨兵群位于数组最左边，且右边还有数据
        {       
			qsort(arr,pr_index+1,right,deep);  //只对右边非哨兵数据快排
        }
        else if(pl_index == left && pr_index == right) //全部是哨兵，两侧无数据，退出
        {
            return;
        }
        else  //两侧都有非哨兵数据，对两侧调用快排
        {
            qsort(arr,left,pl_index-1,deep);
            qsort(arr,pr_index+1,right,deep);
        }
    }
}
void quicksort(size_t dsize, int *arr)
{
	if(dsize <= 1)	//预防特殊情况下后面代码失效
    {
        return;
    }
	size_t left = 0, right = dsize-1;
	int deep = 0;  //可以打印显示出调用的层数
	qsort(arr,left,right,deep);
}

7.堆排序

/*
 * 7.堆排序，建堆（升序建大堆，降序建小堆）
 * 交换堆顶与最后一位无序数据
 * 调整堆，递归，交换调整
 */
void adjust(int *arr, size_t i, size_t dsize)
{
	size_t LowerLeftNode = i*2+1;	//下一层左边的节点
	while(LowerLeftNode < dsize)
	{
		if(LowerLeftNode+1< dsize && arr[LowerLeftNode]< arr[LowerLeftNode+1] )
		{
			++LowerLeftNode;
		}
		if(arr[i]> arr[LowerLeftNode])  //如果上层节点大于小面两个子节点，结束
		{
			break;
		}
		swap(arr[i], arr[LowerLeftNode]);
		i = LowerLeftNode;  //往下循环调整
		LowerLeftNode = i*2+1;
	}
}
void makeheap(size_t dsize, int *arr)
{
	for(size_t i = dsize/2 -1; i >=0;--i)	//从后往前，底下第二层（第一个有子节点的元素的下标）
	{
		adjust(arr,i,dsize);  //有子节点，调整堆（从i节点往下，末位固定dsize-1）
		if(i == 0)
			break;
	}
}
void heapsort(size_t dsize, int *arr)
{
	if(dsize <= 1)	//预防特殊情况下后面代码失效
    {
        return;
    }
	makeheap(dsize,arr); //建立堆，大堆，上面父节点比子节点大
	size_t i = 0;
	for(i=dsize-1;i>=0;--i) //从最后一位开始，与堆顶交换，调整堆，尾部数据减1
	{
		swap(arr[i],arr[0]);  //把最大的arr[0]与队尾交换
		adjust(arr,0,i);   //从第0位往下开始调整，末位不固定，数组长度i，每次减一
		if(i == 0)  //i = 0，退出，防止--i，size_t溢出
			break;
	}
}

8.计数排序

/*
 *8.计数排序，找出数列中最大最小的数，并记录下每一个元素的个数，然后放回
 */
void countsort(size_t dsize, int *arr)
{
	if(dsize <= 1)	//预防特殊情况下后面代码失效
    {
        return;
    }
	int index = 0;
	int min, max;
	min = max = arr[0];
	for(int i = 1; i<dsize;++i)
	{
		min=(arr[i] < min)? arr[i] : min;
		max=(arr[i] > max)? arr[i] : max;
	}
	//创建新的数组存放
	int k = max -min +1;
	int *temp = new int [k]();	//（）初始化为0
	for(int i = 0;i< dsize;++i)
	{
		++temp[arr[i]-min];	//记录每个数的个数，存入数组
	}
	for(int i = min; i <= max;++i)
	{
		for(int j = 0; j < temp[i-min];++j)	//存放元素个数不为0的，才进入循环
		{
			arr[index++] = i;  //把元素值写回数组
		}
	}
	delete [] temp;
	temp = NULL;
}

9.桶排序

/*
 *9.桶排序，将数据按规则分组，对各小组再分别排序
 */
void bucketsort(size_t dsize, int *arr)
{
    if(dsize <= 1)	//预防特殊情况下后面代码失效
    {
        return;
    }
    int maxval = arr[0];
    int minval = arr[0];
    for(int i = 0; i != dsize; ++i)	//遍历数组，找出最大最小元素
    {
        maxval = maxval > arr[i] ? maxval : arr[i];
        minval = minval < arr[i] ? minval : arr[i];
    }
    if(maxval == minval)	//如果最大==最小，数组不需要排序（排除下面div=0，进不了位，div总是为0）
    {
        return;
    }
    else
    {
        int space = 10000;  //每个桶数元素值的最大差值（区间大小）
        int div = ceil((double)(maxval-minval)/space);   
        //桶的个数，ceil取进位数(先double强转（float的精度不够高），避免丢失小数点)
        //space 太小，桶个数太多，会造成栈空间溢出
        int numsofeachbucket[div];	//开辟数组，存放每个桶内的元素个数
        //知识点：
        //1.桶的个数跟数据相关，space是固定的，但是桶的个数会根据环境变化，不能确保程序在其他环境下正确运行
        //2.div很大时，int numsofeachbucket[div]，直接撑爆栈空间，需要采用new 开辟堆空间
        //3.当(maxval-minval)是space的整数倍的时候，段错误，访问越界
        //第3个问题改成int div = floor((double)(maxval-minval)/space)+1;即可
        for(size_t i =0; i != div; ++i)
        {
            numsofeachbucket[i] = 0;	//每个桶的元素个数初始化为0
        }
        for(size_t i = 0; i != dsize; ++i)
        {
            ++numsofeachbucket[(arr[i]-minval)/space];  //把元素按大小分到不同的桶，并增加该桶元素个数
        }
        int **p = new int* [div];	//开辟堆空间，指针数组，每个元素（指针）指向每个桶的0位
        int **temp = new int* [div];	
        //临时数组，保存某些指针的初始值，方便delete（delete时，指针必须位于初始位置）
        int **temp_1 = new int* [div];	
        //同上（改进启发：数组长度是一定的，申请一次内存，知道每个桶始末位置即可）
        for(size_t i = 0; i != div; ++i)
        {
            if(numsofeachbucket[i] != 0)	
            //桶内有元素（没有元素就不要申请空间了，如申请了，指针的地址是不为NULL的，会出问题）
            {
                p[i] = new int [numsofeachbucket[i]];	//指针数组，每个元素（指针）指向每个桶的0位
                temp[i] = p[i];	
                //记录每个桶申请的空间的初始地址，后面delete temp_1[i]即可删除开辟的p[i] new出的空间
                temp_1[i] = p[i];	//记录初始地址，后面p[i],temp[i]（指针）也要挪动
            }
            else
            {
                p[i] = NULL;	//没有元素的桶，不申请空间，指针初始化为NULL
                temp[i] = NULL;
                temp_1[i] = NULL;
            }
        }
        for(size_t i = 0; i != dsize; ++i)
        {
            size_t bucketidx = (arr[i]-minval)/space;	//遍历数组，每个元素的桶号
            *p[bucketidx] = arr[i];	//把每个元素写入对应的桶中
            ++p[bucketidx];	//该桶指针后移一位
        }
        size_t idx = 0;	//之前用了static，下次调用的时候idx不会被赋值 =0 操作
        //cout << "static idx " << idx << endl;
        for(size_t i = 0; i != div; ++i)
        {
            if(numsofeachbucket[i] != 0)	//桶非空
            {
                if(numsofeachbucket[i]>1)	//桶元素个数2个或更多
                {
                    quicksort(numsofeachbucket[i], temp[i]);   
                    //对动态数组进行快速排序（p[i]挪动过了，temp[i]指向数组首位）
                }
                for(size_t j = 0; j != numsofeachbucket[i]; ++j)
                {
                    arr[idx++] = *temp[i];	//对排序后的数组（1个元素不需排序），写入原数组
                    ++temp[i];
                    //cout << "static idx " << idx << endl;
                }
            }
        }
        for(size_t i = 0; i != div; ++i)
        {
            if(numsofeachbucket[i] != 0)	//对申请出来的空间，释放掉
            {
                delete [] temp_1[i];	//上面每个桶的数组初始位置指针p[i],temp[i]都动过了，所以用此副本初始地址
                temp_1[i] = NULL;		//被释放的空间的相关的指针置为空
                temp[i] = NULL;
                p[i] = NULL;
            }
        }
        delete [] temp_1;	//delete 与 new 配对出现，释放数组，指针置NULL
        delete [] temp;		//内存检测工具valgrind	http://valgrind.org/
        delete [] p;
        temp_1 = NULL;
        temp = NULL;
        p = NULL;
    }
}

9.1.桶排序（改进）

/*
 *9-1.桶排序，将数据按规则分组，对各小组再分别排序
 *（改进）
 *1.数组长度一定的，只申请一次内存，避免内存碎片化，提高效率
 *2.给定桶的个数，程序运行状况在不同环境下可控
 */
void bucketsort1(size_t dsize, int *arr)
{
    if(dsize <= 1)	//预防特殊情况下后面代码失效
    {
        return;
    }
    int maxval = arr[0];
    int minval = arr[0];
    for(int i = 0; i != dsize; ++i)	//遍历数组，找出最大最小元素
    {
        maxval = maxval > arr[i] ? maxval : arr[i];
        minval = minval < arr[i] ? minval : arr[i];
    }
    if(maxval == minval)	//如果最大==最小，数组不需要排序
    {
        return;
    }
    else
    {
        int div = 1000; //桶的个数
        int space = (maxval-minval)/div+1; //每个桶的数值跨度，+1放大一点包住
        int *numsofeachbucket = new int [div](); //开辟数组，存放每个桶内的元素个数，（）初始化为0
        int *endpositionofeachbucket = new int [div]();	
        for(size_t i = 0; i != dsize; ++i)
        {
            ++numsofeachbucket[(arr[i]-minval)/space];  //把元素按大小分到不同的桶，并增加该桶元素个数
            ++endpositionofeachbucket[(arr[i]-minval)/space];
        }
        for(int i = 1; i != div; ++i)
		{
			endpositionofeachbucket[i] += endpositionofeachbucket[i-1]; 
			//每个桶区间的最大下标+1的值
		}
		int *temparr = new int [dsize];	//开辟堆空间，存放临时数组
        for(size_t i = 0; i != dsize; ++i)
        {
            temparr[--endpositionofeachbucket[(arr[i]-minval)/space]] = arr[i];	
            //遍历数组，把每个元素写入对应的桶中，从每个桶的后部往前写
            //--运行完成后endpositionofeachbucket[i]就是该桶的首位
        }
        for(size_t i = 0; i != div; ++i)
        {
            if(numsofeachbucket[i] > 1)	//桶元素2个或以上才排序
            {
                quicksort(numsofeachbucket[i], &temparr[endpositionofeachbucket[i]]);   
                //对每个桶的数组进行快速排序（元素个数，每个桶数组首位的地址）
            }  
        }
        for(size_t i = 0; i != dsize; ++i)
        {
            arr[i] = temparr[i];	//对排序后的数组，写入原数组
        }
        delete [] numsofeachbucket;	//delete 与 new 配对出现，释放数组，指针置NULL
        delete [] endpositionofeachbucket;		//内存检测工具valgrind	http://valgrind.org/
        delete [] temparr;
        numsofeachbucket = NULL;
        endpositionofeachbucket = NULL;
        temparr = NULL;
    }
}

比较优化前后的桶排序计算效率（同样的环境下）
优化前 运行时间：149s
优化后 运行时间：96s （提升35%）堆的申请和释放次数也降低了

10.基数排序

/*
 *10.基数排序
 */
void radix_countsort(size_t dsize, int *arr, int exp)
{
	int numofeachbucket[10] = {0};  //十个数位，每个桶上有0个元素
	for(int i = 0; i != dsize; ++i)
	{
		++numofeachbucket[(arr[i]/exp)%10];	//记录该数位上相同的元素个数
	}
	for(int i = 1; i < 10; ++i)
	{
		numofeachbucket[i] += numofeachbucket[i-1]; 
		//每个位数区间的最大下标+1的值（现在存储的是下标区间的上限+1）
	}
	int *output = new int [dsize];
	for(int i = dsize-1; i >= 0; --i)
	{
		output[--numofeachbucket[(arr[i]/exp)%10]] = arr[i]; //把数组放在不同的区间位置上
	}
	for(int i = 0; i != dsize; ++i)
	{
		arr[i] = output[i];  //一个数位排好后，写回原数组
	}
	delete [] output;
	output = NULL;
}
void radixsort(size_t dsize, int *arr)
{
	if(dsize <= 1)
	{
		return;
	}
    int maxval = arr[0];
    for(size_t i = 0; i != dsize; ++i)
    {
    	maxval = arr[i] > maxval ? arr[i] : maxval; //找出最大的数
    }
    for(int exp = 1; maxval/exp > 0; exp *= 10) //从最低位开始对每个数位进行排序
    {
    	radix_countsort(dsize, arr, exp);
    }
}
Michael阿明
关注
  • 25
    点赞
  • 踩
  • 44
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 42
    评论
专栏目录
C++ 十大排序算法
qq_36417644的博客
08-18 171
1 快速排序 思想：1选择最右边的数据作为枢轴，左边选择比枢轴大的右边选择比枢轴小的两者交换，完成第一轮 2 在左边选择第一次中大的数据作为枢轴，递归完成左边排序 3 在右边选择第一次中打的数据作为枢轴，递归完成右边排序 ...
十大排序算法及C++实现
Coding
09-17 596
算法 平均时间复杂度 最好 最坏 空间复杂度 稳定性 冒泡排序 o(n2) o(n) o(n2) o(1) 稳定 选择排序 o(n2) o(n2) o(n2) o(1) 不稳定 插入排序 o(n2) o(n) o(n2) o(1) 稳定 希尔排序 o(nlogn) o(nlog2n) o(nlogn) o(1) 不稳定 归并排序 o(nlogn) o(nlogn) ...
十大常见排序算法（C++版本代码）
qq_43036667的博客
04-24 1577
冒泡排序（Bubble sort）是一种交换排序，它的基本思想是：两两比较相邻元素的关键字，如果反序则交换，直到没有反序的记录（数据元素）为止。时间复杂度为O(n^2)，空间复杂度为O(1)稳定算法步骤比较相邻的元素。如果第一个比第二个大，就交换它们两个；对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；针对所有的元素重复以上的步骤，除了最后一个；重复步骤1~3，直到排序完成。
十大排序算法（C++版）
CltCj的博客
02-03 4738
十大排序算法前言一、直接插入排序二、折半插入排序三、希尔排序总结 前言 什么是排序？   排序：将一组杂乱无章的数据按一定规律顺次排列起来。即，将无序序列排成一个有序序列（由小到大或由大到小）的运算。 排序方法的分类   按数据存储介质：内部排序和外部排序   按比较器个数：串行排序和并行排序   按主要操作：比较排序和基数排序   按辅助空间：原地排序和非原地排序   按稳定性：稳定排序和非稳定排序   按自然性：自然排序和非自然排序 一、直接插入排序 基本思想：   每步将一个待排序的对象
C++-排序算法详解
最新发布
一然明月(嵌入式)的博客
06-06 1617
排序算法是一种将一组数据按照特定顺序（如升序或降序）进行排列的算法。其主要目的是对一组无序的数据进行整理，使得它们呈现出一定的有序性。主要排序算法有:冒泡排序.插入排序,快速排序.选择排序,归并排序,堆排序.
[js] 排序算法 (2)
aefg95955的博客
08-22 381
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 平方阶 (O(n2))。 线性对数阶 (O(nlog2n))。 O(n1+§))，§ 是介于 0 和 1 之间的常数。 线性阶 (O(n)) 。 n：数据规模. k：“桶”的个数. In-place：占用常数内存，不占用额外内存...
c++十大经典排序算法
客舟中
12-28 6250
代码 1 冒泡排序 冒泡排序是一种简单直观的入门排序算法。它的原理就是从第一个元素开始，与后面的元素逐个比较，如果顺序不对就交换，直到没有可比较的元素为止。 1 // 冒泡排序 2 void BublingSort(int *arr, int len) 3 { 4 if(len == 0) 5 { 6 return; 7 } 8 std::cout<<"冒泡排序"<<std::endl; 9 for(i
c++十大经典算法排序
back_room的博客
06-22 603
c++十大经典算法排序
c++排序算法
11-24
此排序算法为本人平常学习练习所写，在学习的过程中也是非常希望和大家分享交流
C++排序算法之插入排序
08-25
C++排序算法之插入排序 本文主要介绍了C++排序算法之插入排序的基本思想、算法实现和时间复杂度分析。插入排序是一种简单的排序算法，通过将未排序的数据元素按大小顺序插入到已排好序数据序列中实现排序。 基本...
C++ 排序算法之冒泡排序
07-25
C++ 排序算法之冒泡排序
简单的C++排序算法
11-21
一看就懂，一学就会的C++排序算法。学习数组使用，用数组下标进行选择排序，用双循环实现选择排序。 选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小...
常见的十种排序算法C++实现（附时空复杂度，稳定性分析）
Xavier_97的博客
09-07 3358
每一轮排序使得当前无序的部分的最大值冒到当前无序数组的末尾，下一轮中无序部分的长度等于上一轮减一，原数组的末端不断的变成有序的部分。时间复杂度最坏和平均情况是O()，最好的情况是已经有序所以是O(n)，空间复杂度O(1)，且因为两个相同的元素是不会交换位置的，因此是一种稳定的排序。
10种常见排序算法（c++）
weixin_42034081的博客
05-22 1487
这里写目录标题总览选择排序 总览 先把这个表背下来每个排序算法的平均时间复杂度和空间复杂度 最重要的：插排，堆排，归并，快排 选择排序 这是最简单也最没用的一种排序方式，因为时间复杂度非常高而且不稳定，基本在工程上用不上这个东西； ...
经典排序算法C++实现（10种）
weixin_42023936的博客
08-27 2366
C++实现经典排序算法插入排序希尔排序（缩小增量排序）选择排序堆排序冒泡排序冒泡排序的原理：快速排序合并排序折中排序新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章U...
用C++实现十大经典排序算法
billy的博客
01-04 8127
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。
算法记录——最全排序算法汇总C++版
a15651035561的博客
08-16 279
一、C++排序算法 1. 冒泡排序 void bubbleSort(int a[], int n) { for(int i = 1; i < n; i++) //n-1次 { for(int j = 0; j < n-i; j++) { if(a[j] > a[j+1]) swap(a[j],a[j+1]); } } } 2. 选择排序 void selectSort(int a[], int n) { for(int i = 0; i < n;
C++ 排序大合集
小天狼星_布莱克 的博客
01-08 860
C++排序算法：排序的稳定性、插入排序、选择排序、冒泡排序、优先队列、堆排序、归并排序、计数排序、sort函数
C++实现十大排序算法
qq_45311905的博客
05-18 353
C++实现十大排序算法1 简单选择排序2 冒泡排序3 插入排序4 快速排序5 归并排序6 希尔排序7 堆排序8 计数排序9 桶排序10 基数排序 1 简单选择排序 存在一乱序数组A[0~n] 第一步：以A[0]作为参考点，比较A[1~n], 遍历完数组后，寻找到最小值A[k]（或最大值）的下标k值，然后交换swap(A[0],A[k]); 第二步：以A[1]作为参考点，比较A[2~n], 遍历完数组后，寻找到最小值A[k]（或最大值）的下标k值，然后交换swap(A[1],A[k]); 第i步：以A
C++排序算法探究：快速排序与希尔排序
"关于C++常用排序法研究" 在C++编程中，排序算法是不可或缺的一部分，尤其是在处理大量数据时。本文主要探讨了两种常见的高效排序算法：快速排序和希尔排序，以及如何衡量它们的性能。 首先，为了评估排序算法的...
评论 42
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Michael阿明

如果可以，请点赞留言支持我哦！

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

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

打赏作者

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

抵扣说明：

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

余额充值