各种排序算法总结

最新推荐文章于 2024-01-03 22:56:09 发布
最新推荐文章于 2024-01-03 22:56:09 发布
阅读量318 收藏 5
点赞数 2
分类专栏： 算法 文章标签： 各种排序算法总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/songsongL/article/details/99428709
版权

文章目录

排序的基本概念

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
快速记忆不稳定排序有哪些：快（快速排序）些（希尔排序）选（选择排序）一堆（堆排序）美女

返回顶部

冒泡排序（Bubble Sort）

思想： 两两比较相邻关键字，及时交换。
过程： 每一趟沉淀一个最大的数。整个过程就像水泡的浮起过程，故因此而得名。
实现代码：

void BubbleSort1(int a[],int n){//冒泡排序 
	for(int i=0;i<n-1;i++){
		for(int j=0;j<n-1-i;j++){
			if(a[j]>a[j+1]){
				swap(a[j],a[j+1]);
			}
		}
	}
}

运行结果：
在这里插入图片描述
上述代码有一点问题，就是如果某一趟没有发生任何关键字的交换（说明关键字已经有序了），这时就不在需要再继续去比较了。

改进后的冒泡排序：

void BubbleSort2(int a[],int n){//改进的冒泡排序 
	int bound,exchange=n-1;
	while(exchange!=0){
		bound=exchange;
		exchange=0;
		for(int j=0;j<bound;j++){			
			if(a[j]>a[j+1]){
				swap(a[j],a[j+1]);
				exchange=j;
			}
		}
	}
}

运行结果：
在这里插入图片描述
算法分析：
最好情况（正序）：
只需一趟排序，比较n-1次且不移动记录。

最坏情况（逆序）：
需n-1趟排序。每一趟比较n-1,n-2,…1次,等差数列，每次交换移动3次记录。
总的比较次数 KCN=n(n-1)/ 2
总的移动次数 RMN=3n(n-1)/ 2

平均情况下：
比较次数： (n-1)(n+2)/4 ,约为 n2/4
移动次数： 3n(n-1)/4,约为 3n2/4

时间复杂度：O(n2)
空间复杂度： O(1)

算法特点：

  • 是稳定排序
  • 可用于链式存储结构
  • 当初始记录无序，n比较大时，此算法不宜采用。

返回顶部

快速排序（Quick Sort）

思想： 选取一个关键字作为分界点，右边的值都比它大，左边值都比它小。左右的 数据可以独立的排序。这是一个递归定义。
过程： 每一趟将数据分为两部分，左小右大，直至low==high。
实现代码：

int Partition(int a[],int low,int high){	
	int pivokey=a[low];
	while(low < high) {
		while(a[high]>=pivokey&&low < high)  high--;	//直到找到一个小的 
		a[low]=a[high];			//正是因为选取第一个元素为基准，才能这样，要不然值都被覆盖了 
		while(a[low]<=pivokey&&low < high)  low++;		//直到找到一个大的 
		a[high]=a[low]; 	
	}  

	a[low]=pivokey;
	return low;
}

void QuickSort(int r[],int low,int high){
	int pivot;
	if(low<high){
		pivot=Partition(r,low,high);
		QuickSort(r,low,pivot-1);
		QuickSort(r,pivot+1,high);
	}
}

运行结果：
在这里插入图片描述
上述代码有一点问题，就是选取第一个或者最后一个元素作为基准，这样在数组已经有序的情况下，每次划分将得到最坏的结果。
一种比较常见的优化方法是随机化算法，即随机选取一个元素作为基准。这种情况下最坏情况不再依赖于输入数据，而是由随机函数决定。实际上，随机化快速排序得到理论最坏情况的可能性仅为 1/(2n)。

改进后的快速排序：

void QuickSort(int array[],int low,int high){
	srand(unsigned(time(0)));
    int sc=rand()%(high-low)+1+low;
    cout<<"随机数"<<sc<<endl;
    swap(array[sc],array[low]);
    show(array,11);
    int par=Partition(array,low,high);
    if (par>low+1){
        QuickSort(array,low,par-1);
    }
    if (par<high-1){
        QuickSort(array,par+1,high);
    }
}

运行结果：
在这里插入图片描述
算法分析：
最好情况：
每一次分割都是长度大致相等的子表

最坏情况（有序）：
每一次分割只能得到比上一次记录少一个的子序列。

平均时间复杂度：O(nlog2n)
空间复杂度： 最好O(log2n)、最差O(n)

算法特点：

  • 是不稳定排序
  • 很难于链式存储结构
  • 当初始记录无序，n比较大时，此算法宜采用。

