基于比较的排序算法

最新推荐文章于 2024-07-22 22:48:43 发布

MadJieJie

最新推荐文章于 2024-07-22 22:48:43 发布

阅读量855

点赞数 2

分类专栏： Algorithms Other 文章标签：排序算法 C c++ ea

若有帮助，请点赞&收藏，转载请标注出处。

本文链接：https://blog.csdn.net/MadJieJie/article/details/68065175

版权

Other 同时被 2 个专栏收录

32 篇文章 1 订阅

订阅专栏

Algorithms

5 篇文章 2 订阅

订阅专栏

常用的排序算法总结

插入排序

时间复杂度：O(n^2)

实现思路：

（1）设置基准数a[0]，将待插入纪录的值赋值给a[0]；

（2）设置开始查找的位置moveInd；

（3）在数组中进行搜索，搜索中将第moveInd个纪录后移，直至a[0].value≥a[moveInd].value为止；

（4）将a[0]插入a[moveInd+1]的位置上。

/******************************************************************
@function: ascending order sort
@param: a:array first address. len:array elements,you can get for sizeof(a)/sizeof(a[0]) 
@return:
*******************************************************************/
void InsertSort(int*a,int length) 
{
	for (int index=1;index<length;index++)
	{
		int moveInd=index-1;
		int afterVal = a[index];
		
		while ( moveInd>=0 && a[moveInd]>afterVal )	//moveInd can't over index&
		{
			a[moveInd+1] = a[moveInd];	//move
			moveInd--;	
		}
			
		a[moveInd+1] = afterVal;
	}
}

选择排序

时间复杂度：O(n^2)

实现思路：

（1）从a数组下标index=0开始遍历数组;

（2）在（1）的遍历循环中将最小（大）的元素下标（beforeInd）;

（3）before判断是否大于index，大于则下标为before和index-1（相当于起始位置）交换元素,反之。

/******************************************************************
@function: ascending order sort
@param: a:array first address. len:array elements,you can get for sizeof(a)/sizeof(a[0]) 
@return:
*******************************************************************/
void SelectSort(int*a,int len) 
{	
	int index,afterInd,beforeInd;
	for (index=0;index<len-1;index++)
	{
		for (afterInd=index+1,beforeInd=index;afterInd<len;afterInd++)
		{
			if (a[afterInd]<a[beforeInd])		//find min
				beforeInd=afterInd;		
		} 
		
		if (beforeInd>index)				//swap value
			SWAP(a[index],a[beforeInd]);
	}
}

冒泡排序

时间复杂度：O(n^2)

实现思路：

（1）构造两重循环,第一层循环（i值下标）遍历到数组倒数第二个数,第二层循环在i值的基础上遍历剩余下标的数

（2）在第二层循环中将当前循环所涉及到的最小值交换移动到前列。

/******************************************************************
@function: ascending order sort
@param: a:array first address. len:array elements,you can get for sizeof(a)/sizeof(a[0]) 
@return:
*******************************************************************/
void BubbletSort(int*a,int len) 
{
	for(int i=0;i<len-1;i++)
		for(int j=i+1;j<len;j++)
		{
			if(a[i]>a[j])
			{
				SWAP(a[i],a[j]);
			}
		}
}

堆排序

时间复杂度：O(nlog n)

实现思路：

（1）从a数组下标index=0开始遍历数组;

（2）在（1）的遍历循环中将最小（大）的元素下标（beforeInd）;

（3）before判断是否大于index，大于则下标为before和index-1（相当于起始位置）交换元素,反之。

/******************************************************************
@function: tree make-up
@param: 
@return:
*******************************************************************/
void HeapAdjust(int *a,int rootIndex,int len)
{
	int childIndex;
    for(;2*rootIndex+1<len;rootIndex=childIndex)//出口是树的结点越界 
    {
        //子结点的位置=2*(父结点位置)+1
        childIndex=2*rootIndex+1;
        //得到子结点中较大的结点
        if(childIndex<len-1 && a[childIndex+1]>a[childIndex])
        {
    		childIndex++;    	
        }

        //如果较大的子结点大于父结点那么把较大的子结点往上移动，替换它的父结点
        if(a[rootIndex]<a[childIndex])
        {
            SWAP(a[rootIndex],a[childIndex]); 
        }
        else 
        {
   			break; //否则退出循环     	
        }

    }
}
/******************************************************************
@function: heap sort
@param: a:array first address. len:array elements,you can get for sizeof(a)/sizeof(a[0]) 
@return:
*******************************************************************/
void HeapSort(int*a,int len) //算法主体函数
{
	//调整序列的前半部分元素，调整完之后第一个元素是序列的最大的元素
    //length/2-1是最后一个非叶节点，此处"/"为整除
	for(int i=len/2-1;i>=0;i--) /**构建完全树*/ 
		HeapAdjust(a,i,len);
	
	/**将完全树进行排序*/	
	while(--len)
	{
		//第一个元素和当前的最后一个元素交换，
        //保证当前的最后一个位置的元素都是在现在的这个序列之中最大的 
		SWAP(a[0],a[len]);
		//不断缩小调整heap的范围，每一次调整完毕保证第一个元素是当前序列的最大值
		HeapAdjust(a,0,len);
	}
}