数据结构--排序（下） 快排、桶排、基数排序、各种排序比较

最新推荐文章于 2023-08-08 10:59:14 发布
最新推荐文章于 2023-08-08 10:59:14 发布
阅读量679 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： 算法 排序算法 快速排序 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20225851/article/details/104213263
版权

快速排序 O（nlogn）

快排和归并排序都是采用分治的思想，快排的方法是先从一个序列中选一个主元出来，然后把序列根据主元分成左右两部分，左边比主元小，又边比主元大， 分出来的两部分在分别递归用同样的方法处理。
第一步：选主元
采取取 头 中 尾 的中位数作为主元，最后把主元放到倒数第二的位置，也就是n-1的位置。

ElementType Median3(ElementType A[] , int left , int right )
{
	int center = (right+left)/ 2 ;
	if (A[left] > A[center])
		Swap(A[left],A[center]);
	if (A[left] > A[right])
		Swap(A[left],A[right]);
	if (A[center] > A[right])
		Swap(A[center] , A[right]);
	Swap(A[center] , A[right-1]);
	return A[right-1];
 }

第二步：子集划分 （关键步骤）
由于第一个元素一定比主元小，最后一个元素一定比主元大，所以只需要讲left+1 — right-2 的元素进行分类就好啦，比主元小的放左边，比主元大 的放右边。
具体实现方法：
假设选取的主元是6，设i ，j两个指针
在这里插入图片描述
当A[i] <6时，说明位置是对的，i往右边移动，当遇到a[i]>=6时，i停止移动，向左移动j，寻找一个A[j] <6的数与之交换。
在这里插入图片描述
上面的图可以看到，8是大于6的，因此i保持不动，移动j，当j移动到2的位置发现2<6,也停止移动，这时候i ，j 位置上的两个元素交换位置。

在这里插入图片描述
然后继续上面的步骤，先移动i再移动j。
直到i<j时停止移动。
在这里插入图片描述
最后把i位置和主元位置的6互换
在这里插入图片描述
这时候就可看到主元左边的元素都比主元小，右边的元素都比主元大！！接下来就继续把划分的两个部分进行同样的方法处理。


 		int mid = Median3(A,left, right);
 		int i = left ,j = right-1 ; 
 		while (true)
 		{
 			while (A[--left] <mid) ; //第一次从left-1开始判断 当遇到比mid大的数停止移动
			while(A[--right] > mid); // 第一次从right-2 开始判断，当遇到比mid小的数停止移动 
			if(i<j) Swap(A[i],A[j]); // 当i<j时停止 
			else break ;  
		}
		Swap(A[i],A[right-1]); //主元位置在right-1 与i 位置的元素互换
		Quicksort(A,left,i-1);
		Quicksort(A,i+1,Right);

第三步：分类
由于快排是利用递归进行的，需要一直调用栈空间，如果数据较小的话效率反而会更低，所以当数据量小于一定数值时直接进行插入排序，反而会提高效率，我网上查了一些博客，最后个人选择10最为分解点，当数据小于10时，直接用插入排序！

ElementType Median3(ElementType A[] , int left , int right )
{
	int center = (right+left)/ 2 ;
	if (A[left] > A[center])
		Swap(A[left],A[center]);
	if (A[left] > A[right])
		Swap(A[left],A[right]);
	if (A[center] > A[right])
		Swap(A[center] , A[right]);
	Swap(A[center] , A[right-1]);
	return A[right-1];
 }  
 
 void Quicksort(ElementType A[] , int left , int right)
 {
 	if (10 <=right-left)
 	{
 		int mid = Median3(A,left, right);
 		int i = left ,j = right-1 ; 
 		while (true) 
 		{
 			while (A[++i] <mid) ; //第一次从left-1开始判断 当遇到比mid大的数停止移动
			while(A[--j] > mid); // 第一次从right-2 开始判断，当遇到比mid小的数停止移动 
			if(i<j) Swap(A[i],A[j]); // 当i<j时停止 
			else break ;  
		}
		Swap(A[i],A[right-1]); //主元位置在right-1 与i 位置的元素互换
		Quicksort(A,left,i-1);
		Quicksort(A,i+1,right);  
	}
	else 
	{
		Insertion_Sort(A+left,right-left +1);
	}
 }
 
 void Quick_Sort(ElementType A[], int n )
 {
 	Quicksort(A, 0,n-1);
 }