返回顶部

直接插入排序（Straight Insertion Sort）

思想： 与怕扑克牌一样，拿起一张牌，插入合适位置。
过程： 每一趟将一个待排序记录插入到适当位置。
实现代码：

void InsertSort(int r[],int n){//第0位置设置观察哨，第1位置为有序区，从第二个开始扫描插入 
	int i,j;
	for(i=2;i<=n;i++){
		r[0]=r[i];
		for(j=i-1;r[0]<r[j];j--){//带插入的数依次和有序区比，寻找插入位置 
			r[j+1]=r[j];

		}
		
		r[j+1]=r[0];
	}
}

运行结果：
在这里插入图片描述
红线左边的是作为观察哨用的，也就是数组中第0位置被设为观察哨。

算法分析：
最好情况（正序）：
每一趟排序，比较1次且不移动。

最坏情况（逆序）：
每一趟排序。比较i次，移动i+1次。

整个过程（需执行n-1趟）：
最好情况，比较n-1次且不移动记录。
最坏情况，每一趟比较2,3,…,n,等差数列。移动3,4,…n+1次，等差数列。
总的比较次数 KCN=(n-1)(n+2)/ 2
总的移动次数 RMN=(n+4)(n-1)/ 2

平均情况下：
比较次数： (n-1)(n+4)/4 ,约为 n2/4
移动次数： (n+4)(n-1)/4,约为 n2/4
时间复杂度：O(n2)
空间复杂度： O(1)

算法特点：

  • 是稳定排序
  • 可用于链式存储结构
  • 当初始记录无序，n比较大时，此算法不宜采用。

返回顶部

折半插入排序（Binary Insertion Sort）

与直接插入排序区别不大，直接插入排序是以顺序查找方式找插入位置，这里只是将其换为折半查找方式来找插入位置。

实现代码：

void BInsertSort(int Array[],int n)		// 折半插入排序升序排列
{
	int i,j,m;      //m充当比较区间的中点
	int low,high;     
	for (i = 2; i <= n; i++)
	{
		Array[0] = Array[i];
		low = 1; high = i-1;   
	
		while (low <= high){
			m = (low + high)/2;
			if (Array[0] > Array[m])  low = m+1;
			else  high = m-1;
		}
		/*确定好位置后，将位置之后的数据后移，插入待排序数据*/
		for (j = i-1;j > high; j--){
			Array[j+1] = Array[j];
		}
		Array[j+1] = Array[0];
	}
}

运行结果与直接插入排序一样

算法分析：
平均情况下，折半查找比顺序查找快，但移动次数不变。

时间复杂度：O(n2)
空间复杂度： O(1)

算法特点：

  • 是稳定排序
  • 不可用于链式存储结构
  • 适合初始记录无序，n比较大时。

返回顶部

希尔排序（Shell’s Sort）

思想： 通过 增量 将整个待排序列分割成几组，对每组分别进行直接插入排序。然后改变增量，重新分组，增加每组的数据量。直到所取增量为1，所有记录在同一组中进行直接插入排序。
过程： 每一趟分组排序，使得整个待排序列趋于 “基本有序”。 最后在一个组中直接插入排序的时候效率高。

实现代码：

void ShellInsertSort(int a[], int n)			//希尔排序 
{ 
    int d, i, j; //d为增量
    for(d = n/2;d >= 1;d = d/2){ //增量递减到1使完成排序  
        
		for(i = d; i < n;i++){   //插入排序的一轮       
            a[0] = a[i];
            for(j = i - d;(j >= 0) && (a[j] > a[0]);j = j-d){
                a[j + d] = a[j];
            }
        	a[j + d] = a[0];
        }
    }
}

运行结果：
在这里插入图片描述
算法分析：
增量大于1时，关键字是跳跃移动的，最后一趟只需做少量比较和移动即可完成排序。

时间复杂度：O(n1.3)
空间复杂度： O(1)

算法特点：

  • 是不稳定排序
  • 不可用于链式存储结构
  • 适合初始记录无序，n比较大时。

返回顶部

简单选择排序（Simple Selection Sort）

也叫直接选择排序

思想： 每一趟选择待排记录中关键字最小的记录。
过程： 经过n-1趟，排序完成。
实现代码：

void SelectionSort(int a[], int n) {	//直接选择排序 
    int i,j,pos;
	for(i=0;i<n-1;i++){
        for (pos=i, j=i+1; j<n; j++)
            if (a[pos]>a[j])
                pos=j;
        if (pos != i) {
            swap(a[i],a[pos]);
        }
    }
}

