几种常见的排序（一）

1、冒泡排序：

冒泡排序是一种极其简单的排序算法，也是我所学的第一个排序算法。它重复地走访过要排序的元素，依次比较相邻两个元素，如果他们的顺序错误就把他们调换过来，直到没有元素再需要交换，排序完成。这个算法的名字由来是因为越小(或越大)的元素会经由交换慢慢“浮”到数列的顶端。

　　冒泡排序算法的运作如下：

  ①比较相邻的元素，如果前一个比后一个大，就把它们两个调换位置。

②对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

③针对所有的元素重复以上的步骤，除了最后一个。

④持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

程序如下：

#include <stdio.h>

void swap (int *a, int i, int j)
{
	int tmp;
	tmp = a[i];
	a[i] = a[j];
	a[j] = tmp;
}

void printfA (int *a, int len)
{
	int i;
	for (i = 0; i < len; i++)
	{
		printf ("%4d", a[i]);
	}
	printf ("\n");
}



int main()
{
	int a[] = {2,5,1,9,8,3,7,4,6,0};
	int len = sizeof(a)/sizeof(a[0]);
	int i,j;
	
	for (i = 0; i < len-1; i++)
	{
		for (j = 0; j < len-1-i; j++)
		{
			if (a[j] > a[j+1])
			{
				swap(a, j, j+1);
			}
		}
	}
		
	printfA (a, len);
	return 0;
}

2、鸡尾酒排序

   鸡尾酒排序，也叫定向冒泡排序，是冒泡排序的一种改进。此算法与冒泡排序的不同处在于从低到高然后从高到低，而冒泡排序则仅从低到高去比较序列里的每个元素。他可以得到比冒泡排序稍微好一点的效能。

程序如下：

#include <stdio.h>

void swap (int *a, int i, int j)
{
	int tmp;
	tmp = a[i];
	a[i] = a[j];
	a[j] = tmp;
}

void printfA (int *a, int len)
{
	int i;
	for (i = 0; i < len; i++)
	{
		printf ("%4d", a[i]);
	}
	printf ("\n");
}



//鸡尾酒排序
int main()
{
	int a[] = {2,5,1,9,8,3,7,4,6,0};
	int i;
	int len = sizeof(a)/sizeof(a[0]);
	int left = 0;
	int right = len-1;
	while (left < right)
	{
		for (i = left; i < right; i++)
		{
			if (a[i] > a[i+1])
			{
				swap (a, i, i+1);
			}
		}
		right--;
			
		for (i = right; i > left; i--)
		{
			if (a[i-1] > a[i])
			{
				swap (a, i, i-1);
			}	
		}
		left++;
	}
	
	printfA (a, len);
	return 0;
}

3、选择排序

   选择排序也是一种简单直观的排序算法。它的工作原理很容易理解：初始时在序列中找到最小（大）元素，放到序列的起始位置作为已排序序列；然后，再从剩余未排序元素中继续寻找最小（大）元素，放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
   注意选择排序与冒泡排序的区别：冒泡排序通过依次交换相邻两个顺序不合法的元素位置，从而将当前最小（大）元素放到合适的位置；而选择排序每遍历一次都记住了当前最小（大）元素的位置，最后仅需一次交换操作即可将其放到合适的位置。

程序如下：

#include <stdio.h>

void swap (int *a, int i, int j)
{
	int tmp;
	tmp = a[i];
	a[i] = a[j];
	a[j] = tmp;
}

void printfA (int *a, int len)
{
	int i;
	for (i = 0; i < len; i++)
	{
		printf ("%4d", a[i]);
	}
	printf ("\n");
}

int main()
{
	int a[10] = {2,5,1,9,8,3,7,4,6,0};
	int len = sizeof(a)/sizeof(a[0]);
	int i,j,min;
	for (i = 0; i < len-1; i++)
	{
		min = i;
		for (j = i+1; j < len; j++)
		{
			if (a[min] > a[j])
			{
				min = j;
			}
		}
		
		if (min != i)
		{
			swap (a, min, i);
		}
	}
	
	printfA (a, len);
	return 0;
}

4、插入排序

  插入排序是一种简单直观的排序算法。它的工作原理非常类似于我们抓扑克牌。

  对于未排序数据(右手抓到的牌)，在已排序序列(左手已经排好序的手牌)中从后向前扫描，找到相应位置并插入。

　 插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

　 具体算法描述如下：

①从第一个元素开始，该元素可以认为已经被排序

②取出下一个元素，在已经排序的元素序列中从后向前扫描

③如果该元素（已排序）大于新元素，将该元素移到下一位置

④重复步骤3，直到找到已排序的元素小于或者等于新元素的位置

⑤将新元素插入到该位置后

⑥重复步骤2~5步骤

　程序如下：

#include <stdio.h>

void swap (int *a, int i, int j)
{
	int tmp;
	tmp = a[i];
	a[i] = a[j];
	a[j] = tmp;
}

void printfA (int *a, int len)
{
	int i;
	for (i = 0; i < len; i++)
	{
		printf ("%4d", a[i]);
	}
	printf ("\n");
}

int main()
{
	int a[10] = {2,5,1,9,8,3,7,4,6,0};
	int len = sizeof(a)/sizeof(a[0]);
	int get; //抓牌
	int i,j;
	
	for (i = 1; i < len; i++)
	{
		get = a[i];  //抓牌
		j = i-1;
		
		while (j >= 0 && a[j] > get)
		{
			a[j+1] = a[j];
			j--;
		}
		a[j+1] = get;
	}
	
	printfA (a, len);
	return 0;
}

5、二分插入排序

  对于插入排序，如果比较操作的代价比交换操作大的话，可以采用二分查找法来减少比较操作的次数，我们称为二分插入排序，程序如下：

#include <stdio.h>

void swap (int *a, int i, int j)
{
	int tmp;
	tmp = a[i];
	a[i] = a[j];
	a[j] = tmp;
}

void printfA (int *a, int len)
{
	int i;
	for (i = 0; i < len; i++)
	{
		printf ("%4d", a[i]);
	}
	printf ("\n");
}

int main()
{
	int a[10] = {2,5,1,9,8,3,7,4,6,0};
	int len = sizeof(a)/sizeof(a[0]);
	int get; //抓牌
	int i,j;
	int left,right,mid;
	
	for (i = 1; i < len; i++)
	{
		get = a[i];  //抓牌
		left = 0;	//左边界
		right = i-1;	//右边界
		
		while (left <= right)
		{
			mid = (left + right)/2;
			if (a[mid] > get)
			{
				right = mid - 1;
			}
			else
			{
				left = mid + 1;
			}
		}	//找到插入位置
		
		//插入位置后数据移位
		for (j = i-1; j >= left; j--)
		{
			a[j+1] = a[j];
		}
		a[left] = get;
	}
	
	printfA (a, len);
	return 0;
}