八大排序算法总结

插入排序

1.直接插入排序

原理：将数组分为无序区和有序区两个区，然后不断将无序区的第一个元素按大小顺序插入到有序区中去，最终将所有无序区元素都移动到有序区完成排序。

要点：设立哨兵，作为临时存储和判断数组边界之用

2.希尔排序

原理：又称增量缩小排序。先将序列按增量划分为元素个数相同的若干组，使用直接插入排序法进行排序，然后不断缩小增量直至为1，最后使用直接插入排序完成排序。

要点：增量的选择以及排序最终以1为增量进行排序结束。

交换排序

1.冒泡排序

原理：将序列划分为无序和有序区，不断通过交换较大元素至无序区尾完成排序。

要点：设计交换判断条件，提前结束以排好序的序列循环。

2.快速排序

原理：不断寻找一个序列的中点，然后对中点左右的序列递归的进行排序，直至全部序列排序完成，使用了分治的思想。

要点：递归、分治

选择排序

1.直接选择排序

原理：将序列划分为无序和有序区，寻找无序区中的最小值和无序区的首元素交换，有序区扩大一个，循环最终完成全部排序。

2.堆排序

原理：利用大根堆或小根堆思想，首先建立堆，然后将堆首与堆尾交换，堆尾之后为有序区。

要点：建堆、交换、调整堆

归并排序

原理：将原序列划分为有序的两个序列，然后利用归并算法进行合并，合并之后即为有序序列。

要点：归并、分治

基数排序

原理：将数字按位数划分出n个关键字，每次针对一个关键字进行排序，然后针对排序后的序列进行下一个关键字的排序，循环至所有关键字都使用过则排序完成。

要点：对关键字的选取，元素分配收集

代码如下， 懒人一个，直接写一个c文件里了， 看函数名应该懂的了！！！！  留做以后复习之用。。。

#include <stdio.h>
#include <stdlib.h>

void show(int *arr,int len);
void InsertSort(int *arr,int len);
void ShellSort(int *arr,int len);
void BubbleSort(int *arr,int len);
void QuickSort(int *arr,int len);
void SelectSort(int *arr,int len);
void HeapSort(int *arr,int len);
void MergeSort(int *arr,int len);
void RadixSort(int *arr,int len);

int main()
{
	int a[10] = {5,3,2,10,9,7,1,4,6,8};
		
	show(a,10);
	printf("After InsertSort:");
	InsertSort(a,10);
	show(a,10);
	

	int b[10] = {5,3,2,10,9,7,1,4,6,8};
	show(b,10);
	printf("After ShellSort:");
	ShellSort(b,10);
	show(b,10);
	
	int c[10] = {5,3,2,10,9,7,1,4,6,8};
	show(c,10);
	printf("After Bubblesort:");
	BubbleSort(c,10);
	show(c,10);

	int d[10] = {5,3,2,10,9,7,1,4,6,8};
	show(d,10);
	printf("After Quicksort:");
	QuickSort(d,10);
	show(d,10);

	int e[10] = {5,3,2,10,9,7,1,4,6,8};
	show(e,10);
	printf("After SelectSort:");
	SelectSort(e,10);
	show(e,10);

	int f[10] = {5,3,2,10,9,7,1,4,6,8};
	show(f,10);
	printf("After HeapSort:");
	HeapSort(f,10);
	show(f,10);

	int g[10] = {5,3,2,10,9,7,1,4,6,8};
	show(g,10);
	printf("After MergeSort:");
	MergeSort(g,10);
	show(g,10);

	int h[10] = {5,3,2,10,9,7,1,4,6,8};
	show(h,10);
	printf("After RadixSort:");
	MergeSort(h,10);
	show(h,10);

	return 0;
}

void show(int *arr,int len)
{
	int i;
	printf("Arr:");
	for(i=0; i<len; i++)
	{
		printf("%d ",*(arr+i));
	}
	printf("\n");
}

void InsertSort(int *arr,int len)
{
	int i,j,temp;
	for(i=1; i<len; i++)
	{
		j=i-1;
		temp = arr[i];
		while(temp < arr[j] && j>=0)
		{
			arr[j+1] = arr[j];
			j--;	
		}	
		arr[j+1] = temp;
	}
}

void ShellSort(int *arr,int len)
{
	int i,j,m;
	int d = len/2;
	int temp;
	while(d >= 1)
	{
	   for(i=0; d+i<len; i++)	
	   {
		for(j=i+d; j<len; j+=d)
		{
		 m = j-d;
	         temp = arr[j];
		 while(arr[m] > temp && m>=i)
		{
			arr[m+d] = arr[m];
			m -= d;
		}
		arr[m+d]=temp;
		}
	   }
	   d = d/2;
	}
	
}