运行结果：
在这里插入图片描述
算法分析：
最好情况（正序）：不移动记录。
最坏情况（逆序）：移动3(n-1)次记录。

无论如何，比较次数均为： KCN=n(n-1)/ 2

时间复杂度：O(n2)
空间复杂度： O(1)

算法特点：

  • 是不稳定排序
  • 可用于链式存储结构
  • 适用于每一记录占用空间较多，移动次数较少。

返回顶部

堆排序（Heap Sort）

什么是堆：
n个元素的序列{k1，k2，…，kn}，满足：
ki>=k2i 且 ki>=k2i+1
或 ki<=k2i 且 ki<=k2i+1
称之为 堆

将待排数组记录看成是一棵完全二叉树的顺序存储结构，则堆实质上是满足如下性质的完全二叉树：

树中所有非终端结点的值均不大于（或不小于）其左右孩子结点的值

对应大根堆与小根堆。

思想： 利用大根堆（或小根堆）堆顶记录的关键字最大（或最小）这一特征，每次都选择堆的堆顶。
过程： 每拿走一个堆顶（把堆顶记录与最后一个记录交换），重新调整为堆，继续拿。

实现代码：
调整堆：

void heapAdjust(int a[], int i, int nLength) 	//调整堆
{
	/*2*i+1与2*i+2为i的孩子，是因为数组从0位置开始存。
	如果0位置不用，那就是2*i与2*i+1为i的孩子*/ 
    int child;		 
    for (; 2 * i + 1 < nLength; i = child)
    { 
        child = 2 * i + 1;
        
        if ( child < nLength-1 && a[child + 1] > a[child])	// 得到子结点中较大的结点
            ++child;
        
        if (a[i] < a[child]){		// 如果较大的子结点大于父结点,交换 
        	swap(a[i],a[child]);
        }
        else  break;
    }
}

建初堆：
在完全二叉树中，所有序号大于⌊n/2⌋ 的结点都是叶子，以这些结点为根的子树已是堆，不用调整。


void CreatHeap(int a[],int n){				//建初堆
	for (int i = n / 2 - 1; i >= 0; --i)	//length/2-1是第一个非叶节点
        heapAdjust(a, i, n);
        show(a,11); 
}

堆排序：

void HeapSort(int a[],int length)	// 堆排序
{
	cout<<"初始大根堆如下："<<endl;
    CreatHeap(a,length);			//把无序序列变成大根堆
	 
    // 从最后一个元素开始对序列进行调整
    for (int i = length - 1; i > 0; --i)
    {    
      	swap(a[i],a[0]);			// 把第一个元素和当前的最后一个元素交换，       
        heapAdjust(a, 0, i);		//不断的缩小调整的范围直到第一个元素     
		cout<<"后续调整堆如下："<<endl;
		show(a,11); 
    }
}

运行结果：
在这里插入图片描述
算法分析：

时间复杂度：O(nlog2n)
空间复杂度： O(1)

算法特点：

  • 是不稳定排序
  • 不可用于链式存储结构
  • 数据较多时较为高效。

返回顶部

归并排序（Merging Sort）

思想： 将两个或两个以上的有序表合并成一个有序表。
过程： 初始序列可看成是n个有序的子序列，每个字序列长度为1，然后两两归并，重复，直到得到长度为n的有序序列为止。

实现代码：

void Merge(int r[],int r1[],int s,int m,int t){//归并 
	int i=s,j=m+1,k=s;
	while(i<=m&&j<=t){
		if(r[i]<r[j]) r1[k++]=r[i++];
		else r1[k++]=r[j++];
	}
	while(i<=m){
		r1[k++]=r[i++];
	}
	while(j<=t){
		r1[k++]=r[j++];
	}
}

void MergeSort(int r[],int s,int t){
	int m,r1[t];
	if(s==t) return;
	else{
		m=(s+t)/2;						//分割序列
		MergeSort(r,s,m);				//递归
		MergeSort(r,m+1,t);
		Merge(r,r1,s,m,t);				//归并
		for(int i=s;i<=t;i++){			//将排好序的部分写回原数组
			r[i]=r1[i];
		}			
	}
}

运行结果：
在这里插入图片描述
算法分析：

时间复杂度：O(nlog2n)
空间复杂度： O(n)

算法特点：

  • 是稳定排序
  • 可用于链式存储结构

返回顶部

基数排序（Radix Sort）

