顺序冒泡、倒序冒泡、插入排序、折半插入排序、希尔排序、快速排序、选择排序c语言实现

        只放代码，用代码理解记忆，可以搜索数据结构与算法动态可视化网站进行学习。

---

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趟，代码自己想咯。