这是对个人对于排序算法回顾和复习,所以可能写的很省略。如果之前没有学过可以看看参考列的博客。这篇博客在秋招后会删掉。写的太low了o(╯□╰)o
冒泡排序
通过前后相邻元素进行比较一次最大或最小值放到最后,思想很简单,不细说。
void BubbleSort(int A[], int n)
{
int temp;
for (int j = 0; j < n - 1; j++)
{
for (int i = 0; i < n - 1 - j; i++)
{
if (A[i] > A[i + 1])
{
temp=A[i];
A[i]=A[i+1];
A[i+1]=temp;
}
}
}
}
简单选择排序
初始时在序列中找到最小(大)元素,放到序列的起始位置作为已排序序列;然后,再从剩余未排序元素中继续寻找最小(大)元素,放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。
第一趟{1,5,3,6,8,7,2,4}
第二趟{1,2,3,6,8,7,5,4}
第三趟{1,2,3,6,8,7,5,4}
第四趟{1,2,3,4,8,7,,5,6}
第五趟{1,2,3,4,5,7,8,6}
第六趟{1,2,3,4,5,6,8,7}
第七趟{1,2,3,4,5,6,7,8}
void SelectSort(int A[],int n)
{
int min,temp;
for(int i=0;i<n;i++)
{
min=i;
for(int j=i+1;j<n;j++)
if(A[j]<A[min])
min=j;
if(min!=A[i])
{
temp=A[i];
A[i]=A[min];
A[min]=temp;
}
}
}
插入排序
思想很简单,将前面当成已排序序列,然后从后往前插入数据。依次扩大已排序序列,从后往前插入。
还是以前面序列为例
{ 6, 5, 3, 1, 8, 7, 2, 4 }
第一趟:{5,6,3,1,8,7,2,4}
第二趟:{3,5,6,1,8,7,2,4}
第三趟:{1,3,5,6,8,7,2,4}
第四趟:{1,3,5,6,8,7,2,4}
第五趟:{1,3,5,6,7,8,2,4}
第六趟:{1,2,3,5,6,7,8,4}
第七趟:{1,2,3,4,5,6,7,8}
伪代码
void InsertSort(int A[],int n)
{
int temp;
for(int i=1;i<n;i++)
{
temp=A[i];
int j;
for(j=i-1;j>=0;j--)
{
if(temp<A[j])
A[j+1]=A[j];
else
break;
}
A[j+1]=temp;
}
}
二分插入排序
二分排序其实就是对上面插入排序的改进,将前面的顺序遍历查找改成了二分查找。
void BinarySort(int A[],int n)
{
int low,high,temp;
for(int i=1;i<n;i++)
{
temp=A[i];
low=0;
high=i-1;
int mid;
while(low<=high)
{
mid=(high+low)/2;
if(A[mid]<temp)
low=mid+1;
else
high=mid-1;
}
int j;
for(j=i;j>low;j--)
A[j]=A[j-1];
A[low]=temp;
}
}
希尔排序
算法思路:
先取一个正整数 d1(d1 < n),把全部记录分成 d1 个组,所有距离为 d1 的倍数的记录看成一组,然后在各组内进行插入排序
然后取 d2(d2 < d1)
重复上述分组和排序操作;直到取 di = 1(i >= 1) 位置,即所有记录成为一个组,最后对这个组进行插入排序。一般选 d1 约为 n/2,d2 为 d1 /2, d3 为 d2/2 ,…, di = 1。
其中d1一般为n/2
还是以前面的序列为例
{ 6, 5, 3, 1, 8, 7, 2, 4 }
令d1=4
可以将上面分成四组{6,8},{5,7},{3,2},{1,4}
然后进行插入排序{6,8},{5,7},{2,3},{1,4}
第一趟结果{6,5,2,1,8,7,3,4}
d2=2
分成两组{6,2,8,3},{5,1,7,4}
第二趟{2,3,6,8},{1,4,5,7}
所以最终结果为{2,1,3,4,6,5,8,7}
d3=1
最终结果
{1,2,3,4,5,6,7,8}
void ShellSort(int A[],int n)
{
int d1=n/2;
int temp,j;
while(d1>0)
{
//内部插入排序
int num=n/d1;
int p=0;
while(p<num)
{
for(int i=d1;i<n;i+=d1)
{
temp=A[i];
for(j=i-d1;j>=0;j-=d1)
{
if(A[j]>temp)
A[j+d1]=A[j];
else
break;
}
A[j+d1]=temp;
}
p++;
}
d1=d1/2;
}
}
归并排序
归并排序算法主要依赖归并(Merge)操作。归并操作指的是将两个已经排序的序列合并成一个序列的操作,归并操作步骤如下:
申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列
设定两个指针,最初位置分别为两个已经排序序列的起始位置
比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置
重复步骤3直到某一指针到达序列尾
将另一序列剩下的所有元素直接复制到合并序列尾
{ 6, 5, 3, 1, 8, 7, 2, 4 }
L=4时,递归分组为{6,5,3,1},{8,7,2,4}
L=2时,递归分组为{6,5},{3,1},{8,7},{2,4}
L=1时,递归分组为{6},{5},{3},{1},{8},{7},{2},{4}.
合并
L=2 {5,6},{1,3},{7,8},{2,4}
L=4 {1,3,5,6},{2,4,7,8}
L=8 {1,2,3,4,5,6,7,8}
void Merge(int *a,int s,int m,int n)
{
int *temp=new int[n];
int i=s,q=s;
int j=m+1;
//将两个分组按顺序合并
while(i<=m&&j<=n)
{
if(a[i]<a[j])
temp[q++]=a[i++];
else
temp[q++]=a[j++];
}
while(i<=m)
temp[q++]=a[i++];
while(j<=n)
temp[q++]=a[j++];
for(int k=s;k<=n;k++)
a[k]=temp[k];
delete temp;
}
void MSort(int *a,int s,int t)
{
int m;
if(s==t)
return;
else
{
m=(s+t)/2;
MSort(a,s,m);
MSort(a,m+1,t);
Merge(a,s,m,t);
}
}
void MergeSort(int a[],int N)
{
MSort(a,0,N-1);
}
堆排序
堆(二叉堆)可以视为一棵完全的二叉树,完全二叉树的一个“优秀”的性质是,除了最底层之外,每一层都是满的,这使得堆可以利用数组来表示(普通的一般的二叉树通常用链表作为基本容器表示),每一个结点对应数组中的一个元素。
将其用一个数组保存序列就是{80,60,70,50,40,30,20,10,1}
并且如果二叉树的序列是从0开始(对应数组下标从0开始)
则有叶子节点和根节点序列i的关系式为
- Leftchild=2i+1
Rightchild=2i+2。
堆排序分为两步- 构建堆
- 调整堆
以序列{6,5,3,1,8,7,2,4}为例
构建堆的时候构建顺序是从下往上从右往左的进行。在构建过程中会破坏堆,这时候需要调整。调整的时候顺序是从上往下的。
//堆排序
void HeapAdjust(int A[],int s,int m)
{
//保存根节点
int temp=A[s];
for(int j=2*s;j<=m;j=j+1)
{
//判断左子树右子树大小
if(j<m&&A[j]<A[j+1])
j++;
//如果根节点较大,直接结束。
if(temp>A[j])
break;
//重新调整子树
A[s]=A[j];
s=j;
}
A[s]=temp;
}
void HeapSort(int A[],int n)
{
int temp;
//构建堆
for(int i=(n-1)/2;i>=0;i--)
HeapAdjust(A,i,n-1);
for(int j=n-1;j>0;j--)
{
//调整并构建堆
temp=A[0];
A[0]=A[j];
A[j]=temp;
HeapAdjust(A,0,j-1);
}
}
快速排序
很经典,不多讲。
int Partition(int A[],int low,int high)
{
int t=A[low];
while(low<high)
{
while(A[high]>t&&low<high)
high--;
A[low]=A[high];
while(A[low]<t&&low<high)
low++;
A[high]=A[low];
}
A[low]=t;
return low;
}
void QuickSort(int A[],int low,int high)
{
int i;
if(low<high)
{
//求中枢
i=Partition(A,low,high);
QuickSort(A,low,i);
QuickSort(A,i+1,high);
}
}
int main()
{
int A[] = { 6, 5, 3, 1, 8, 7, 2, 4 }; // 从小到大冒泡排序
int n = sizeof(A) / sizeof(int);
QuickSort(A, 0,n-1);
for(int i=0;i<n;i++)
printf("%d ",A[i]);
printf("\n");
return 0;
}