数据结构之排序（一）

本次所介绍的排序分别是冒泡排序、简单选择排序、直接插入排序、二分插入排序、希尔排序

void swap(int a[],int i,int j)；//交换下标为i和j的两个元素的值

void printA(int a[],int len)；//打印数组

冒泡排序，每一轮，依次比较相邻元素，大的往后移，将最大的元素移到最后，直到最后排序完成，代码如下：

int a[] = {23,32,46,1,32,4,23,12,4,5};
int len = sizeof(a) / sizeof(a[0]);
int i,j;
int flag;
for (i = 0; i < len - 1;i++)
{
	flag = 0;
	for (j = 0;j < len - 1 - i;j++)
	{
		if (a[j] > a[j + 1])
		{
			swap(a,j,j + 1);
			flag = 1;
		}
	}
	if (flag == 0)
		break;
}
printA(a,len);

冒泡排序还有一个变化，叫鸡尾酒排序，原理是先冒泡找到最大的，再回头找到最小的。部分关键代码如下：

int left = 0;
int right = len - 1;
while (left < right)
{
	int i;
        flag = 0;
	for (i = left;i < right;i++)
	{
		if (b[i] > b[i + 1])
		{
                        flag = 1;
			swap(b,i,i+1);
		}
	}
	right--;
	for (i = right;i > left;i--)
	{
		if (b[i] < b [i-1])
		{
                        flag = 1;
			swap(b,i,i-1);
		}
	}
	left++;
        if (flag == 0)
	        break;
}

单选择排序思想是每次选出最小元素，放在待排序的最前列。相比冒泡排序减少了移动的次数，但没有减少比较的次数，在最好情况下，时间复杂度还要比冒泡排序高。关键代码如下：

for (i = 0;i < len - 1;i++)
{
	int min = i;
	for (j = i+1;j < len;j++)
	{
		if (a[min] > a[j])
		{
			min = j;
		}
	}
	if (min != i)
	{
		swap(a,i,min);
	}
}

直接插入排序认为当前元素前面的队列是有序的，找到当前元素应该插入的位置，将该元素插入。关键代码如下：

for (i = 1;i < len;i++)
{
	get = a[i];
	j = i - 1;
	while (j >= 0 && a[j] > get)
	//while (a[j] > get && j >= 0)   访问到了数组外
	{
		a[j+1] = a[j];
		j--;
	}
	a[j+1] = get;
}

二分插入排序是在直接插入排序的基础上，在找插入位置时，由于前面的序列已经有序，所以可以用二分查找法。关键代码如下：

for (i = 1;i < len;i++)
{
	get = a[i];
	left = 0;
	right = i - 1;
	while (left <= right)
	{
		mid = (left+right)/2;
		if (get > a[mid])
		{
			left = mid + 1;
		}
		else
		{
			right = mid - 1;
		}
	}
	for (j = i - 1;j >= left;j--)
	{
		a[j+1] = a[j];
	}
	a[left] = get;
}

希尔排序是插入排序的一个改进版本，也称为缩小增量排序，比直接插入排序算法更高效的。希尔排序是非稳定排序算法。希尔排序是把数组按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少至1时，整个数组被分成一组，完成排序。关键代码如下：

int d = len;
do
{
	d = d / 3 + 1;
	for (i = d;i < len;i++)
	{
		get = a[i];
		j = i - d;
		while (j >= 0 && a[j] > get)
		{
			a[j + d] = a[j];
			j -= d;
		}
		a[j + d] = get;
	}
}while (d > 1);

d也可以这样取得：

d = 0;
while (d < len)
{
	d = d * 3 + 1;
}
while (d >= 1)
{
	for (i = d;i < len;i++)
	{
		get = b[i];
		j = i - d;
		while (j >= 0 && b[j] > get)
		{
			b[j + d] = b[j];
			j -= d;
		}
		b[j + d] = get;
	}
	d = (d - 1) / 3;
}

有关排序的更多算法和代码实现，希望能与大家交流。