表排序

表排序是指对一些结构进行排序时，由于结构本身数据较大，排序时移动效率低，所以需要建一个数组table，每个位置先保存对应结构下标序号，然后对这个数组排序时，利用下标位置去访问对应的结构中的数据，从而只需对table中的序号进行排序，最后按着序号依次访问对应的结构，就是有序的访问次序了。

在这里插入图片描述
这里的table就是保存待排序结构的下标，当对table进行排序时，只需要访问A[table[i]]中的内容进行比较然后对table中的序号进行修改即可。

在这里插入图片描述
排序完的结构如图， 3 5 2 1 7 0 4 6 位置对应结果中的字母是abcdefg，完成了排序的目的。实例结合下面的桶排序给出。

桶排序 O(m+n)

如果数据范围较小，可以用桶排序来实现几乎线性的排序。
例：比如将一个班的高数成绩进行排序，因为成绩只有【0，100】的范围，我们可以开一个大小为101的表a，存放学生的数据，比如有一个人考了50分，就在a[50]中放入这个人的信息，最后只需要从0-100的顺序对a进行访问及排序好的顺序了。
如果利用上面表排序的方法，我只需要在a中存放对应学生数据的下标即可。
输入：
5
小林 100
小红 60
小张 45
小李 60
小月 50

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

struct student{
	string name ;
	int score ;
	student(string s , int n):name(s),score(n){}
};

int main ()
{
	int n ;
	cin >> n ;
	vector <student> v ;
	for (int i=0;i<n;i++)
	{
		string name ;
		int score ;
		cin >> name >> score ;
		v.push_back(student(name,score));
	}
	vector <int> a[101];//表
	for (int i=0;i<n;i++) 
	{
		a[v[i].score].push_back(i); //将scaore成绩的学生的下标放到表a[score] 中 
	}
	for (int i=0;i<=100 ;i++)
	{
		if (!a[i].empty())
		{
			for (int j=0;j<a[i].size();j++)
			{
				int item = a[i][j] ;
				cout << v[item].name<<" "<<v[item].score <<endl;
			}
		}
	 } 
	
 }