它是和前面所述各类排序方法完全不同的一种排序方法。前面的各类排序方法都是建立在关键字比较的基础上的，而基数排序不比较关键字的大小，是一种借助于多关键字排序的思想对单关键字排序的方法。

怎么理解呢？
以扑克牌为例，扑克牌由面值和花色构成（多关键字），要对这副牌进行排序有两种策略（以花色大于面值，且红桃>黑桃>梅话>方块来说明）：

  1. 最高位优先法（MSD（Most significant digital））
    先将牌按花色分为四堆，然后每一堆按面值进行排序。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    这样，这副牌就按从小到大顺序排好了。

  2. 最低位优先法（LSD（Least significant digital））
    这是一种“分配”与“收集”交替进行的方法。
    先将牌按面值分成13堆（完整的牌），从小到大收集起来，再把花色一样的放在一起即可。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    这样，这副牌就按从小到大顺序排好了。

基数排序思想： 一个关键字可以看成是“多个关键字”组成，个位、十位、百位等，从而借助于多关键字排序对单关键字排序。
过程： 从低位到高位，将值相同的收集起来放在一个队里。再分配，再收集，最终完成排序
在这里插入图片描述
实现代码：

int getNumInPos(int num,int pos) //获得某个数字的第pos位的值
{
    int temp = 1;
    for (int i = 0; i < pos - 1; i++)
        temp *= 10;
 
    return (num / temp) % 10;
}
 
#define RADIX 10    //可能是0-9，需要10个桶 
#define KEYNUM 5     //整数位数
void RadixSort(int a[], int n)		//基数排序 
{
    int *radixArrays[RADIX];    //分别为0~9的序列空间
    for (int i = 0; i < RADIX; i++)
    {
        radixArrays[i] = new int[n];
        radixArrays[i][0] = 0;    
    }
 
    for (int pos = 1; pos <= KEYNUM; pos++)    //从个位开始
    {
        for (int i = 0; i < n; i++)    //分配过程
        {
            int num = getNumInPos(a[i], pos);
            int index = ++radixArrays[num][0];
            radixArrays[num][index] = a[i];
        }
 
        for (int i = 0, j =0; i < RADIX; i++) //写回到原数组中
        {
            for (int k = 1; k <= radixArrays[i][0]; k++)
                a[j++] = radixArrays[i][k];
            radixArrays[i][0] = 0;
        }
    }
}

运行结果：
在这里插入图片描述

算法分析：
对于n个记录，假设每个记录含d个关键字，每个关键字的取值范围为rd个值，每一趟分配的时间复杂度为 O(n) ，每一趟收集的时间复杂度为 O(rd) 。整个排序需进行d趟分配与收集。
时间复杂度：O(d(n+rd))
空间复杂度： O(n+rd)

算法特点：

  • 是稳定排序
  • 可用于链式存储结构
  • 时间复杂度能突破基于关键字比较方法的下界 O(nlog2n)。 达到 O(n)。

返回顶部

总的代码：

#include<iostream>
#include <stdlib.h>
#include <ctime>
using namespace std;

void swap(int &a,int &b){
	int temp=a;a=b;b=temp;
}

void show(int a[],int n){
	for(int i=0;i<n;i++){
		cout<<a[i]<<" ";
	}
	printf("\n");
}

void BubbleSort1(int a[],int n){//冒泡排序
	show(a,n); 
	for(int i=0;i<n-1;i++){
		for(int j=0;j<n-1-i;j++){
			if(a[j]>a[j+1]){
				swap(a[j],a[j+1]);				
			}
		}
		cout<<"第"<<i+1<<"趟比较结果："<<endl;
		show(a,n);
	}
}

void BubbleSort2(int a[],int n){//改进的冒泡排序 
	show(a,n); 
	int bound,exchange=n-1;
	int i=0;
	while(exchange!=0){
		cout<<"第"<<++i<<"趟比较结果："<<endl;
			show(a,n);
		bound=exchange;
		exchange=0;
		for(int j=0;j<bound;j++){			
			if(a[j]>a[j+1]){
				swap(a[j],a[j+1]);
				exchange=j;
			}
		}
	}
}  

void quicksort(int a[],int low,int high){//快速排序 
 
	if(low>high) return;
	int pivokey=a[low];
	int left=low;
	int right=high;
	while(left<right) {
		while(a[right]>=pivokey&&left<right)  right--;		//直到找到一个小的 
		while(a[left]<=pivokey&&left<right)  left++;		//直到找到一个大的 
		if(left<right)  swap(a[left],a[right]); 		
	}  	
	a[low]=a[left];			//正是因为选取第一个元素为基准，才能这样，要不然值都被覆盖了 
	a[left]=pivokey;
	
	quicksort(a,low,left-1);
	quicksort(a,left+1,high);
}

