排序--2

希尔排序：

int main ()
{
	int a[10]= {9,8,7,6,5,4,3,2,1,55};
	int len =sizeof (a) / sizeof(a[0]);
	int get;
	int d = len;
	int i, j;
	
	
	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 = j -d;
				}
				a[j + d] = get;
			}
		
	}while(d > 1);
	
	printA (a, len);
	return 0;
	
}

希尔排序，先将一组数每个d分为一组，对其每一组进行快速排序，一=轮之后，改为d/3+1一组，同样进行快速排序。知道d为一，便是快速排序，此时，所有数都是有序的。我觉得，这种方法在对于随机d分组中已经有序的数可以不用排序，相对于快速排序是一种改进，因为，他不用每次都比较。

堆排序：

void heapify(int *a, int i, int len)
{
	int left  = 2 * i + 1;             //左孩子
	int right = 2 * i + 2;              //右孩子
	int max = i;                      //先把根节点赋值到max中;
	
	
	if ( left < len && a[max] < a[left])
		max = left;
	if ( right < len && a[max] < a[right] )
		max = right;
	
	
	if (max != i)
	{
		swap (a, i, max);
		heapify (a, max,len);
	}
	
}


void heapsort (int *a, int len)
{
	int i;
	for (i = len - 1; i > 0; i--)
	{
		swap (a, 0,i);
		len --;
		heapify (a, 0 ,len);
		
	}
}

int main ()
{
	int a[10]= {9,8,7,6,5,4,3,2,1,0};
	int len =sizeof (a) / sizeof(a[0]);
	int i;
	for (i = len / 2 -1; i >= 0; i--)    //建堆
	{
		heapify(a, i,len);
	
	}
	heapsort (a,len);
	
	
	printA (a,len);
	
	
	return 0;
}

这种方法可以当做将数组中的数，放置在一个二叉树数中，利用heapify调整三个节点之内的大小，这样可以将最大或者最小的数放置在根节点，将根节点与最后一个节点交换，并删去最后一个节点，便可以得到最大数或者最小数，删除体现在len- -将数组长度减一，这样，最后一个值便可以定下来。这种排序的思想可以用于随机生成随机数，随机生成0-40，每四个一组。

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
void swap (int *a,int i, int j)
{
	int tmp = a[i];
	a[i] = a[j];
	a[j] = tmp;
}


int main ()
{
	srand ((unsigned int)time(NULL));
	int i;
	int a[40] = {0};
	int m;
	int len = 40;
//	printf ("1111");
	for (i = 0; i < len; i++)
	{
		a[i] = i;
		printf ("%d\n",a[i]);
	}
	for (i = len - 1; i >=0; i--)
	{
		m = rand()% (i + 1);     //产生的随机数都在变小
		swap (a, m, i);
		printf ("%4d", a[i]);    //i的值每次都在减少
		if (i % 4 == 0 )
		{
			printf ("\n");
			
		}
	
	}
	
	printf ("\n");
	return 0;

}

产生的思想在，每次随机一个0-40的下标，与最后一个数的值交换。