C++实现常见排序算法

本程序参考了网上各位大牛和数据结构中的程序，VS2005运行通过，如有问题，请各位大牛指正。

实现的排序有：直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、选择排序、堆排序等等

#include <iostream>
using namespace std;
const int len = 100;
class CSort
{
public:
	CSort();
	~CSort();
	virtual void sort()=0;
	void swap(int& a,int& b);
	friend ostream& operator<<(ostream &cout,const CSort& csort);
protected:
	int* arr;
	int length;
};

CSort::CSort():length(len)
{
	arr = new int[length];
	for (int i=0;i<length;i++)
	{
		arr[i]=rand()%1000;
	}
}

CSort::~CSort()
{
	delete[]arr;
}

void CSort::swap(int& a,int& b)
{
	int temp = a;
	a=b;
	b=temp;
}

ostream& operator<<(ostream& cout,const CSort& csort)
{
	for (int i=0;i<csort.length;i++)
	{
		cout<<csort.arr[i]<<" ";
	}
	cout<<endl;
	return cout;
}
/*
插入排序思想：将一个记录插入到已经排好的有序表中，从而得到一个新的、记录增1的有序表，直到将所有待排记录全部插入为止
*/

class CInsertSort : public CSort
{
public:
	void sort();
};

//直接插入排序--小 到 大
void CInsertSort::sort()
{
	int i,j;
	int key;//存放乱序的元素
	for ( i=1;i<length;i++)
	{
		if (arr[i-1]>arr[i])
		{
			key=arr[i];
			for ( j=i-1;j>=0 && arr[j]>key;j--)
			{
				arr[j+1]=arr[j];				
			}
			arr[j+1]=key;
		}
	}
}

class BInsertSort : public CSort
{
public:
	void sort();

};
void BInsertSort::sort()
{
	for (int i=1;i<length;i++)
	{
		//先找到要插入的位置
		int low = 0;
		int high = i-1;
		while(high>=low)
		{
			int mid = (low+high)/2;
			if (arr[i]>arr[mid])
			{
				low=mid+1;
			}
			else
			{
				high=mid-1;
			}
		}
		//找到应该插入的位置high+1,之后移位置
		int key = arr[i];
		for (int j=i-1;j>=high+1;j--)
		{
			arr[j+1]=arr[j];
		}
		//已经找到位置，把要排序的数放入其中
		arr[high+1]=key;
	}
}

class CShellInsert : public CSort
{
public:
	void sort();
private:
	void ShellInsert(int dk);
};

void CShellInsert::sort()//调用希尔排序
{
	int dlta[3]={5,3,1};//设置希尔排序的增量，调用希尔排序函数
	for (int i=0;i<3;i++)
	{
		ShellInsert(dlta[i]);
	}
}

void CShellInsert::ShellInsert(int dk)//希尔排序函数,把直接插入排序中的1变成dk就好，直接插入排序中增量为1
{
	int i,j;
	int key;//存放乱序的元素
	for (i=dk;i<length;i++)
	{
		if (arr[i-dk]>arr[i])
		{
			key=arr[i];
			for (j=i-dk;j>=0 && arr[j]>key;j=j-dk)
			{
				arr[j+dk]=arr[j];				
			}
			arr[j+dk]=key;
		}
	}
}

/*气泡排序*/
class BubbleSort:public CSort
{
public:
	void sort();
};

void BubbleSort::sort()
{
	bool change = true;//表示第i个位置的元素在确定位置时，是不是有换位置。true表示，下面的数据还没拍好。没有的话，说明下面元素已经排好，不用在继续下去
	for (int i=0;i<length-1 && change;i++) 
	{
		change = false;//先设置已经拍好
		for (int j=0;j<length-1-i;j++)
		{
			if (arr[j]>arr[j+1])
			{
				change = true;//需要调换位置
				swap(arr[j],arr[j+1]);
			}
		}
	}
}

/*快速排序*/
class CQuickSort:public CSort
{
public:
	void sort();
private:
	int Partition(int low,int high);
	void QuickSort(int low,int high);
};

void CQuickSort::sort()
{
	QuickSort(0,len-1);
}

int CQuickSort::Partition(int low,int high)
{
	int key=arr[low];//先挖第一个洞
	while(low<high)
	{
		while(low<high && arr[high]>=key)//此时，low位置待放元素：比较时，比枢轴元素大，位置不变
			high--;
		arr[low]=arr[high];//见到第一个比枢轴元素小的，应该把这个元素放到洞（左边）中。
		while(low<high && arr[low]<=key)//这时，应该从另一侧进行检测，high待放元素，比较时，比枢轴元素小，位置不变
			low++;
		arr[high] = arr[low];//见到第一个比枢轴元素大的，应该把这个元素放到洞中（右边）
	}
	arr[low]=key;//这时第一个洞的元素应该是在low处
	return low;//返回这次划分的位置
}

