九度笔记之 1202排序

题目1202：排序

时间限制：1 秒

内存限制：32 兆

特殊判题：否

提交：2313

解决：998

题目描述：

    对输入的n个数进行排序并输出。

输入：

    输入的第一行包括一个整数n(1<=n<=100)。
    接下来的一行包括n个整数。

输出：

    可能有多组测试数据，对于每组数据，将排序后的n个整数输出，每个数后面都有一个空格。
    每组测试数据的结果占一行。

样例输入：

4
1 4 3 2

样例输出：

1 2 3 4 

算法分析

利用堆排序

或者快速排序

源程序

快速排序

partion的两种实现

第一种是i从左到右移动，j从又到左移动，如果a[i]> v,a[j]<v 就交换值

第二种是算法导论上的师兄，i,j同时从左到右移动

#include <iostream>
using namespace std;
int num[100]={0};

void exchange(int &a,int &b){

	int tem = a;
	a = b;
	b = tem;
	/*
	a = a^b;
	b = a^b;
	a = a^b;
	*/
}
int partion(int b,int e){
	int i = b+1;
	int j = e;
	while(i<j){
		while(num[i]<num[b] && i<j)
			i++;
		while(num[j]>num[b]&& j>i)
			j--;
		if(i<j){
			exchange(num[i],num[j]);
		}
	}
	exchange(num[i-1],num[b]);
	return i-1;

}

int partionnew(int b,int e){//  the introduction to algorithm
	//int value = num[e];
	int i = b-1;
	int j = b;
	while(j<e){
		if(num[j]<num[e]){
			i++;
			exchange(num[j],num[i]);
		}
		j++;
	}
	exchange(num[i+1],num[e]);
	return i+1;
}

void qSort(int b,int e){
	if(b<e){
		int m = partionnew(b,e);
		qSort(b,m-1);
		qSort(m+1,e);
	}
}
void judo(){
	int n;
	while(std::cin>>n){
		for(int i = 0;i<n;i++)
			std::cin>>num[i];
		qSort(0,n-1);
		for(int i = 0;i<n;i++)
			std::cout<<num[i]<<" ";
		std::cout<<std::endl;
	}
}
int main() {
	//cout << "!!!Hello World!!!" << endl; // prints !!!Hello World!!!
	judo();
	return 0;
}

堆排序

构建堆也有两种实现，通过inserMinHeap实现堆的构建，或者通过modify实现堆的构建（算法导论）

在Modify函数中 需要查找左右子树是否存在，以及最小的子节点，有个很技巧性方法

		cid = i;                  //useful
		if(num[2*i]<value)
			cid = 2*i;
		if(2*i+1 <=heapSize && num[2*i+1]<num[cid])// well solution
			cid = 2*i+1;
		if(cid==i)
			break;

设置cid,初始化为当前点i, cid在每个判断中表示最小值的节点id.

如果最后cid==i 说明当前点比子节点都小，就不用再往下查找了。

#include <iostream>
using namespace std;
int num[101] = {0};
int heapSize = 0;
void insertMinHeap(int value){
	int i = heapSize+1;
	while(i>1 && num[i>>1]>value){
		num[i] = num[i>>1];
		i = i>>1;
	}
	num[i] = value;
	heapSize++;
}

void modifyMinHeap(int i){
	int value = num[i];
	int cid = 0;
	while(2*i<= heapSize){
		cid = i;                  //useful
		if(num[2*i]<value)
			cid = 2*i;
		if(2*i+1 <=heapSize && num[2*i+1]<num[cid])// well solution
			cid = 2*i+1;
		if(cid==i)
			break;
		num[i]=num[cid];
		num[cid]=value;
	}
}


void buildMinHeap(int n){
	for(int i = 1;i<101;i++){
		num[i] = 0;
		heapSize=0;
	}

	int value = 0;
	for(int i = 0;i<n;i++){
		std::cin>>value;
		insertMinHeap(value);
	}

}
void buildMinHeapUseModify(int n){
	for(int i = 1;i<n+1;i++)
		std::cin>>num[i];
	heapSize = n;
	for(int i = n>>1; i>0 ;i--){
		modifyMinHeap(i);
	}

}
void heapSort(){
	int n = heapSize;
	for(int i = 1;i<=n;i++){
		std::cout<<num[1]<<" ";
		num[1]=num[heapSize];
		heapSize--;
		modifyMinHeap(1);
	}
	std::cout<<std::endl;
}

void judo(){
	int n = 0;
	while(std::cin>>n){
		buildMinHeapUseModify(n);
		heapSort();
	}
}
int main() {
	//cout << "!!!Hello World!!!" << endl; // prints !!!Hello World!!!
	judo();
	return 0;
}