常见排序算法

最新推荐文章于 2025-05-14 21:19:16 发布

原创最新推荐文章于 2025-05-14 21:19:16 发布 · 304 阅读

0 ·

CC 4.0 BY-SA版权

数据结构与算法专栏收录该内容

7 篇文章

订阅专栏

一.选择排序

1.概念：每次从无序的子数组里面选择最小的数，放在有序区的后面（既与无序区的首元素交换）；不稳定排序；时间复杂度O(n^2);辅助存储O(1)

2.代码实现

int SELECTION_SORT(int *A,int len)  //len为数组元素个数
{
	for(int i=0;i<len-1;i++)
	{
		int _min=i;
		for(int j=i+1;j<len;j++)
		{
 			if(A[j]<A[_min])
			_min=j;
		}
		int temp=A[_min];
		A[_min]=A[i];
 		A[i]=temp;
	}
	return 0;
}

3. 举例

int main()
{
	int A[]={3,5,2,6,2,1,6,6,0};
	SELECTION_SORT(A,9);
	for(int i=0;i<9;i++)
		cout<<A[i]<<"  ";
	return 0;
}

结果：

二.冒泡排序

1.概念：重复访问数列n-1次，每次比较相邻的两个元素，若顺序不对则交换两个元素；稳定排序；时间复杂度O(n^2)；辅助存储O(1)

2.代码实现

int BUBBLE_SORT(int *A,int len)
{
	if(A==NULL||len==0)
		return 0;
	for(int i=0;i<len-1;i++)
		for(int j=0;j<len-1-i;j++)
		{
			if(A[j]>A[j+1])
			{
				int temp=A[j];
				A[j]=A[j+1];
				A[j+1]=temp;
			}
		}
	return 0;
}

3.举例

int main()
{
	int A[]={1,3,6,3,7,2,1,8};
	<span style="font-size:12px;">BUBBLE_SORT(A,8);
	for(int i=0;i<8;i++)
		cout<<A[i]<<"   ";</span>
	return 0;
}

结果

三.直接插入排序

1.概念：每次从无序表中取出第一个元素，把它插入到有序表的合适位置，使有序表仍然有序，重复n-1次；稳定排序；时间复杂度O(n^2);辅助存储O(1)

2.实现代码

int INSERTION_SORT(int *A,int len)
{
	 for(int i=1;i<len;i++)
		for(int j=0;j<i;j++)    //j从i到0更易交换
		{
			if(A[i]<A[j])
			{
				int temp=A[i];
                                A[i]=A[j];
 				A[j]=temp;
			}
		}
		return 0;
}

3.举例

int main()
{
	int A[]={3,2,5,3,6,2,1,7,6};
	INSERTION_SORT(A,9);
	for(int i=0;i<9;i++)
		cout<<A[i]<<"   ";
	return 0;
}

结果

四.快速排序

1.概念：通过一趟递归使数组分为两个自子数组，一部分的元素都比父数组最后一个人元素小，一部分元素都比父数组的最后一个元素大，这样递归下去，直到子数组的元素个数为2；不稳定排序；平均时间复杂度O(nlogn)；最坏情况时间复杂度O(n^2)，当数组本来就有序时；存储辅助O(logn)

2.代码实现

int PATITION(int *A,int p,int r)
{
	int i=p-1;
	int x=A[r];
	for(int j=p;j<r;j++)
	{
		if(A[j]<x)
		{
			i=i+1;
			int temp=A[j];
			A[j]=A[i];
			A[i]=temp;
		}
	}
	i=i+1;
	A[r]=A[i];
	A[i]=x;
	return i;
}
int QUICK_SORT(int *A,int p,int r)     //p为数组第一个元素的下标，r为数组最后一个元素的下标
{
	if(p>=r)
		return 0;
	int q=PATITION(A,p,r);
	QUICK_SORT(A,p,q-1);
	QUICK_SORT(A,q+1,r);
	return 0;

}

3.举例

int main()
{
	int A[]={3,6,2,34,7,1,4,15,7,3,6};
	QUICK_SORT(A,0,10);
	for(int i=0;i<11;i++)
		cout<<A[i]<<"   ";
	return 0;
}

结果

五.归并排序

1.概念：把一个数组分成两个子数组，分别对两个子数组进行排序，然后合并两个子数组，使整个数组有序，如此递归下，直到子数组元素个数为2；稳定排序；时间复杂度O(nlogn)；存储辅助O(n)

2.代码实现

int MERGE(int *A,int p,int q,int r)
{
	int len1=q-p+1;
	int len2=r-q;
	int *A1=new int[len1+1];
	int *A2=new int[len2+1];
	for(int i=0;i<len1;i++)
		A1[i]=A[p+i];
	for(int i=0;i<len2;i++)
		A2[i]=A[q+1+i];
	A1[len1]=100;              //为了后边比较方便在此设置哨兵值，一般取大于数组最大元素的值
	A2[len2]=100;
	int i=0;
	int j=0;
	for(int k=p;k<=r;k++)
	{	
		if(A1[i]<=A2[j])
		{
			A[k]=A1[i];
			i++;
		}
		else	// if(A1[i]>=A2[j])   是错的，因为若前面i++
		{
			A[k]=A2[j];
			j++;
		}
	}
	delete [] A1;
	delete [] A2;
	return 0;
}