void BubbleSort(int *arr,int len)
{
	int i,j,temp;
	int changed = 0;
	for(i=0; i<len-1; i++)
	{
		changed = 0;
		for(j=len-1; j>i; j--)
		{
			if(arr[j-1] > arr[j])
			{
				temp = arr[j-1];
				arr[j-1] = arr[j];
				arr[j] = temp;
				changed = 1;
			}	
		}	
		if(!changed)
		 	break;
	}
}

void QuickSort(int *arr,int len)
{
	if(len <= 0)
		return ;

	int temp = arr[0];
	int i,j;
	i = 0;
	j = len - 1;
	while(i < j)
	{
		while(i < j)
		{
			if(arr[j] < temp)
			{
				arr[i] = arr[j];
				break;
			}
			j--;
		}
		while(i < j)
		{
			if(arr[i] > temp)
			{
				arr[j] = arr[i];
				break;
			}
			i++;
		}
	}
	arr[i] = temp;
	QuickSort(arr,i);
	QuickSort(arr+i+1,len-i-1);
}

void SelectSort(int *arr,int len)
{
	int i,j,temp,k;

	for(i=0; i<len; i++)
	{
		k = i;
		for(j=i+1; j<len; j++)
		{
			if(arr[j] < arr[k])
				k = j;	
		}
		if(k != i)
		{
			temp = arr[i];
			arr[i] = arr[k];
			arr[k] = temp;
		}
	}
}

void AjustHeap(int *arr,int len,int start);
void BuildHeap(int *arr,int len);

void HeapSort(int *arr,int len)
{
	BuildHeap(arr,len);
	int temp;
	int j=len-1;
	do{
		temp = arr[0];
		arr[0] = arr[j];
		arr[j] = temp;
		j--;
		AjustHeap(arr,j+1,0);	
		
	}while(j>0);
}

void BuildHeap(int *arr,int len)
{
	int i,j,temp;
	for(i=0; i<len; i++)
	{
		for(j=i+1; arr[j]>arr[(j-1)/2] && j>0; j=(j-1)/2)
		{
			temp = arr[j];
			arr[j] = arr[(j-1)/2];
			arr[(j-1)/2] = temp;	
		}
	}	
}

void AjustHeap(int *arr,int len,int start)
{
	int largeFlag;
	int left,right,temp;
	left = 2*start;
	right = 2*start + 1;
	largeFlag = start;
	if(left < len)
	{
		if(arr[left] > arr[largeFlag])
			largeFlag = left;
	}
	if(right < len)
	{
		if(arr[right] > arr[largeFlag])
			largeFlag = right;
	}
	if(largeFlag != start)
	{
		temp = arr[start];
		arr[start] = arr[largeFlag];
		arr[largeFlag] = temp;
		AjustHeap(arr,len,largeFlag);
	}
}

void Merge(int *arr,int start,int mid,int end);
void MergeSort(int *arr,int len)
{
	int i = len/2;
	if(len >= 2)
	{
		MergeSort(arr,i);
		MergeSort(arr+i,len-i);
		Merge(arr,0,i,len-1);
	}
}

void Merge(int *arr,int start,int mid,int end)
{
	int start1,end1,start2,end2,i=0;
	start1 = start;
	end1 = mid-1;
	start2 = mid;
	end2 = end;
	int * temp = (int *)malloc(sizeof(int)*(end-start+1));	
	while(start1<=end1 && start2<=end2)
	{
		if(arr[start1] < arr[start2])
			temp[i++] = arr[start1++];
		else
			temp[i++] = arr[start2++];
	}
	while(start1 <= end1)
	{
		temp[i++] = arr[start1++];
	}
	while(start2 <= end2)
	{
		temp[i++] = arr[start2++];
	}
	for(i=0; i<end-start+1; i++)
	{
		arr[i] = temp[i];
	}
}

void RadixSort(int *arr,int len)
{
	int temp[10][10] = {0}; //temp order
	int count[10] = {0};	//count the number match every key
	int i,j,n,lsd,k,flag;
	
	n = 1;
 	flag = 1;
	while(flag)
	{
		flag = 0;
		k = 0;
		for(i=0; i<len; i++)
		{
			lsd = (arr[i]/n)%10;
			temp[lsd][count[lsd]++] = arr[i];
		}
		
		for(i=0; i<len; i++)
		{
			if(count[i] != 0)
			{
				for(j=0; j<count[i]; j++)
				{
					arr[k++] = temp[i][j];
				}
				flag = 1;
			}
			count[i] = 0;
		}
		n *= 10;
	}
}