//int Partition(int r[],int low,int high){
//	int i=low,j=high;
//	while(i<j){
//		while(i<j&&r[i]<=r[j]) j--;			//直到找到一个小的 
//		if(i<j){
//			cout<<r[i]<<"和"<<r[j]<<"交换"<<endl;
//			swap(r[i],r[j]);
//			//i++;
//		}
//		while(i<j&&r[i]<=r[j]) i++;			//直到找到一个大的 
//		if(i<j){
//			cout<<r[i]<<"和"<<r[j]<<"交换"<<endl;
//			swap(r[i],r[j]);
//			//j--;
//		}
//		show(r,11);
//	}
//	cout<<endl<<"位置"<<i<<endl<<endl;
//	return i;
//}

int Partition(int a[],int low,int high){	
	int pivokey=a[low];
	while(low < high) {
		while(a[high]>=pivokey&&low < high)  high--;	//直到找到一个小的 
		a[low]=a[high];			//正是因为选取第一个元素为基准，才能这样，要不然值都被覆盖了 
		while(a[low]<=pivokey&&low < high)  low++;		//直到找到一个大的 
		a[high]=a[low]; 	
	
	}  
	a[low]=pivokey;
	return low;
}

//void QuickSort(int r[],int low,int high){
//	int pivot;
//	if(low<high){
//		pivot=Partition(r,low,high);
//		QuickSort(r,low,pivot-1);
//		QuickSort(r,pivot+1,high);
//	}
//}

void QuickSort(int array[],int low,int high){//随机化法改进的快速排序 
	srand(unsigned(time(0)));
    int sc=rand()%(high-low)+1+low;
    cout<<"随机数"<<sc<<endl;
    swap(array[sc],array[low]);
    int par=Partition(array,low,high);
    if (par>low+1){
        QuickSort(array,low,par-1);
    }
    if (par<high-1){
        QuickSort(array,par+1,high);
    }
}

int SelectMink(int r[],int low,int high,int k){ 
	int s= Partition(r,low,high);
	if(s==k) return r[s];
	if(s>k) return SelectMink(r,low,s-1,k);
	else return SelectMink(r,s+1,high,k);
}

void InsertSort(int r[],int n){//第0位置设置观察哨，第1位置为有序区，从第二个开始扫描插入 
	int i,j;
	for(i=2;i<=n;i++){
		r[0]=r[i];
		for(j=i-1;r[0]<r[j];j--){//带插入的数依次和有序区比，寻找插入位置 
			r[j+1]=r[j];

		}
		
		r[j+1]=r[0];
		cout<<"第"<<i-1<<"趟结果："<<endl;
		show(r,11);
	}
}

void BInsertSort(int Array[],int n)		//第0位置设置观察哨，折半插入排序升序排列
{
	int i,j,m;      //m充当比较区间的中点
	int low,high;     
	for (i = 2; i <= n; i++)
	{
		Array[0] = Array[i];
		low = 1; high = i-1;   
	
		while (low <= high){
			m = (low + high)/2;
			if (Array[0] > Array[m])  low = m+1;
			else  high = m-1;
		}
		/*确定好位置后，将位置之后的数据后移，插入待排序数据*/
		for (j = i-1;j > high; j--){
			Array[j+1] = Array[j];
		}
		Array[j+1] = Array[0];
		cout<<"第"<<i-1<<"趟结果："<<endl;
		show(Array,11);
	}
}

void ShellInsertSort(int a[], int n)			//希尔排序 
{ 
    int d, i, j; //d为增量
    for(d = n/2;d >= 1;d = d/2){ //增量递减到1使完成排序  
        
		for(i = d; i < n;i++){   //插入排序的一轮       
            a[0] = a[i];
            for(j = i - d;(j >= 0) && (a[j] > a[0]);j = j-d){
                a[j + d] = a[j];
            }
        	a[j + d] = a[0];
        }
    }
}

void SelectionSort(int a[], int n) {	//直接选择排序 
    int i,j,pos;
	for(i=0;i<n-1;i++){
        for (pos=i, j=i+1; j<n; j++)
            if (a[pos]>a[j])
                pos=j;
        if (pos != i) {
            swap(a[i],a[pos]);
        }
        cout<<"第"<<i+1<<"趟结果："<<endl;
		show(a,n);
    }
}