int MERGE_SORT(int *A,int p,int r)
{
	if(p<r)
	{
		int q=(p+r)/2;
		MERGE_SORT(A,p,q);
		MERGE_SORT(A,q+1,r);
		MERGE(A,p,q,r);
	}
	return 0;
}

3.举例

int main()
{
	int A[]={5,3,6,10,7,4,2,0,7,3};
	MERGE_SORT(A,0,9);
	for(int i=0;i<10;i++)
		cout<<A[i]<<"   ";
	return 0;
}

结果

六.堆排序

1.概念利用最大堆设计的一种排序算法，利用数组的特点快速定位指定索引的元素；

不稳定排序；时间复杂度O(nlogn)；存储辅助O(1)

2.代码实现

int MAX_HEAPIFY(int *A,int i,int len)    //维护最大堆      len待排数组元素个数
{
	int left=2*i+1;
	int right=2*i+2;
	int large;
	if(left<len&&A[left]>A[i])
		large=left;
	else
		large =i;
	if(right<len&&A[right]>A[large])
		large=right;
	if(large!=i)
	{
		int temp=A[large];
		A[large]=A[i];
		A[i]=temp;
		MAX_HEAPIFY(A,large,len);
	}
	return 0;
}

int BULID_MAX_HEAPIFY(int *A,int len)          //建最大堆
{
	for(int i=len/2-1;i>=0;i--)
		MAX_HEAPIFY(A,i,len);
	return 0;
}

int HEAP_SORT(int *A,int len)           //堆排序
{
	BULID_MAX_HEAPIFY(A,len);
	for(int i=len-1;i>0;i--)
	{
		int temp=A[i];
		A[i]=A[0];
		A[0]=temp;
		len=len-1;
		MAX_HEAPIFY(A,0,len);
	}
	return 0;
}

3.举例

int main()
{
	int A[]={5,3,9,7,6,2,6,8,3};
	HEAP_SORT(A,9);
	for(int i=0;i<9;i++)
		cout<<A[i]<<"   ";
	return 0;
}

结果：

七.shell(希尔）排序

1.概念：先将整个待排序列分割为若干个子序列分别进行直接插入排序，直到整个序列"基本有序"时，在对全体进行一次直接插入排序。不稳定排序，时间复杂度O(n^s) 1<s<2,s取决于每轮选择的增量；存储辅助O(1)

2.实现代码

int SHELL_SORT(int *A,int len)
{	
	for(int k=len/2;k>0;k=k/2)            //k为增量
		for(int i=k;i<len;i++)
		{
			int j=i;
            if(A[i]<A[i-k])
			{
				int temp=A[i];
				do{
					A[j]=A[j-k];
					j=j-k;
				}while(j>=0&&A[j]>temp);
				A[j+k]=temp;

			}
		}	
	return 0;
}

3.举例

int main()
{
	int A[]={5,2,6,4,8,5,9,1,2};
	SHELL_SORT(A,9);
	for(int i=0;i<9;i++)
		cout<<A[i]<<"   ";
}

结果：

八.计数排序

1.概念：将数组A的每个元素作为另一个辅助数组B的下标，统计出A每个元素出现的次数，从而确定出A的每个元素在排序后的数组中所处的位置；稳定排序；时间复杂度O(n+k)；存储辅助O(n+k)

2.实现代码

int COUNTING_SORT(int *A,int len,int k)         //  k大于数组中最大数
{
	int *B=new int[k];
	int *C=new int[len];
	for(int i=0;i<k;i++)
		B[i]=0;
	for(int i=0;i<len;i++)
		B[A[i]]++;                             //统计每个元素出现的次数                    
	
	for(int i=1;i<k;i++)
		B[i]=B[i]+B[i-1];                      //计算排序后每个元素前面有多少元素，对于A中重复的元素，表示重复元素的最后一个前面有多少元素

	for(int i=len-1;i>=0;i--)         //i从后向前保证了稳定排序
	{
		C[B[A[i]]-1]=A[i];            //由于下标是从0开始，注意-1，不然就错
		B[A[i]]--;                    //考虑A中重复的元素
	}
	for(int i=0;i<len;i++)
	{
		A[i]=C[i];
	}
	delete [] B;
	delete [] C;
	return 0;
}

3.举例

int main()
{
	int A[]={3,2,6,2,5,7,1,9};
	COUNTING_SORT(A,8,12);
	for(int i=0;i<8;i++)
		cout<<A[i]<<"   ";
	return 0;
}

结果：