在这里插入图片描述
这个是我自己编的数据，由于数据少，数据的范围较大，所以效率不是很高，下面我写一个对100000个数据排序的桶排序。算法复杂度是O（n+m）， n是指数据量，m是数据范围，如果m足够下，这个算法可以接近线性的速度。(通过是输出rand随机生成的100000个数据的查看，发现数据范围在[0,32767]应此m就是32768）
在这里插入图片描述
void Bucket_Sort (ElementType A[] , int n)
{
int a[32768];
memset(a,0,sizeof (a));
for (int i=0;i<n;i++)
{
a[A[i]] +=1;
}
int flag = 0 ;
for (int i=0;i<32768;i++)
{
while (a[i]>0)
{
A[flag ++] = i ;
a[i] – ;
}
}
}
在这里插入图片描述
如果不要复制结果的话时间可以再快一倍。
100000个数据比快排快了10倍！！！！所以如果知道数据范围且待排数据量远远大于数据范围的话，选择桶排序无疑是最好的选择，但是会浪费一定的空间。

基数排序

如果上面的m>>n时， 桶排序是不合算的，这样就要用基数排序一样是线性的时间。但是基数排序还是基于桶排序来实现的。
基数排序有次位优先和主位优先两种，这里以次位优先为例：

假设要排序最大三位数的一串数字，那么就要分别对个位十位百位进行三次桶排序，我们通过一个示例来说明方法。

输入序列： 64 ，8，216，512，27，729，0，1，343，125
设这么一个桶来进行排序
在这里插入图片描述
第一次对个位进行排序：
在这里插入图片描述
第二次对十位排序：
在这里插入图片描述
第三次对百位排序：
在这里插入图片描述
通过这三次排序就可以发现最后一次排序后已经变成有序了。
这里我们用队列去实现五位数的基数排序。

void Cardinal_Sort(ElementType A[], int n)
{
	queue<int> a[5][10]; // 桶 
	for (int i=0;i<n;i++) //个位 
	{
		a[0][A[i]%10].push(A[i]);	
	} 
	int number = 10 ,item ,i  ;
	for ( i=1;i<5;i++) // 十位 百位 千位 万位 
	{
		for (int j=0;j<=9;j++)
		{
			while (!a[i-1][j].empty()) // 从前一位i-1获取数据 
			{
				item = a[i-1][j].front() ;  a[i-1][j].pop();
				a[i][item/number%10].push(item); 
			}
		} 
		number *=10 ;//进一位比较 
	}
	number = 0 ;
	for (int j=0;j<=9;j++) //复制排序结果到A
	{
		while (!a[i-1][j].empty())
		{
			item = a[i-1][j].front() ;  a[i-1][j].pop();
			A[number++] = item ; 
		} 
	} 
 }

这是我自己写的桶排序，效率和mooc上给的代码查不多。
在这里插入图片描述
下面给出mooc的代码：

 #define MaxDigit 5
#define Radix 10
 
/* 桶元素结点 */
typedef struct Node *PtrToNode;
struct Node {
    int key;
    PtrToNode next;
};
 
/* 桶头结点 */
struct HeadNode {
    PtrToNode head, tail;
};
typedef struct HeadNode Bucket[Radix];
  
int GetDigit ( int X, int D )
{ /* 默认次位D=1, 主位D<=MaxDigit */
    int d, i;
     
    for (i=1; i<=D; i++) {
        d = X % Radix;
        X /= Radix;
    }
    return d;
}
 
void LSDRadixSort( ElementType A[], int N )
{ /* 基数排序 - 次位优先 */
     int D, Di, i;
     Bucket B;
     PtrToNode tmp, p, List = NULL; 
      
     for (i=0; i<Radix; i++) /* 初始化每个桶为空链表 */
         B[i].head = B[i].tail = NULL;
     for (i=0; i<N; i++) { /* 将原始序列逆序存入初始链表List */
         tmp = (PtrToNode)malloc(sizeof(struct Node));
         tmp->key = A[i];
         tmp->next = List;
         List = tmp;
     }
     /* 下面开始排序 */ 
     for (D=1; D<=MaxDigit; D++) { /* 对数据的每一位循环处理 */
         /* 下面是分配的过程 */
         p = List;
         while (p) {
             Di = GetDigit(p->key, D); /* 获得当前元素的当前位数字 */
             /* 从List中摘除 */
             tmp = p; p = p->next;
             /* 插入B[Di]号桶尾 */
             tmp->next = NULL;
             if (B[Di].head == NULL)
                 B[Di].head = B[Di].tail = tmp;
             else {
                 B[Di].tail->next = tmp;
                 B[Di].tail = tmp;
             }
         }
         /* 下面是收集的过程 */
         List = NULL; 
         for (Di=Radix-1; Di>=0; Di--) { /* 将每个桶的元素顺序收集入List */
             if (B[Di].head) { /* 如果桶不为空 */
                 /* 整桶插入List表头 */
                 B[Di].tail->next = List;
                 List = B[Di].head;
                 B[Di].head = B[Di].tail = NULL; /* 清空桶 */
             }
         }
     }
     /* 将List倒入A[]并释放空间 */
     for (i=0; i<N; i++) {
        tmp = List;
        List = List->next;
        A[i] = tmp->key;
        free(tmp);
     } 
}

因为没有使用现成的队列，所以代码量比较大，可以自己选择实现方式，重要的是掌握排序的方法！！！！

排序算法的比较

在这里插入图片描述
现在真正自己写排序其实很少啦，学习排序主要是学习排序的方法，算法效率提高的技巧，以及对之前数据结构的掌握。而且没有绝对好的排序算法，没种算法都有自己的局限性，要么需要额外，要么不稳定。

最后给出这上面排序的所有对比代码：

#include <iostream>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <queue>
#define ElementType int 
#define Max 100000
using namespace std ;

void Swap(int &a, int &b)
{
	int item = a ;
	a= b ;
	b =item ;
}

**************************冒泡*************************************  
void Bubble_Sort(ElementType A[] , int n)
{
	for (int i=n-1;i>=0;i--)
	{
		int flag = 0 ;
		for (int j=0;j<i;j++)
		{
			
			if (A[j]>A[j+1])
			{
				Swap(A[j],A[j+1]);
				flag = 1;  //记录是否发生交换 
			}
		}
		if (flag==0) break ; //未发生交换说明有序，结束排序 
	}
}

**************************插排*************************************  
void Insertion_Sort(ElementType A[] , int n)
{
	int p , i;
	for (i=1;i< n;i++)
	{
		int item = A[i];
		for ( p = i ; p>0 && A[p-1]>item ;p--)
			A[p] = A[p-1];
		A[p]  =  item ;
	}
}

//输出排序结果 
void print(ElementType A[] , int n)
{
	cout <<"排序结果：";
	for (int i=0;i<n;i++)
	cout << A[i]<<" ";
}

**************************希尔排序*************************************  
void Shell_sort(ElementType A[], int n)
{
	int Sedgewick[] = {0,1, 5 ,19, 41, 109, 209, 505, 929, 2161, 3905 ,8929, 16001, 36289, 64769, 146305, 260609 ,587521, 1045505, 2354689 ,4188161 }	;
	int si ,d,i,j,tmp;
	for (si = 0 ;Sedgewick[si]<=n;si++ );
	for ( d = Sedgewick[si] ; d>0 ; d=Sedgewick[--si] )
	{
		for ( i= d ; i<n ;i++)
		{
			tmp =  A[i];
			for ( j=i ;j>=d && A[j-d] >tmp;j-=d )
				A[j] = A[j-d];
			A[j] = tmp;
		}
	}
}

//**************************堆排*************************************  
void PercDown( ElementType A[], int p, int N )
{ /* 改编代码4.24的PercDown( MaxHeap H, int p )    */
  /* 将N个元素的数组中以A[p]为根的子堆调整为最大堆 */
    int Parent, Child;
    ElementType X;
    X = A[p]; /* 取出根结点存放的值 */
    for( Parent=p; (Parent*2+1)<N; Parent=Child ) {
        Child = Parent * 2 + 1;
        if( (Child!=N-1) && (A[Child]<A[Child+1]) )
            Child++;  /* Child指向左右子结点的较大者 */
        if( X >= A[Child] ) break; /* 找到了合适位置 */
        else  /* 下滤X */
            A[Parent] = A[Child];
    }
    A[Parent] = X;
}
 
void HeapSort( ElementType A[], int N ) 
{ /* 堆排序 */
     int i;
       
     for ( i=N/2-1; i>=0; i-- )/* 建立最大堆 */
         PercDown( A, i, N );
      
     for ( i=N-1; i>0; i-- ) {
         /* 删除最大堆顶 */
         Swap( A[0],A[i] ); /* 见代码7.1 */
         PercDown( A, 0, i );
     }
}

//**************************归并*************************************  
void merge(ElementType A[] , ElementType B[],int L, int R ,int RightEnd)
{
	int LeftEnd = R-1 ;
	int flag  = L ;//初始位置
	int first = L ;
	int last = RightEnd; 
	while (L<=LeftEnd && R<= RightEnd)
	{
		if (A[L] > A[R])
			B[flag++] = A[R++];
		else 
			B[flag++] = A[L++];
	}
	while (L<=LeftEnd) B[flag ++] = A[L++];
	while (R<=RightEnd) B[flag++] = A[R++];
	
	for (int i = first ; i<=last ;i++)
		A[i] = B[i];
}

void Msort(ElementType A[], ElementType B[] ,int first ,int last)
{
	if (first < last)
	{
		int center = (first +last) / 2;
		Msort(A, B , first ,center);
		Msort(A,B,center+1 , last);
		merge(A,B,first,center+1 , last);
	}
	
}
void Merge_sort(ElementType A[], int n)
{
	ElementType *B ;
	B = (ElementType *)malloc(sizeof(ElementType)*n);
	Msort (A,B,0,n-1);
	free (B);
}

//**************************快排************************************* 
ElementType Median3(ElementType A[] , int left , int right )
{
	int center = (right+left)/ 2 ;
	if (A[left] > A[center])
		Swap(A[left],A[center]);
	if (A[left] > A[right])
		Swap(A[left],A[right]);
	if (A[center] > A[right])
		Swap(A[center] , A[right]);
	Swap(A[center] , A[right-1]);
	return A[right-1];
 }  
 
 void Quicksort(ElementType A[] , int left , int right)
 {
 	if (10 <=right-left)
 	{
 		int mid = Median3(A,left, right);
 		int i = left ,j = right-1 ; 
 		while (true) 
 		{
 			while (A[++i] <mid) ; //第一次从left-1开始判断 当遇到比mid大的数停止移动
			while(A[--j] > mid); // 第一次从right-2 开始判断，当遇到比mid小的数停止移动 
			if(i<j) Swap(A[i],A[j]); // 当i<j时停止 
			else break ;  
		}
		Swap(A[i],A[right-1]); //主元位置在right-1 与i 位置的元素互换
		Quicksort(A,left,i-1);
		Quicksort(A,i+1,right);  
	}
	else 
	{
		Insertion_Sort(A+left,right-left +1);
	}
 }
 
 void Quick_Sort(ElementType A[], int n )
 {
 	Quicksort(A, 0,n-1);
 }
 
 **************************桶排*************************************  
 void Bucket_Sort (ElementType A[] , int n)
 {
 	int a[32768];
	memset(a,0,sizeof (a));
	for (int i=0;i<n;i++)
	{
		a[A[i]] +=1;	
	}	
	int flag = 0 ;
	for (int i=0;i<32768;i++)
 	{
		while (a[i]>0)
		{
			A[flag ++] = i ;
			a[i] -- ;
		}
		
	}
 } 

//**************************队列实现基数排序*************************************
void Cardinal_Sort(ElementType A[], int n)
{
	queue<int> a[5][10]; // 桶 
	for (int i=0;i<n;i++) //个位 
	{
		a[0][A[i]%10].push(A[i]);	
	} 
	int number = 10 ,item ,i  ;
	for ( i=1;i<5;i++) // 十位 百位 千位 万位 
	{
		for (int j=0;j<=9;j++)
		{
			while (!a[i-1][j].empty()) // 从前一位i-1获取数据 
			{
				item = a[i-1][j].front() ;  a[i-1][j].pop();
				a[i][item/number%10].push(item); 
			}
		} 
		number *=10 ;//进一位比较 
	}
	number = 0 ;
	for (int j=0;j<=9;j++) //复制排序结果到A
	{
		while (!a[i-1][j].empty())
		{
			item = a[i-1][j].front() ;  a[i-1][j].pop();
			A[number++] = item ; 
		} 
	} 
 } 
**************************mooc给出的基数排序************************************* 
 #define MaxDigit 5
#define Radix 10
 
/* 桶元素结点 */
typedef struct Node *PtrToNode;
struct Node {
    int key;
    PtrToNode next;
};
 
/* 桶头结点 */
struct HeadNode {
    PtrToNode head, tail;
};
typedef struct HeadNode Bucket[Radix];
  
int GetDigit ( int X, int D )
{ /* 默认次位D=1, 主位D<=MaxDigit */
    int d, i;
     
    for (i=1; i<=D; i++) {
        d = X % Radix;
        X /= Radix;
    }
    return d;
}
 
void LSDRadixSort( ElementType A[], int N )
{ /* 基数排序 - 次位优先 */
     int D, Di, i;
     Bucket B;
     PtrToNode tmp, p, List = NULL; 
      
     for (i=0; i<Radix; i++) /* 初始化每个桶为空链表 */
         B[i].head = B[i].tail = NULL;
     for (i=0; i<N; i++) { /* 将原始序列逆序存入初始链表List */
         tmp = (PtrToNode)malloc(sizeof(struct Node));
         tmp->key = A[i];
         tmp->next = List;
         List = tmp;
     }
     /* 下面开始排序 */ 
     for (D=1; D<=MaxDigit; D++) { /* 对数据的每一位循环处理 */
         /* 下面是分配的过程 */
         p = List;
         while (p) {
             Di = GetDigit(p->key, D); /* 获得当前元素的当前位数字 */
             /* 从List中摘除 */
             tmp = p; p = p->next;
             /* 插入B[Di]号桶尾 */
             tmp->next = NULL;
             if (B[Di].head == NULL)
                 B[Di].head = B[Di].tail = tmp;
             else {
                 B[Di].tail->next = tmp;
                 B[Di].tail = tmp;
             }
         }
         /* 下面是收集的过程 */
         List = NULL; 
         for (Di=Radix-1; Di>=0; Di--) { /* 将每个桶的元素顺序收集入List */
             if (B[Di].head) { /* 如果桶不为空 */
                 /* 整桶插入List表头 */
                 B[Di].tail->next = List;
                 List = B[Di].head;
                 B[Di].head = B[Di].tail = NULL; /* 清空桶 */
             }
         }
     }
     /* 将List倒入A[]并释放空间 */
     for (i=0; i<N; i++) {
        tmp = List;
        List = List->next;
        A[i] = tmp->key;
        free(tmp);
     } 
}
 


int main ()
{
	
	clock_t start ,stop ;
	double T ;
	int A[Max] ,B[Max];
	for (int i=0 ; i< Max; i++)
		A[i] = rand();
		
	for (int i=0 ; i< Max; i++)
	B[i] = A[i];
	start = clock ();
	Bubble_Sort(B , Max);
	stop = clock();
	T = (double)(stop-start)/CLOCKS_PER_SEC;
	cout <<"冒泡排序用时："<<T<<"s"<<endl;

	for (int i=0 ; i< Max; i++)
		B[i] = A[i];
	start = clock ();
	Insertion_Sort(B , Max);
	stop = clock();
	T = (double)(stop-start)/CLOCKS_PER_SEC;
	cout <<"插入排序用时："<<T<<"s"<<endl;

	for (int i=0 ; i< Max; i++)
		B[i] = A[i];
	start = clock ();
	Shell_sort(B , Max);
	stop = clock();
	T = (double)(stop-start)/CLOCKS_PER_SEC;
	cout <<"希尔排序用时："<<T<<"s"<<endl;
	
	for (int i=0 ; i< Max; i++)
		B[i] = A[i];
	start = clock ();
    HeapSort(B , Max);
	stop = clock();
	T = (double)(stop-start)/CLOCKS_PER_SEC;
	cout <<"堆排序用时："<<T<<"s"<<endl;
	
	for (int i=0 ; i< Max; i++)
		B[i] = A[i];
	start = clock ();
	Merge_sort(B , Max);
	stop = clock();
	T = (double)(stop-start)/CLOCKS_PER_SEC;
	cout <<"归并排序用时："<<T<<"s"<<endl;
	
	for (int i=0 ; i< Max; i++)
		B[i] = A[i];
	start = clock ();
	Quick_Sort(B , Max);
	stop = clock();
	T = (double)(stop-start)/CLOCKS_PER_SEC;
	cout <<"快速排序用时："<<T<<"s"<<endl;
	
	for (int i=0 ; i< Max; i++)
		B[i] = A[i];
	start = clock ();
	Bucket_Sort(B , Max);
	stop = clock();
	T = (double)(stop-start)/CLOCKS_PER_SEC;
	cout <<"桶排序用时："<<T<<"s"<<endl;
	
	for (int i=0 ; i< Max; i++)
		B[i] = A[i];
	start = clock ();
	Cardinal_Sort(B , Max);
	stop = clock();
	T = (double)(stop-start)/CLOCKS_PER_SEC;
	cout <<"队列实现基数排序用时："<<T<<"s"<<endl;
	
	for (int i=0 ; i< Max; i++)
		B[i] = A[i];
	start = clock ();
	LSDRadixSort(B , Max);
	stop = clock();
	T = (double)(stop-start)/CLOCKS_PER_SEC;
	cout <<"mooc给出的基数排序用时："<<T<<"s"<<endl;
 }

在这里插入图片描述
桶排序显示0秒是因为太快了，计算不到时间，感兴趣的话可以让他重复运行10次，然后将最后的时间除10就可以把平均速度算出来了。

代码噜噜噜
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python每日算法 | 基数排序PK快速排序，手撕基数排序算法！
REPCHAOCHAO的博客
09-07 681
python每日算法9.7：十大排序算法之基数排序，通过本期内容你将掌握基数排序如何用python实现，以及基数排序与快速排序的效率比较。
基数排序比快速排序快
WINCOL的专栏
11-11 3748
 最近在关于算法的书籍本以为以前看过的算法书都说快速排序是最好的排序算法，也没有想过，闲着无聊变写了一个关于基数排序的算法简单分析了一下应该时间复杂度比快速排序小，于是编程实现果然结果要比快速排序快，对两者都1000000个数排序快速排序一般要700多毫秒，基数排序一般要200毫秒，10000000个数排序的情况就更明显了前者需要30秒左右，而后者只需要3～5秒左右。算法测
基础数据结构17：基数排序和快速排序
小柒的秃头之路
08-31 613
1.基数排序（桶排序）：低位优先，所有数据从低位开始，一次放入到10个桶内，再次从桶里取出，直到完全有序。 快速排序：每次找基准值的位置，以基准线为分界线，左边的值全部比基准值小，而右边的值肯定比基准值大。 规则：从右向左找比基准值小的数据放到左边，找到后放到左边，从左向右找比基准值大的数据，找到后放到右边，重复上面的操作，直到left=right，循环退出，再将基准值放到arr[left]或者arr[right]。 #include <stdio.h> #include <asser
基数排序和快速排序谁快(随机数测试)？
m0_51390969的博客
12-13 1005
文章目录前言一、测试结果对比二、附上代码，大家可以自己手动测试测试 前言 一、测试结果对比 使用的是win10的子系统ubuntu编译运行 计算时间使用的是< cstdlib>里的clock()函数，因为数量很小，所以最后结果没除CLOCKS_PER_SEC 基数排序会快一些，但是消耗空间接近2倍更多。 2倍，才2倍？ 我参考了这个优化—链接 二、附上代码，大家可以自己手动测试测试 #include<iostream> #include<cstdio> #inclu.
快速排序，希尔排序，归并排序，基数排序的时间复杂度比较
最新发布
damoyuanzhuvhi的博客
08-08 415
希尔排序通过gap步长，不着眼于一个个细节，而着眼于全局，将全局向有序推进，从而相对于插值排序减少了移位次数，优化了时间，时间复杂度与gap有关，插值排序相当于gap=1的情况。快速排序最好的情况是选择的基数更将数组左右平分，这种情况下形成的递归树的高度为logn，每一层的规模为n，所以时间复杂度为O（nlogn）。基数排序处理一次的时间复杂度为O（n），处理的次数由最大数的位数决定，所以时间复杂度为O（n）。最坏的情况为基数总是最大或者最小，这种情况相当于冒泡排序，时间复杂度为O（n^2）
【数据结构笔记38】桶排序、基数排序、多关键字排序、排序算法汇总比较
记录学习痕迹的公众号：Piper蛋窝
10-22 625
基数排序是由桶排序引申的算法，并且有可能突破NlogN的极限。
【数据结构与算法】-＞算法-＞排序（三）-＞线性排序-＞桶排序&计数排序&基数排序
欢迎来到新世界
09-07 253
排序（三）Ⅰ 前言Ⅱ 桶排序（Bucket Sort）A. 原理B. 适用场景C. 代码实现Ⅲ 计数排序（Counting Sort）A. 原理B. 适用场景C. 代码实现Ⅳ 基数排序（Radix Sort）A. 原理B. 适用场景C. 代码实现 Ⅰ 前言 再次把之前的表拿出来。排序算法就剩最后三个要讲啦。 前面两节可以跳转下面两篇文章去看???? 【数据结构与算法】-＞算法-＞排序（一）-＞冒泡排序&插入排序&选择排序 【数据结构与算法】-＞算法-＞排序（二）-＞归并排序&快速排
数据结构-排序.ppt
12-03
"数据结构-排序.ppt" 在计算机科学中，排序算法是指将一组无序的记录序列调整为有序的记录序列的算法。排序算法的重要性在于，它可以将大量的数据按一定的规律顺次排列起来，使得数据更加有序和易于管理。 排序的...
(完整word版)数据结构实验-排序算法C++实现.doc
11-16
排序算法 C++ 实现实验报告 本实验报告的主要目的是学习、实现、对比各种排序算法，掌握...本实验报告对各种排序算法的实现和比较进行了详细的分析和讨论，为后续的数据结构实验和算法设计提供了有价值的经验和参考。
常用排序PK 冒泡 快排 选择排序 基数排序 等
11-25
在编程领域，排序算法是数据结构与算法学习中的基础部分，它们用于将一组无序的数据按照特定顺序排列。本文将详细解析几种常见的排序算法：冒泡排序、快速排序、选择排序以及基数排序，并探讨它们的工作原理、效率和...
数据结构课程设计——多关键字排序.docx
01-17
### 数据结构课程设计——多关键字排序 #### 一、问题描述与任务定义 在实际应用场景中，例如高考分数处理，不仅需要对考生的总分进行排序，还要考虑到不同专业对单科成绩的不同要求。这就引入了多关键字排序的...
排序 数据结构 堆排序 快排
12-27
基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数进行比较。通常按照低位先排序，然后收集；再按高位排序，然后再收集；依次类推，直到最高位。 **特点**： - 时间...
排序算法---快速排序、堆排序、冒泡排序
qq_41683305的博客
05-09 1028
排序算法1 快速排序 1 快速排序 文章原地址：https://blog.csdn.net/morewindows/article/details/6684558 快速排序的平均时间复杂度是0(NlogN)，它采用了一种分治的策略，通常称其为分治法。该方法的基本思想是： 先从数列中取出一个数作为基准数。 分区：将大于这个数放到它的右边，小于等于它的数全放在它的左边 再对左右区间重复第二步，直到各区间只要一个数 虽然快速排序称为分治法，但分治法这三个字显然无法很好概括快速排序的全部步骤，因此我对快速排序做了
快速排序，堆排序和基数排序
coolwriter的博客
05-01 1832
之前我的博客有排序算法总结 十种排序算法 - CSDN博客 https://blog.csdn.net/coolwriter/article/details/78732728 1、快速排序 　　快速排序的中心是填坑法，取一个数（这里选取第一个数）作为基准数temp，从队尾开始寻找第一个比基准数小的数a[j]，交换a[j]和temp，然后队首开始查找第一个比temp大的数a[i]，交换之，遍...
数据结构算法———基数排序
热门推荐
05-30 1万+
数据结构算法介绍之基数排序(Radix Sort)
快速排序和基数排序
yeternity的博客
05-09 1424
承接 09-排序1 排序 (25分) #include #include #define MAX 100005 typedef long ElementType; //快速排序-直接调用库函数 //简单整数排序 int compare ( const void *a, const void *b ) { return ( *(ElementType*)a - *(ElementType*)
计数排序，基数排序，桶排序和快速排序算法时间对比
shakingWaves的专栏
01-07 1190
//基数排序 #include #include #include using namespace boost::timer; using namespace std; void find_max_min(int *a,int &max,int &min,int n) { max=a[0],min=a[0];//寻找最大最小值 for(int i=1;i<n;++i){ if(ma
超排序——（桶排序 + 快排）
BlessingXRY的博客
02-22 2524
think: 1题目名字叫做超排序，自己才疏学浅，依据查到的知识，阐述一下自己对超排序尚不成熟的想法，我们都知道快速排序速度快，但是遇到相同数据的时候不稳定，自己之前看到过一个数据时间复杂度那时可能达到O(N^2)，和之前的O(NlogN)差的挺大的，而桶排序是为数不多的时间复杂度达到O(N)的优秀算法，但是其对内存的要求可能就会比较高，快排和桶排排序都很优秀，但同样都存在这得失的条件，而将快排和
数据结构--线性结构
ACMer
01-30 1303
线性结构 线性结构主要有以下四种: 线性表 栈 队列 栈 每种线性结构都可以用链表或者数组去实现，本身也是属于线性表，个人自学数据结构目前主要用于程序竞赛，所以主要以数组实现为主。 线性表（List） 数据对象集：n个元素构成的有序序列（a1，a2…an） 操作集：线性表L∈List，整数i表示位置，元素X∈ElementType，线性表的基本操作主要有: 1、List MakeEmpty()...
数据结构-内部排序方法详解：插入排序、快速排序等
该资源主要讨论了数据结构中的排序算法，特别是直接插入排序，并提到了其他几种常见的排序算法，如快速排序、堆排序、归并排序和基数排序。此外，还涉及了内部排序和外部排序的概念，以及各种排序方法的分类。 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值