排序算法要点

第一篇： 堆排序

二叉堆满足二个特性：
1)．父结点的键值总是大于或等于（小于或等于）任何一个子节点的键值。
2)．每个结点的左子树和右子树都是一个二叉堆（都是最大堆或最小堆）。

堆排序的三个要点
从小到大排序，要先建立最大堆。
以构建最大堆为例

1.堆调整
以待排序节点开始，遍历子节点，把两个子节点值比较大的子节点向上移动。
两个子节点都比该节点小，说明不用在调节了。注意，要保证这个步骤成立，本次堆调整时，子节点都是二叉堆。
当然了，叶子节点一定是二叉堆(因为没有子节点)。
还要注意一点是，一次调节交换可能会破坏子节点的有序性，所以每次调节都要调整到二叉树叶节点位置（当然，也可以是两个子节点都比该节点小时）。

2.构建堆
构建堆就是构建一个根节点位置开始的二叉堆。所以要先保证它的子节点也是二叉堆。
void MakeMinHeap(int a[], int n) 
{ 
 for (int i = n / 2; i > 0; i--) 
  MinHeapFixdown(a, i, n); 
}
注意，构建的二叉堆的数组元素还不是排好顺序的，因为不能保证左子树和右子树的顺序。

3.二叉堆排序
二叉堆的根节点一定是最大的，将它换到数组末尾不再移动，将数据末尾的节点换到根节点，重新调整二叉堆。
重复这个过程，直到数据全部移动到二叉堆的后面。
for (int i = n; i > 1; i--) 
{ 
 swap(a[1], a[i]); 
 MinHeapFixdown(a, 1, i-1); 
}

 

第二篇、归并排序

1. 合并相邻子数组

需要注意的问题，当两个数组长度不一样时的情况。
事先分配临时数组，将排序结果缓存，然后每次合并数组后，再保存回原来的数组。
也可以，将临时数组和原数组每次排列交替做输入数组和结果缓存数组(一趟完整归并一次交换)，避免copy。

2.归并方式

递归方式：

void mergesort(int a[], int first, int last) 
{ 
    if (first < last) 
    { 
        int mid = (first + last) / 2; 
        mergesort(a, first, mid);    //左半边排序
        mergesort(a, mid + 1, last); //右半边排序 
        mergearray(a, first, mid, last); //左右两个有序序列合并 
    } 
}

非递归方式：

1）. 一趟归并排序
将整个数组每seg长度分一段，每一段都进行排序，保证有序。

2）. 归并排序
有序子数组从下到上的顺序进行合并。
分段长度seg由1逐渐增长到数组长度，排序完成。

源码

int Merge(int data[],int res[], int low, int mid, int high)
{
	int i, j, k;   

	i = low;
	j = mid+1;
	k = low;

	while(i<=mid && j<=high) 
	{   
		if(data[i] <= data[j])   
			res[k++] = data[i++];   
		else   
			res[k++] = data[j++];   
	}   

	for(; i<=mid; i++)   
		res[k++] = data[i];   
	for(; j<=high; j++) 
		res[k++] = data[j];

	return k-low;
}

void mergeSort(int *data,int* res, int first, int last )   
{     
	if(first < last)     
	{   
		int mid = (first+last)/2;     
		mergeSort(data,res, first, mid);		//使左边有序   
		mergeSort(data,res, mid+1, last);		//使右边有序   
		int len = Merge(data,res, first, mid, last); //合并数组
		for ( int i = 0; i < len ; i++ )
		{
			data[first+i] = res[first+i];
		}
	}   
}   

void mergeSort(int *data, int len )   
{   
	int* temp = new int[len];
	mergeSort( data,temp, 0, len - 1 );
 	delete[] temp;
 	temp = NULL;
} 
//----------------------------------------------------------------------------------------

void MergePass(int data[], int res[], int seg, int size)
{
	int seg_start = 0;
	while(seg_start <= size - 2 * seg) //seg为每段长度，将整个数组划分
	{
		Merge(data, res, seg_start, seg_start + seg - 1, seg_start + seg * 2 - 1 );
		seg_start += 2 * seg;
	}
	//剩下大于一段小于两段的数据
	if(seg_start + seg < size)
		Merge(data, res, seg_start, seg_start + seg - 1, size - 1 );
	else
		for(int j = seg_start; j < size; j++) //只剩下小于等于一段数据
			res[j] = data[j];
}

void MergeSort(int a[], int size)
{
	int* temp = new int[size];
	int seg = 1;
	while(seg < size)
	{
		MergePass(a, temp, seg, size);
		seg += seg;
		MergePass(temp, a, seg, size);
		seg += seg;
// 四路归并了～
// 		MergePass(a, temp, seg, size);
// 		seg += seg;
// 		MergePass(temp, a, seg, size);
// 		seg += seg;
	}
	delete [] temp;
	temp = NULL;
}
//----------------------------------------------------------------------------------------
int main()       
{       
	int a[]={50,10,20,30,70,40,80,60};   
	//int a[] = {3, 5, 3, 6, 4, 7, 5, 7, 4};

	MergeSort(a, sizeof(a) / sizeof(*a));          

	for(int i=0; i<sizeof(a) / sizeof(*a); ++i)       
		cout<<a[i]<<" ";       
	cout<<endl;       
	
	mergeSort(a, sizeof(a) / sizeof(*a));       

	for(int i=0; i<sizeof(a) / sizeof(*a); ++i)       
		cout<<a[i]<<" ";       
	cout<<endl;

	system("pause");       
	return 0;       
}