一、排序的分类
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.csdn.net/weixin_42636552/article/details/82258184?