void CQuickSort::QuickSort(int low,int high)
{
	if (low<high)
	{
		int keyloc = Partition(low,high);//在keyloc的元素已经找到正确的位置了
		QuickSort(low,keyloc-1);//分别对之后低子表进行快排
		QuickSort(keyloc+1,high);//分别对之后高子表进行快排
	}
}

class CSelectionSort:public CSort
{
public:
	void sort();
};


void CSelectionSort::sort()
{
	for (int i=0;i<length-1;i++)
	{
		int k = i;
		for (int j=i+1;j<length;j++)
		{
			if (arr[j]<arr[k])//要求的序列是由小到大，这里k应该记得是小值，if条件成立时，记的就为大值
			{
				k=j;
			}
		}
		if (k!=i)
		{
			swap(arr[i],arr[k]);
		}
	}
}

class CHeapSort:public CSort
{
public:
	void sort();
private:
	void HeapSort();
	void HeapAdjust(int s,int m);
};

void CHeapSort::sort()
{
	HeapSort();
}

/*
堆排序：
初始数据：存储在数组arr中
建立初始堆排序时，
首先把无序序列看成一个完全二叉树：处在0号元素的为根，12号为左右子树之后一次化成完全二叉树的形式画树
调整初始堆时，应该从最后一个非叶子节点开始调整
在建立初始堆后，再进行调整堆，输出序列
首先是堆顶元素(总是数组的第一个元素)和最后一个未排好的元素交换(一直在变化)，之后进行调整堆就好
调整堆时，总是自上而下的调整。即使是在建堆的时候也是这样的。
注意：建初始堆和排序时的调整堆都需调用调堆函数HeapAdjust，两种的不同之处在于调换元素和顺序不同
*/
void CHeapSort::HeapSort()//堆排序
{
	for (int i=length/2-1;i>=0;i--)//建堆,相当于从序号m-0的非叶子结点开始调整
	{
		HeapAdjust(i,length);
	}
	for (int j=length-1;j>0;j--)
	{
		swap(arr[0],arr[j]);//调整堆后，第一个元素总是存放着最大的元素(由小到大排序的)，让其给最后一个元素j交换
		HeapAdjust(0,j);
	}
}

//要从小到大排序：建立大根堆，把顶端元素(数组中第一个元素)和数组中 最后一个未排 元素交换

//s表示调换的位置，m表示未排好序列的个数
void CHeapSort::HeapAdjust(int s,int m)//调整推,变成大根堆
{
	int key =arr[s];//先把要调整的元素取出来,传过来的
	//之后对非终结点进行调整
	for (int i=2*s+1;i<m;i=2*i+1)
	{
		if (i<m-1 && arr[i] < arr[i+1])//先让要调整元素的两个孩子进行调整,其中i下标保存最大的值 i<m-1:保证其有左右孩子时，才进行左右孩子的比较
		{
			i++;
		}
		if (key > arr[i])//这时，根保存着最大值，不用调整(建立大根堆)
		{
			break;
		}
		arr[s]=arr[i];
		s=i;//这时，s应该指向刚刚调过去的位置，因为，在调整时，总是从上而下进行的，要从他的左孩子开始
	}
	arr[s]=key;
}

/*归并排序*/
class CMergingSort:public CSort
{
public:
	void sort();
private:
	void MergeSort(int left,int right);
	void Merge(int left,int mid,int right);
};
void CMergingSort::sort()
{
	MergeSort(0,length-1);
}

void CMergingSort::MergeSort(int left,int right)
{
	if (left<right)
	{
		int mid = (left+right)/2;
		MergeSort(left,mid);
		MergeSort(mid+1,right);
		Merge(left,mid,right);		
	}
}

void CMergingSort::Merge(int left,int mid,int right)
{
	int* temp = new int[right - left + 1];
	int i=left;
	int j=mid+1;
	int k=0;
	while(i<=mid && j<=right)
	{
		if (arr[i]>arr[j])
		{
			temp[k++]=arr[j++];
		}
		else
		{
			temp[k++]=arr[i++];
		}
	}
	while(i<=mid)
	{
		temp[k++]=arr[i++];
	}
	while(j<=right)
	{
		temp[k++]=arr[j++];
	}
	for (i=0,k=left;k<=right;k++,i++)//归并后的数组对应的原来的数组是 left--right 那段，因此还要把这段数据放到原数组中
	{
		arr[k]=temp[i];
	}
	delete []temp;
}

int main()
{
	CSort *pCsort;//执行这条代码时，是不调用类CSort的构造函数的
	//pCsort = new CInsertSort();//直接插入排序
	//pCsort = new BInsertSort();//测试折半插入
	//pCsort = new CShellInsert();//测试希尔排序
	//pCsort = new BubbleSort();//冒泡排序
	//pCsort = new CQuickSort();//快速排序
	//pCsort = new CSelectionSort();//选择排序
	pCsort = new CMergingSort();//堆排序
	
	cout<<"排序前："<<endl;
	cout<<*pCsort<<endl;

	pCsort->sort();//排序

	cout<<"排序后："<<endl;
	cout<<*pCsort<<endl;

	//pCsort = new CMergingSort();//归并排序
	system("pause");
	return 1;
}