菜鸟的奋斗——从排序开始走进程序的世界

今天就写个归并排序吧，简单的功能，实现整数排序，没有苛刻的测试用例。表示博客今天开张了

陆陆续续的编写，并参考了shan9liang的文章（http://blog.csdn.net/shan9liang/article/details/7533466）

#include "iostream"
using namespace std;

#define MAX 2147483647
void merge(int vec[],int low,int mid,int high) {
	int n1 = mid -low +1;
	int n2 = high - mid;
	int* a = new int[n1+1];
	int* b = new int[n2+1];
	int i,j;
	for(i=0;i<n1;i++)
		a[i] = vec[low+i];
	for(j=0;j<n2;j++)
		b[j] = vec[mid+j+1];
	a[n1] = MAX;
	b[n2] = MAX;
	i = 0;
	j = 0;
	for(int k=low;k<=high;k++) {
		if(a[i]<b[j]) {
			vec[k] = a[i];
			i++;
		}
		else {
			vec[k] = b[j];
			j++;
		}
	}
}
void MergeSort(int vec[], int low,int high) {
	if(low < high) {
		int mid = (high +low)/2;
		MergeSort(vec,low,mid);
		MergeSort(vec,mid+1,high);
		merge(vec,low,mid,high);
	}
}
int main() {
	int vec[] = {1,3,5,2,4,6};
	MergeSort(vec,0,5);
	for(int i=0;i<6;i++) 
		cout<<vec[i]<<' ';
	return 0;
}

关于排序的大体分类如下图所示：

 

冒泡排序

（1）基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

（2）实例：

#include "iostream"
using namespace std;

void BubbleSort(int vec[],int n) {
	bool Flag = true;
	for(int i=n-1; i>=1  && Flag; i--) {
		Flag = false;
		for(int j=0;j<i;j++) {
			if(vec[j]>vec[j+1]) {
				Flag = true;
				vec[j] = vec[j] ^ vec[j+1];
				vec[j+1] = vec[j+1] ^ vec[j];
				vec[j] = vec[j] ^ vec[j+1];
			}
		}
	}
}
int main() {
	int a[] = {6,12,5,3,4,18};
	BubbleSort(a,6);
	for(int i=0;i<=5;i++)
		cout<<a[i]<<' ';
	cout<<endl;
	return 0;
}

简单选择排序
（1）基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；

然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。

（2）实例：

#include <iostream>
using namespace std;

void SelectSort(int vec[],int n) {
	for(int i=0; i<n-1; i++)
		for(int j=i+1; j<n;j++)
			if(vec[i] > vec[j]) {
				vec[i] = vec[i] ^ vec[j];
				vec[j] = vec[j] ^ vec[i];
				vec[i] = vec[i] ^ vec[j];
			}
}
void Print(int vec[], int n) {
	for(int i=0; i<n; i++)
		cout<< vec[i]<<' ';
	cout<<endl;
}

int main() {
	int a[] = {12,4,5,8,21,1,3};
	Print(a,7);
	SelectSort(a,7);
	Print(a,7);
	system("pause");
	return 0;

}

上述代码中可以发现，只要出现逆置的情况就会发生一次交换，这样的作法效率是很低的，因此可以首先检测出最小值的下标，最后进行交换。

void SelectSort(int vec[],int n) {  
    for(int i=0; i<n-1; i++) { \
		int Min = i;
        for(int j=i+1; j<n;j++)
			if(vec[Min] > vec[j]) 
				Min = j;
		if(Min != i){
                vec[i] = vec[i] ^ vec[Min];  
                vec[Min] = vec[Min] ^ vec[i];  
                vec[i] = vec[i] ^ vec[Min];  
		}
			
	}
}  

 

直接插入排序

（一直对插入排序的印象极为深刻，因为在读《算法导论》的开篇就是用摸扑克牌的方法介绍插入排序，自认为很经典，举例也极为恰当）

（1）基本思想：在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排

好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数

也是排好顺序的。如此反复循环，直到全部排好顺序。

（2）实例

#include <iostream>
using namespace std;

void InsertSort(int vec[],int n) {
	for(int i=1; i<=n-1; i++) {
		int temp = vec[i];//摸到一张扑克牌
		int j = i-1;
		while(j>=0 && vec[j]>temp) {//寻找插入位置
				vec[j+1] = vec[j];
				j--;
			}
		vec[j+1] = temp;//插入扑克牌
	}
}
void Print(int vec[], int n) {
	for(int i=0; i<n; i++)
		cout<< vec[i]<<' ';
	cout<<endl;
}

int main() {
	int a[] = {12,4,5,8,21,1,3};
	Print(a,7);
	InsertSort(a,7);
	Print(a,7);
	system("pause");
	return 0;

}

快速排序
基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。

#include <iostream>  
using namespace std;  

int QuickPartation(int vec[], int low, int high) {
	if(low < high) {
		int i = low - 1;
		int temp = vec[high];
		for(int j=low; j<=high-1; j++) {
			if(vec[j] <= temp) {
				i = i + 1;
				int m = vec[i];
				vec[i] = vec[j];
				vec[j] = m;
			}
		}
		vec[high] = vec[i+1];
		vec[i+1] = temp;
		return i+1;
	}
}
  
void QuickSort(int vec[], int low, int high) {
	if(low < high) {
		int mid = QuickPartation(vec,low,high);
		QuickSort(vec,low,mid-1);
		QuickSort(vec,mid+1, high);
	}
}

void Print(int vec[], int n) {
	for(int i=0; i<n; i++)
		cout<<vec[i]<<' ';
	cout<<endl;
}
int main() {  
    int a[] = {12,4,5,8,21,1,13};  
    Print(a,7);  
    QuickSort(a,0,6);  
    Print(a,7);  
    system("pause");  
    return 0;  
  
}