常见排序算法

一、冒泡排序

算法思想：首先将第一个记录的关键字与第二个记录的关键字进行比较，若为逆序，则交换这两个记录的值，然后比较第二个记录和第三个记录的关键字，以此类推，直至第n-1个和第n个记录的关键字比较过为止；至此第一趟冒泡排序完成，对前n-1个记录的关键字按照第一趟的冒泡排序排序，依次循环，直到最后缩到第一个为止

#include<stdio.h>
void bubble_sort(int a[],int n)
{
	int i, j, t;
  for(j = 0; j < n ; j++)
 	{
	  for(i = 0; i < n - j - 1; i++)	//注意是n-j-1,因为一趟遍历n个数，要两两比较n-1次
	  {
	     if(a[i] > a[i+1])	//把值比较大的元素沉到底
	     {
	        t = a[i];
	        a[i] = a[i+1];
	        a[i+1] = t;
	     }
	  }
 	}
}

int main()
{
	int i, j;
	int arr[] = {2,4,8,5,9,7,1,10,3,6};
	for(i = 0; i < sizeof(arr)/sizeof(int); i++)
		printf("%d ",arr[i]);
	bubble_sort(arr, sizeof(arr)/sizeof(int));
	printf("\n");
	for(j = 0; j < sizeof(arr)/sizeof(int); j++)
		printf("%d ",arr[j]);
}

二、选择排序

算法思想：每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。

#include<stdio.h>
void select_sort(int arr[], int n)
{
	int i, j, k, t;
	for(i=0; i<n-1; i++)
	{
		k = i;
		for(j=i+1; j<n; j++)
		{
			if(arr[j] < arr[k])
				k = j;
		}
		if(k != i)
		{
			t = arr[i];
			arr[i] = arr[k];
			arr[k] = t;
		}
	}

}

int main()
{
	int i, j;
	int arr[] = {2,4,8,5,9,7,1,10,3,6};
	for(i = 0; i < sizeof(arr)/sizeof(int); i++)
		printf("%d ",arr[i]);
	select_sort(arr, sizeof(arr)/sizeof(int));
	printf("\n");
	for(j = 0; j < sizeof(arr)/sizeof(int); j++)
		printf("%d ",arr[j]);
}

 

 

三、直接插入排序

算法思想：每次从无序表中取出第一个元素，把它插入到有序表的合适位置，使有序表仍然有序。 第一趟比较前两个数,然后把第二个数按大小插入到有序表中; 第二趟把第三个数据与前两个数从前向后扫描，把第三个数按大小插入到有序表中；依次进行下去，进行了(n-1)趟扫描以后就完成了整个排序过程。

#include<stdio.h>
void insert_sort(int arr[], int n)
{
	int i, j, t;
	for (i = 1; i < n; i++)
	{
		t = arr[i];
		for(j=i-1; j>=0 && arr[j]>t; j--)
			arr[j+1] = arr[j];
		arr[j+1] = t;
	}
}

int main()
{
	int i, j;
	int arr[] = {2,4,8,5,9,7,1,10,3,6};
	for(i = 0; i < sizeof(arr)/sizeof(int); i++)
		printf("%d ",arr[i]);
	insert_sort(arr, sizeof(arr)/sizeof(int));
	printf("\n");
	for(j = 0; j < sizeof(arr)/sizeof(int); j++)
		printf("%d ",arr[j]);
}

四、希尔排序

算法思想：希尔排序(Shell Sort)是插入排序的一种。是针对直接插入排序算法的改进。先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成（n除以d1）个组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。

#include<stdio.h>
void shell_sort(int arr[], int n)
{
	int d, i, j, t;
	for(d=n/2; d>=1; d=d/2)
	{
		for(i=d; i<n; i++)
		{
			t = arr[i];
			for(j=i-d; j>=0 && arr[j]>t; j=j-d)
				arr[j+d] = arr[j];
			arr[j+d] = t;
		} 
	}
}

int main()
{
	int i, j;
	int arr[] = {2,4,8,5,9,7,1,10,3,6};
	for(i = 0; i < sizeof(arr)/sizeof(int); i++)
		printf("%d ",arr[i]);
	shell_sort(arr, sizeof(arr)/sizeof(int));
	printf("\n");
	for(j = 0; j < sizeof(arr)/sizeof(int); j++)
		printf("%d ",arr[j]);
}

五、快速排序

算法思想：快速排序（Quicksort）是对冒泡排序的一种改进。通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

#include<stdio.h>
void quick_sort(int data[], int low, int high) 
{
	int mid; 
	if(low < high) 
	{
		mid = partition(data, low, high); 
		quick_sort(data, low, mid-1); /* 递归调用 */
		quick_sort(data, mid+1, high);
	} 
}

int partition(int data[], int low, int high) 
{
	int tmp;
	while(low < high) 
	{
		while((low < high) && (data[high] >= data[low]))	//high-->low
			--high;
		if(low < high)
		{
			tmp = data[low];
			data[low] = data[high];
			data[high] = tmp;
			low++;
		}
	
		while((low < high) && (data[low] <= data[high]))	//low-->high
			++low;
		if(low < high)
		{
			tmp = data[low];
			data[low] = data[high];
			data[high] = tmp;
			high--;
		}  
	}  
	return low;     		
} 


int main()
{
	int i, j;
	int arr[] = {2,4,8,5,9,7,1,10,3,6};
	for(i = 0; i < sizeof(arr)/sizeof(int); i++)
		printf("%d ",arr[i]);
	quick_sort(arr, 0, sizeof(arr)/sizeof(int)-1);
	printf("\n");
	for(j = 0; j < sizeof(arr)/sizeof(int); j++)
		printf("%d ",arr[j]);
}