各种排序算法

//最经典的冒泡法
//给出一种排序方式--从小到大
#include <iostream>
using namespace std;
//定义响应的排序结构体
#define MAX_SIZE  10//默认的数组大小
class SqListOrder
{
private:
	int data[MAX_SIZE+1];// 用于存储排序数组，data[0]用作哨兵或临时变量
	int length;//表示目前数组的长度
public:
	SqListOrder();//构造函数
	//~SqListOrder();//析构函数
	int InputData();//放入待排序的数据
	int PrintData();//打印数据
	int swap(int i,int j);//交换下标为i,j的数据
	int BubbleSort0();//简单的排序算法
	int BubbleSort();//经典的冒泡算法
	int BubbleSort1();//改进的冒泡算法
	int SelectSort();//简单选择排序
	int InsertSort();//插入排序
};
//构造函数
SqListOrder::SqListOrder()
{
	length=0;
}
//输入数据
int SqListOrder::InputData()//放入待排序的数据
{
	int n;
	cout<<"请输入待排序的数据(-1作为停止符)："<<endl;
	cin>>n;
	while(-1!=n&&length<MAX_SIZE)
	{
		data[++length]=n;
		cin>>n;
	}
	return 0;
}
//打印数据
int SqListOrder::PrintData()
{
	for (int i=1;i<=length;i++)
	{
		cout<<"  "<<data[i];
	}
	cout<<endl;
	return 0;
}

//若大小位置相反，交换两数据
int SqListOrder::swap(int i,int j)
{
	//先判断数据长度，下标是否合法
	if (length>MAX_SIZE||i>length||j>length)
	{
		cout<<"输入的数据量过大或者下标越界！"<<endl;
		return 1;
	}
	int temp=data[i];
	data[i]=data[j];
	data[j]=temp;
	return 0;
}

int SqListOrder::BubbleSort0()
{
	for (int i=1;i<length;i++)
	{
		for (int j=i+1;j<=length;j++)
		{
			if (data[i]>data[j])
			{
				swap(i,j);
			}
		}
	}
	return 0;
}
//经典的冒泡算法
int SqListOrder::BubbleSort()
{
	for (int i=1;i<length;i++)
	{
		for (int j=length-1;j>=i;j--)
		{
			if (data[j]>data[j+1])
			{
				swap(j,j+1);
			}
		}
	}
	return 0;
}
//改进的冒泡算法
int SqListOrder::BubbleSort1()
{
	int flag=0;//0表示未排好序，1比表示已排好序
	for (int i=1;i<length&&0==flag;i++)
	{
		flag=0;
		for (int j=length-1;j>=i;j--)
		{
			if (data[j]>data[j+1])
			{
				swap(j,j+1);
				flag=0;
			}
		}
	}
	return 0;
}
//简单选择排序算法
int SqListOrder::SelectSort()
{
	for (int i=1;i<length;i++)
	{
		int min=i;//存储当前位置数据最小的下标
		for (int j=i+1;j<=length;j++)
		{
			if (data[min]>data[j])
			{
				min=j;
			}
		}
		if (min!=i)
		{
			swap(min,i);
		}
	}
	return 0;
}
//插入排序
//data[0]存储待插入的元素
int SqListOrder::InsertSort()
{
	int i,j;
	for (i=1;i<length;i++)
	{
		//待插入元素比前一个元素小
		if (data[i+1]<data[i])
		{
			data[0]=data[i+1];//存储待插入的元素
			//*****寻找比待插入元素小的第一个元素,并移位
			for (j=i;data[j]>data[0];j--)
			{
				data[j+1]=data[j];
			}
			data[j+1]=data[0];
		}
	}
	return 0;
}
int main()
{
	SqListOrder a;
	a.InputData();
	cout<<"排序前的数据："<<endl;
	a.PrintData();

	/*a.BubbleSort0();
	cout<<"容易理解的冒泡排序后的数据："<<endl;
	a.PrintData();
	return 0;*/

	/*a.BubbleSort();
	cout<<"经典冒泡排序后的数据："<<endl;
	a.PrintData();
	return 0;*/

	/*a.BubbleSort1();
	cout<<"改进的冒泡排序后的数据："<<endl;
	a.PrintData();
	return 0;*/

	/*a.SelectSort();
	cout<<"简单选择排序后的数据："<<endl;
	a.PrintData();
	return 0;*/

	a.InsertSort();
	cout<<"插入排序后的数据："<<endl;
	a.PrintData();
	return 0;
}

希尔排序：插入排序的某种改进

//希尔排序
int SqListOrder::ShellSort()
{
	int i,j;
	int increment=length;
	do 
	{
		increment=increment/2;
		for (i=increment+1;i<=length;i++)
		{
			if (data[i]<data[i-increment])
			{
				data[0]=data[i];//存储待插入的元素
				for (j=i-increment;j>0&&data[j]>data[0];j-=increment)
				{
					data[j+increment]=data[j];//记录后移，查找待插入位置
				}
				data[j+increment]=data[0];//插入元素
			}
		}
	} while (increment>1);
	return 0;
}

堆排法，大顶堆，这种方法是自己写的，构造的不完全的大顶堆，书本书构造的是标准意义上的大顶堆，料率似乎更高一些。

//堆排法
int SqListOrder::HeapSort()
{
	int i;
	for (i=length;i>=2;i--)
	{
		 HeapOrder(i);
		 swap(1,i);
	}
	return 0;
}
//对前n个数据建立大顶堆
int SqListOrder::HeapOrder(int n)
{
	int i;
	i=n/2;
	int temp=(data[2*i],data[n])?data[2*i]:data[n];
	if (temp>data[i])
	{
		if(data[2*i]>data[n])
			swap(i,2*i);
		else
			swap(i,n);
	}
	for (i=n/2-1;i>=1;i--)
	{
		temp=(data[2*i],data[2*i+1])?data[2*i]:data[2*i+1];
		if (temp>data[i])
		{
			if(data[2*i]>data[2*i+1])
				swap(i,2*i);
			else
				swap(i,2*i+1);
		}
	}
	return 0;
}

课本上构造构造的大顶堆，对应的堆排算法。