一些排序的简单归纳

最新推荐文章于 2022-09-21 22:29:58 发布

つ微凉徒眸意浅挚半～～

最新推荐文章于 2022-09-21 22:29:58 发布

阅读量158

点赞数

CC 4.0 BY-SA版权

分类专栏： C语言

本文链接：https://blog.youkuaiyun.com/rjp_1987/article/details/90723682

C语言专栏收录该内容

10 篇文章

订阅专栏

一、排序的分类

1.排序算法从存储位置分为:内排序(在内存上存储)和外排序（在磁盘上存储）

2.八大排序：

（1）插入排序：直接插入、希尔排序

（2) 选择排序：简单选择排序、堆排序

（3）交换排序：冒泡排序、快速排序

（4）归并排序

（5)基数排序

二、各个排序具体的算法思想及代码实现

1.直接插入排序

是指每次从无序表中取出第一个元素，把他插入到有序表的合适位置，使有序表仍然有序

该算法思想为：找到数据合适的位置，再把数据插进去。

算法分析：时间复杂度为O(n^2）,空间复杂度O(1)。在最优情况下，时间复杂度为O(n）.越有序越快。稳定

代码实现：

void  Insert_Sort(int *arr,int len)
{
	int tmp;
	int i=1;//待排序部分的起始位置
	int j=i-1;//已排序部分的末尾位置
	for(i=1;i<len;i++)
	{
		tmp=arr[i];
		for(j=i-1;j>=0;j--)//寻找比tmp小的元素   j>=0已排序部分还没有遍历完   4,85,69,32,12,54,25,36,48,100
		{
			if(arr[j]>tmp)//没有找到合适的位置，大的元素后移
			{
				arr[j+1]=arr[j];
			}	

		}
      arr[j+1]=tmp;
	}	
}

2.希尔排序

思想：将元素进行分组，使小组内元素趋于有序，整体逐渐趋于有序。

流程： 1.划分小组，是小组内元素趋于有序；2.增量缩减，整体趋于有序；3.最后增量为1，做了一次直接插入。

算法分析：时间复杂度O(n^1.3~n^1.5), 空间复杂度为O(1）。不稳定

希尔排序是插入排序的一种优化，当增量为1时，直接为插入排序。

void Shell_Adjust(int *arr,int len,int gap)//gap表示间隔gap个元素划分成N个小组
{
	int i;//待排序的起始位置
	int j;//已排序的末尾位置
	int temp;
	for(i=gap;i<len;i++)
	{
		temp=arr[i];
		for(j=i-gap;j>=0;j-=gap)
		{
			if(arr[j]>temp)
			{
			arr[j+gap]=arr[j];
		}
			else
			{
				break;
			}
			}
		arr[j+gap]=temp;
	}
}
void Shell_Sort(int *arr,int len)
{
	int dk[]={5,3,1}; //划分时间隔设置为质数，避免将相同元素划分到同一组
	int size=sizeof(dk)/sizeof(dk[0]);
	for(int i=0;i<size;i++)
	{
		Shell_Adjust(arr,len ,dk[i]);
	}

}

3.简单选择排序

思想：每次找到当前最小元素放到适当位置；

算法分析：时间复杂度O(n^2), 空间复杂度为O(1）。稳定

void Simple_Sort(int *arr,int len)//将当前最小的元素放在对应的位置
{
	int i=0;//待排序第一个元素
	int j=0;//待排序第二个元素
	int min=0;//标记当前最小元素的下标
	for(i;i<len-1;i++)
	{
		min=i;
		for(j=i+1;j<len;j++)
		{
			if(arr[min]>arr[j])
			{
				min=j;
			}
		}
		if(i!=min)
		{
			int temp=arr[i];
			arr[i]=arr[min];
			arr[min]=temp;
		}
	}

}

4.堆排序

堆：满足完全二叉树。分为大顶堆和小顶堆。

大顶堆：堆顶的元素大于左右孩子元素；升序排列堆顶放的是当前最大的元素

小顶堆：堆顶元素小于左右孩子元素。降序排列堆顶放的是当前最小的元素

思想：首先将所有按照堆的形式建立成大顶堆，然后将堆顶元素与最后元素交换。在建立大顶堆时，通过计算得到最后一个父节点，找出左右孩子中最大节点max,然后与父节点比较。若父节点小于max，将他们进行交换。顺序是从后向前进行调整。在进行堆调整时，顺序是从上往下。将堆顶元素与最后一个节点交换，然后大顶堆进行调整；然后堆顶元素与第二个元素交换，然后大顶堆进行调整，以此类推.......

算法分析：时间复杂度O(Nlog N),空间复杂度O（1），不稳定

void Heap_Adjust(int *arr,int tmp,int len )//tmp表示父节点下标
{
	int j=tmp*2+1;//表示左下标
	int swap;
	for(j;j<len;j=2*tmp+1)
	{
		if((j<len-1)&&(arr[j]<arr[j+1]))
		{
			j++;
		}
		if(arr[j]<arr[tmp])//父亲节点的数据大于孩子节点中的数据
		    break;	
		
			swap=arr[tmp];
			arr[tmp]=arr[j];
			arr[j]=swap;

		tmp=j;//父节点的位置，标识左右孩子需要发生调整的支路上去
	}
}
void HeapSort(int *arr,int len)
{
	int i=(len-2)/2;//表示最后一个父节点的位置，建立大顶堆
	for(i;i>=0;i--)// 4 3 2 1 0
	{
		Heap_Adjust(arr,i,len);
	}
	int tmp;
	for(int j=len-1;j>0;j--)//将堆顶与最后一个节点元素交换
	{
		tmp=arr[0];
		arr[0]=arr[j];
		arr[j]=tmp;
		Heap_Adjust(arr,0,j);
	}
}

5.归并排序

思想：分治策略。分：将所有元素划分为小组，使小组内元素趋于有序，整体趋于有序。合：将小组进行合并，归并后的小组依然有序。在划分时，直到每个小组都是有序的。（小组内只有一个元素）

算法分析：时间复杂度：O(Nlog N),空间复杂度O（N）稳定的

//按照划分小组的组数（5 4 3 2 1）这样的顺序是小组内的元素排列有序.将左边小组与右边小组中的元素比较，存入临时数组tmp中
void Merge_Adjust(int arr[],int tmp[],int start,int mid,int end)
{
	    int i=start;//标识左边小组第一个元素开始的位置
		int j=mid+1;//标识右边小组第一个元素开始的位置
		int k=start;//标识tmp区的起止位置
		while(i<mid+1&&j<end+1)
		{
			if(arr[i]<=arr[j])
			{
			/*	tmp[k]=arr[j];	k++; 	i++;*/
				tmp[k++]=arr[i++];
			}
			else
			{
				tmp[k++]=arr[j++];
			}
		}
		while(i<mid+1)//左边小组没越界，右边小组越界
		{
			tmp[k++]=arr[i++];
		}
		while(j<end+1)//右边小组没越界，左边小组越界
		{
			tmp[k++]=arr[j++];
		
		}
		for(int m=start;i<end;i++)
		{
			arr[m]=tmp[m];
		}
}
//将数组里面的数据进行小组划分，直到组内有序。当组内只有一个元素时。
void Merge_divide(int arr[],int tmp[], int start,int end)
{

	if(start<end)//每次划分时使小组内排列有序
	{
		 int mid=(start+end)/2;
		Merge_divide(arr,tmp,start,mid);//将左边小组元素继续进行划分
		Merge_divide(arr,tmp,mid+1,end);//将右边小组元素进行划分
		Merge_Adjust(arr,tmp, start, mid,end);
	}

}

void MergeSort(int arr[],int len)
{
	    int *tmp=(int *)malloc(sizeof(int)*len);
		Merge_divide(arr,tmp,0,len-1);
		free(tmp);
	
}

6.冒泡排序

思想：两两比较，大的往后走，小的往前走。

算法分析：空间复杂度O(n^2),空间复杂度O（1）稳定没有优化

void Bubble(int *arr,int len)
{
	int tmp;
	for(int i=0;i<len;i++)
	{
		for(int j=0;j<len-i-1;j++)
		{
			if(arr[j]>arr[j+1])
			{
				tmp=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=tmp;
			}
		}
	}
}

7.基数排序

思想：将每个数据进行按照个/十/百/千的顺序进行排序。我们找出所有元素中最大数然后计算出他的位数，然后根据他的位数，对所以元素进行取余操作（各位、十位、百位等）。我们有0~9个容器，余数为1放进1号容器，余数为2放进2号容器，依次操作。然后将容器内的数据依照容器号拿出来，拿出的所有元素逐渐趋于有序。然后对十位取余，余数为1放进1号容器，余数为2放进2号容器，依次操作。然后将容器内的数据依照容器号拿出来，拿出的所有元素逐渐趋于有序。直到最大数字进行最高位取余结束。

8.快速排序

思想：我们在所有元素中任意选择一个元素作为基准，然后以基准所在的元素下标为划分点，进行一次划分。这是第一个我们要划分的函数。接下来是元素调整。首先我们在传参的时候，然后传入数组，开始位置，尾结点位置。在基准的左边，找比基准小的数字，往前移。在基准的右边找比基准大的元素，往后移。循环终止条件是开始位置大于等于结束位置。

算法分析：数据越有序，效率越差。空间复杂度和时间复杂度都为O（log N）。不稳定。

int Partion(int *arr,int low,int high)//一次划分
{
	int tmp=arr[low];
	while(low<high)
	{
		while(low<=high&&arr[high]>=tmp)
		{
				;
		high--;
		}
	arr[low]=arr[high];
	
	while(low<high&&arr[low]<=tmp)//找比基准小的
	{
		low++;
	}
	arr[high]=arr[low];
	
    }
	arr[low]=tmp;
	return low;
}
void Quick(int *arr,int low,int high)
{
	int par=Partion(arr,low,high);
	if(low<par)
	{
		Quick(arr,low,par-1);
	}
	if(high>par)
	{
		Quick(arr,par+1,high);
	
	}
}
void QuickSort(int *arr,int len)
{
	Quick(arr,0,len-1);
}
void Show(int *arr,int len)
{
	for(int i=0;i<len;i++)
	{
		printf("%d ",arr[i]);
	}
}

快排的优化参考博客：

https://blog.youkuaiyun.com/weixin_42636552/article/details/82258184?