void heapAdjust(int a[], int i, int nLength)
{
	/*2*i+1与2*i+2为i的孩子，是因为数组从0位置开始存。
	如果0位置不用，那就是2*i与2*i+1为i的孩子*/ 
    int child;		 
    for (; 2 * i + 1 < nLength; i = child)
    { 
        child = 2 * i + 1;
        
        if ( child < nLength-1 && a[child + 1] > a[child])	// 得到子结点中较大的结点
            ++child;
        
        if (a[i] < a[child]){		// 如果较大的子结点大于父结点,交换 
        	swap(a[i],a[child]);
        }
        else  break;
    }
}

void CreatHeap(int a[],int n){
	for (int i = n / 2 - 1; i >= 0; --i)	//length/2-1是第一个非叶节点
        heapAdjust(a, i, n);
        show(a,11); 
}

void HeapSort(int a[],int length)	// 堆排序
{
	cout<<"初始大根堆如下："<<endl;
    CreatHeap(a,length);			//把无序序列变成大根堆
	 
    // 从最后一个元素开始对序列进行调整
    for (int i = length - 1; i > 0; --i)
    {    
      	swap(a[i],a[0]);			// 把第一个元素和当前的最后一个元素交换，       
        heapAdjust(a, 0, i);		//不断的缩小调整的范围直到第一个元素     
		cout<<"后续调整堆如下："<<endl;
		show(a,11); 
    }
}

void Merge(int r[],int r1[],int s,int m,int t){//归并 
	int i=s,j=m+1,k=s;
	while(i<=m&&j<=t){
		if(r[i]<r[j]) r1[k++]=r[i++];
		else r1[k++]=r[j++];
	}
	while(i<=m){
		r1[k++]=r[i++];
	}
	while(j<=t){
		r1[k++]=r[j++];
	}
}

void MergeSort(int r[],int s,int t){
	int m,r1[t];
	if(s==t) return;
	else{
		m=(s+t)/2;
		MergeSort(r,s,m);
		MergeSort(r,m+1,t);
		Merge(r,r1,s,m,t);
		cout<<s<<"->"<<t<<"位置已排好序"<<endl;
		for(int i=s;i<=t;i++){
			r[i]=r1[i];
		}
		show(r,11);			
	}
}

int getNumInPos(int num,int pos) //获得某个数字的第pos位的值
{
    int temp = 1;
    for (int i = 0; i < pos - 1; i++)
        temp *= 10;
 
    return (num / temp) % 10;
}
 
#define RADIX 10    //可能是0-9，需要10个桶 
#define KEYNUM 5     //整数位数
void RadixSort(int a[], int n)		//基数排序 
{
    int *radixArrays[RADIX];    //分别为0~9的序列空间
    for (int i = 0; i < RADIX; i++)
    {
        radixArrays[i] = new int[n];
        radixArrays[i][0] = 0;    
    }
 
    for (int pos = 1; pos <= KEYNUM; pos++)    //从个位开始
    {
        for (int i = 0; i < n; i++)    //分配过程
        {
            int num = getNumInPos(a[i], pos);
            int index = ++radixArrays[num][0];
            radixArrays[num][index] = a[i];
        }
 
        for (int i = 0, j =0; i < RADIX; i++) //写回到原数组中
        {
            for (int k = 1; k <= radixArrays[i][0]; k++)
                a[j++] = radixArrays[i][k];
            radixArrays[i][0] = 0;
        }
    }
}


int main(){
  	int n=11;
    int a[n]={5,3,8,1,4,6,9,2,7,10,11};
//    srand(unsigned(time(0)));
//    for (int i = 0; i <n ; i++) {
//        a[i] = rand()%100+1;
//    }

//	cout<<"直接插入排序:"<<endl;
//	show(a,n);
//	InsertSort(a,n-1); 
//	show(a,n);

//	cout<<"折半插入排序:"<<endl;
//	show(a,n);
//	BInsertSort(a,n-1); 
//	show(a,n);

//	cout<<"希尔排序:"<<endl;
//	show(a,n);
//	ShellInsertSort(a,n-1); 
//	show(a,n);

//	cout<<"快速排序:"<<endl;
//	show(a,n);
//    QuickSort(a,0,n-1);
//	quicksort(a,0,n-1);
//	show(a,n);

//	cout<<endl<<"冒泡排序:"<<endl;
//	BubbleSort1(a,n);
//	show(a,n);
//	
//	cout<<endl<<"改进的冒泡排序:"<<endl;
//	BubbleSort2(a,n);
//	show(a,n);
	
//	cout<<endl<<"直接选择排序:"<<endl;
//	show(a,n);
//	SelectionSort(a,n);
//	show(a,n);
	
//	cout<<"堆排序:"<<endl;
//	show(a,n);
//	HeapSort(a,n);
//	show(a,n);

//    cout<<endl<<"归并排序:"<<endl;
//    show(a,n);
//    MergeSort(a,0,n-1);
//   	show(a,n);
   	
//   	cout<<endl<<"基数排序:"<<endl;
//    show(a,n);
//    RadixSort(a,n);
//   	show(a,n);
   	
    int choose;
    show(a,n);
    cout<<"请输入要查询第几小的数:"<<endl; 
    cin>>choose; 
    printf("第%d小的数是：%d\n",choose,SelectMink(a,0,n,choose));
	
	return 0;
}

