只放代码,用代码理解记忆,可以搜索数据结构与算法动态可视化网站进行学习。
1.冒泡排序
一般书上给的是,倒序冒泡,这里给出顺序冒泡的代码。这里用的是g++编译器,认可bool运算,其它不认可的话,可以用整形来代替。时间复杂度o(),空间o(1),稳定。
#include<stdio.h>
#include<stdlib.h>
#define Max 10
#include<time.h>
void bubblesort(int *A,int n)
{
for(int i=0;i<n-1;i++)
{
bool tag=false;
for(int j=i+1;j<n;j++)
{
if(A[i]>A[j])
{
int temp;
temp=A[i];
A[i]=A[j];
A[j]=temp;
tag=true;
}
}
if(!tag)
{
return ;//如果某一趟没有发生交换,则序列已经有序
}
}
}
int main(void)
{
srand(time(NULL));
int arr[Max];
for(int i=0;i<Max;i++)
{
arr[i]=rand()%50;
printf("%d ",arr[i]);
}
putchar(10);
bubblesort(arr,Max);
for(int i=0;i<Max;i++)
{
printf("%d ",arr[i]);
}
return 0;
}
2.直接插入排序
一个一个地插入,顺便排序,小的保持,大的后移一个位置,以插入属于它的位置。时间复杂度o(),空间o(1),稳定。固定为n-1趟。
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
//#include<string.h>
//直接插入排序
void insertSort(int *arr,int n)
{
int temp,j;
for(int i=1;i<n;i++)
{
if(arr[i]<arr[i-1])//注意if的作用域范围
{
temp=arr[i];
for(j=i-1;j>=0&&arr[j]>temp;j--)
{
arr[j+1]=arr[j];
}
arr[j+1]=temp;
}
}
}
int main(void)
{
srand(time(NULL));
int array[10];
for(int i=0;i<10;i++)
{
array[i]=rand()%20;
printf("array[%d]=%d\n",i,array[i]);
}
insertSort(array,10);
//putchar(10);
printf("\n");
for(int i=0;i<10;i++)
{
printf("array[%d]=%d\n",i,array[i]);
}
return 0;
}
3.折半插入排序
先找到插入的位置再移,而不是像直接插入排序中的边比较边移动,所以性能是更佳的。什么其它版本的哨兵,我的代码主打下标从0开始。时间复杂度o(),空间o(1),稳定。固定为n-1趟。
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define MAXSIZE 10
//#include<string.h>
void InsertSort(int *arr)
{
int low, high;
int temp,mid;
int i,j;
for(i=1;i<MAXSIZE;i++) //n的平方
{
low=0;
high=i-1;
temp=arr[i];
while(low<=high)
{
mid=(low+high)/2;
if(arr[mid]>temp)
{
high=mid-1;
}
else
{
low=mid+1;
}
}
for(j=i-1;j>=high+1;j--)
{
arr[j+1]=arr[j];
}
arr[high+1]=temp;
}
}
int main(void)
{
int array[MAXSIZE];
srand(time(NULL));
for(int i=0;i<MAXSIZE;i++)
{
array[i]=rand()%100;
printf(" array[%d]=%d ",i,array[i]);
}
putchar(10);
InsertSort(array);
for(int i=0;i<MAXSIZE;i++)
printf("%d ",array[i]);
return 0;
}
4.希尔排序
等距分组,组间排序,缩小间距,再次排序。剩下的看代码,算不出时间复杂度,空间:o(1),不稳定。
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 10
#include<time.h>
void ShellSort(int *arr,int n)
{
int i,j,temp;
for(int dk=n/2;dk>0;dk/=2)
{
for(i=dk;i<n;i++)
{
if(arr[i]<arr[i-dk]) //先for在if,因为依托于i
{
temp=arr[i];
for(j=i-dk;j>-1&&arr[j]>temp;j-=dk)
{
arr[j+dk]=arr[j];
}
arr[j+dk]=temp;
}
}
}
}
int main(void)
{
srand(time(NULL));
int arr[MaxSize];
for(int i=0;i<MaxSize;i++)
{
arr[i]=rand()%100;
printf("%d ",arr[i]);
}
putchar(10);
ShellSort(arr,MaxSize);
for(int i=0;i<MaxSize;i++)
{
printf("%d ",arr[i]);
}
return 0;
}
5.快速排序
有注释,直接看代码。空间时间复杂度都是o(nlog),这里说的是平均情况下的复杂度,快速排序在最坏情况下时间复杂度为o()。不稳定。
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
int Partition(int *arr,int low,int high)
{
int pivot=arr[low]; //枢轴元素
while(low<high)
{
while(arr[high]>=pivot&&low<high) //从后往前找到小于 枢轴元素的值
{
high--;
}
arr[low]=arr[high];
while(arr[low]<=pivot&&low<high) //从前往后找到大于枢轴元素的值
{
low++;
}
arr[high]=arr[low];
}
arr[low]=pivot;
return low; //返回枢轴元素最终放入的位置
}
void QuickSort(int *arr,int low,int high)
{
if(low<high)
{
int index=Partition(arr,low,high);
QuickSort(arr,low,index-1); //在枢轴元素的两边进行另一步骤的快速排序
QuickSort(arr,index+1,high);
}
}
int main(void)
{
srand(time(NULL));
int a[10];
for(int i=0;i<10;i++)
{
a[i]=rand()%100;
printf("a[%d]:%d ",i,a[i]);
//putchar(10);
}
putchar(10);
QuickSort(a,0,9);
for(int i=0;i<10;i++)
{
//a[i]=rand()%100;
printf("a[%d]:%d ",i,a[i]);
}
return 0;
}
6.选择排序
参考上述顺序冒泡排序,这里只是要交换位置的时,记录要交换的值的数组下标,减少交换次数,只进行最后的一次交换。时间复杂度o(),空间o(1),不稳定。固定为n-1趟,代码自己想咯。