返回顶部

songsongL
关注
专栏目录
归并排序和快速排序比较【算法设计与分析实验报告】
free斩
03-21 5577
下面的源代码是修改的了时间差精确到了纳秒级别的了，但是还是感觉很有误差。无论怎么测，总是快排比归并快，即使是测试数据的数组长度在10以内。         前面一样的程序写的是时间精确到微秒级的，数组长度大概在一万以内的，就是归并排序快了，大于这个长度的快速排序比较快。综合上面的情况，数组小时，二者时间差也不会太多，所以个人认为还是快速排序比较好了，唉还是觉得归并比较简单好写，弱爆了啊。。。
快速排序
旭哥的专栏
07-30 278
同冒泡排序一样，快速排序也属于交换排序，通过元素之间的比较和交换位置来达到排序的目的。 不同的是，冒泡排序在每一轮只把一个元素冒泡到数列的一端，而快速排序在每一轮挑选一个基准元素，并让其他比它大的元素移动到数列一边，比它小的元素移动到数列的另一边，从而把数列拆解成了两个部分。 这种思路就叫做分治法。 假如给定8个元素的数列，一般情况下冒泡排序需要比较8轮，每轮把一个元素移动到数列一端，时间复杂度是O（n^2）。 而快速排序的流程是什么样子呢？ 如图所示，在分治法的思想下，原数列在每一轮被拆分成两部分，每
Chapter 7 排序（Sort）
小哥哥的博客
03-04 847
文章目录1. 排序的概念及其算法性能1.1 概念1.2 排序算法的性能评估1.3 排序表的类定义2. 插入排序2.1 直接插入排序2.1.1 实现代码2.1.2 性能评估2.2 二分法插入排序2.2.1 实现代码2.2.2 性能评估2.3 希尔排序2.3.1 实现代码2.3.2 性能评估 1. 排序的概念及其算法性能 1.1 概念 数据表（dataList） 它是待排序元素的有限集合 排序码（k...
数据结构之排序2 ---（归并排序，堆排序，快速排序）
比卡丘不皮的博客
09-03 863
数据结构之排序 目录 归并排序： 堆排序： 快速排序： 归并排序： 归并排序采用分治法，将元素递归分成若干组，排好序后再逐级合并（Merge过程最坏情况下的比较次数为2n-1） 归并排序最好、最坏、平均复杂度都一样，比较占用空间，但却是稳定高效的排序算法，仅次于QuickSort 时间复杂度：O(nlgn) 空间复杂度：O(n) stable：是 void merge(int *array, int first, int center, int end) { int n1 = c..
c语言快速排序法的平均寻找次数,C语言：快速排序
weixin_42441929的博客
05-18 451
快速排序是排序算法中，平均时间复杂度为O(n*log n)的一种算法，其实现需要先解决这样的一个问题，对一个序列A[1]，A[2],A[3] .......A[N]，调整序列中元素的位置，使得A[1](原序列中的第一个元素，下同)的左侧所有元素都不超过A[1]，右侧所有元素都大于A[1],例如对序列{5,3,9,6,4,1}来说，调整后变为{3,1,4,5,9,6}这样就让A[1] =5 ，左侧的...
【排序算法】归并排序与快速排序：深入解析与比较
最新发布
Ricky的博客
01-03 3769
无论是在数据库操作中的数据检索，还是在高效算法的设计中，良好的排序机制都能显著提升性能和效率。合并时，从两个数组的起始位置开始比较，选择两者中较小的元素放入结果数组中，然后移动指针，重复此过程，直到所有元素都被合并。分区策略: 快速排序通过选择一个基准元素，然后重新排列数组，使得所有小于基准的元素都移到基准的左边，所有大于基准的元素都移到基准的右边。基准元素的选择: 基准的选择可以多样化，常见的方法包括选择第一个元素、最后一个元素、中间元素，或者随机选择一个元素作为基准。归并排序是一种稳定的排序算法。
java各种排序算法总结
11-18
排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。在各个领域中考虑到数据的各种限制和规范，要得到一个符合实际...
js的各种排序算法实现(总结)
10-21
排序算法是编程中的基本概念，用于对数组或集合中的元素进行有序排列。在JavaScript中，我们可以实现多种经典的排序算法。下面将对一些常见的排序算法在JavaScript中的实现进行详细说明。 1. **内置排序函数**： ...
数据结构课程设计 比较几种内部排序算法的关键字比较次数和移动次数以取得直观感受
06-18
设计一个测试程序比较几种内部排序算法的关键字比较次数和移动次数以取得直观感受
排序之归并排序和快速排序
LearningMegan
04-02 10000
1. 归并排序归 快速排序 归并排序和快速排序的区别
归并排序和快速排序比较
热门推荐
Jymn_Chen
12-30 3万+
最近在做一个算法实验：归并排序和快速排序的比较。 这两种算法在排序方面是非常非常的通俗的了，权威的文献和网上的相关文章也是一大堆，在这里就简单贴下代码，写下个人从这个实验中学到的东西。 先说说个人对这两个算法的理解： 归并排序，简单来说就是先将数组不断细分成最小的单位，然后每个单位分别排序，排序完毕后合并，重复以上过程最后就可以得到排序结果。 快速排序，简单来说就是先选定一个基准元素，然后
快速排序和归并排序比较
Java海洋
11-29 2845
分治法 有很多算法在结构上是递归的：为了解决一个给定的问题，算法要一次或多次地递归调用其自身来解决相关的子问题。这些算法通常采用分治策略（divide-and-conquier）：将原问题划分成n个规模较小而结构与原问题相似的子问题；递归地解决这些子问题，然后再合并其结果，就得到原问题的解。分治模式在每一层递归上都有三个步骤： ²         分解（divide）：将原问题分解成一系列子问
排序算法性能分析
don_lvsml的专栏
02-17 850
一、基于比较的排序算法 1.插入排序法 直接插入排序，希尔排序，不常用的：Tree sort；Library sort：Patience sorting 2.交换排序 冒泡排序，快速排序，计数排序 3.选择排序 直接选择排序，堆排序 4.归并排序 归并排序 二、不基于比较的排序算法 基数排序，桶排序 三、空间，时间复杂度，稳定性
算法-排序（3）基础排序算法比较
04-16 891
排序的时间开销可用算法执行中的数据比较次数和数据移动次数来衡量。 不稳定的排序方法往往是按照一定的间隔移动或交换记录对象的位置，从而可能导致具有相等排序码的不同对象的前后相对位置在排序前后颠倒过来。 稳定的排序方法往往在相邻的数据对象间比较排序码，如果发生逆序才交换，具有相等排序码的不同对象在排序前后不会颠倒。 一、起泡排序算法 1.基础起泡排序算法 n-1次起泡，第i次起泡从...
快速排序(附Java实现和分析)
xiaoguobaf的博客
04-07 5627
总结一下快速排序，如有错误或者不足，欢迎交流讨论。 1、快速排序的思路快速排序和归并排序的思路很相似，都是采取的分治思想。快速排序通过选择一个元素，该元素称为枢轴元素或切分元素，然后将它放到一个合适的位置上，使得它前面的元素不大于它，它后面的元素不小于它，然后将枢轴元素为分界点，两边的数组也采取类似的方法，即选取枢轴元素，使得前面的元素不大于它，后面的不小于它，重复进行下去，直到数组里面只有一个元
利用ArrayList对map进行按key（键）和按value (值) 排序
qq_41487251的博客
09-08 4691
利用ArrayList对map进行按key(键)和按value (值) 排序 总感觉按照值得应该比较少，意义好像也不大，感觉还没有真正懂。 使用比较器 按key（键）排序 通过ArrayList将map.entrySet()，变成list 然后在类外写具体如何比较大小的方法compare()，最后调用 Collections.sort(list, new Comparator<Map.Entry<String, String>>() import java.util.*; pub
C语言实现的各种排序算法总结与稳定性分析
本文档主要涵盖了排序算法在C语言中的实现以及它们的时间复杂度分析，重点介绍了两类排序方法：稳定排序和不稳定排序。以下是各排序算法的关键知识点： 1. **稳定排序** - **冒泡排序** (Bubble Sort)：这是一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值