排序——若干排序算法

该篇文章主要介绍若干排序算法。

源文件：All_SortAlgorithm.h

#ifndef ALL_SORTALGORITHM_H_
#define ALL_SORTALGORITHM_H_
#include<iostream>
using namespace std;
template<typename T>
class MyClass
{
	T *data;
	int length;
public:
	MyClass()
	{
		data = NULL;
		length = 0;
	}
	~MyClass()
	{
		delete data;
	}
	void CreateArray(T arr[], int n);
	void Disp(void);
	void DirectInsertSort(void);//简单直接插入排序
	void BInaryInsertSort(void);//折半插入排序
	void ShellSort(void);//希尔排序

	void BubleSort(void);//冒泡排序
	void QuickSort(void);//快速排序
	void QuickSort1(int begin, int end);//由QuickSort调用

	void SelectSort(void);//选择法排序
	void Sift(int low, int high);//堆调整算法
	void HeapSort(void);//堆排序

	void Merge2(int low, int mid, int high);
	void MergePass2(int len);
	void MergeSort2(void);//归并排序
};
template<typename T>
void MyClass<T>::CreateArray(T arr[],int n)
{
	length = n;
	data = new int[length];
	for (int i = 0; i < length; i++)
	{
		data[i] = arr[i];
	}
}
template<typename T>
void MyClass<T>::Disp(void)
{
	for (int i = 0; i < length; i++)
		cout << data[i] << " ";
	cout << endl;
}
template<typename T>
void MyClass<T>::DirectInsertSort(void)
{
	for (int i = 0; i < length - 1; i++)
	{
		T temp = data[i + 1];
		int j;
		for (j = i; j >=0; j--)
		{
			if (data[j]>temp)
			{
				data[j + 1] = data[j];
			}
			else
			{
				break;
			}
		}
		data[j+1] = temp;
	}
}
template<typename T>
void MyClass<T>::BInaryInsertSort(void)
{
	for (int i = 0; i < length-1; i++)
	{
		if (data[i + 1]<data[i])
		{
			int s = 0;
			int t = i;
			T temp = data[i + 1];
			while (s <= t)
			{
				int mid = (s + t) / 2;
				if (data[mid]>temp)
					t = mid - 1;
				else
					s = mid+1;
			}
			for (int j = i; j >= s; j--)
			{
				data[j + 1] = data[j];
			}
			data[s] = temp;
		}
	}
}
template<typename T>
void MyClass<T>::ShellSort(void)
{
	int d = length / 2;
	while (d>0)
	{
		for (int j = d; j < length; j++)
		{
			T temp = data[j];
			int k=j-d;
			for (; k >= 0; k = k - d)
			{
				if (temp < data[k])
				{
					data[k + d] = data[k];
				}
				else
				{
					break;
				}
			}
			data[k + d] = temp;
		}
		d = d / 2;
	}
}

template<typename T>
void MyClass<T>::BubleSort(void)
{
	for (int i = 0; i < length - 1; i++)
	{
		bool flag = false;
		for (int j =0; j < length-i-1; j++)
		{
			if (data[j]>data[j + 1])
			{
				T temp = data[j];
				data[j] = data[j + 1];
				data[j + 1] = temp;
				flag = true;
			}
		}
		if (!flag)
		{
			break;
		}
	}
}
template<typename T>
void MyClass<T>::QuickSort1(int begin,int end)
{
	int s = begin;
	int t = end;
	if(s < t)
	{
		T temp = data[s];
		while (s!=t)
		{
			while (s<t&&data[t] >= temp)
				t--;
			data[s] = data[t];
			while (s<t&&data[s] <= temp)
				s++;
			data[t] = data[s];

		}
		data[s] = temp;
		QuickSort1(begin, s - 1);
		QuickSort1(s + 1, end);
	}
}
template<typename T>
void MyClass<T>::QuickSort(void)
{
	QuickSort1(0, length-1);
}
template<typename T>
void MyClass<T>::SelectSort(void)
{
	for (int i = 0; i < length - 1; i++)
	{
		int mindex = i;
		for (int j = i + 1; j < length; j++)
		{
			if (data[j]<data[mindex])
				mindex = j;
		}
		if (mindex != i)
		{
			T temp = data[i];
			data[i] = data[mindex];
			data[mindex] = temp;
		}
	}
}
template<typename T>
void MyClass<T>::Sift(int low, int high)
{
	int i = low;
	int j = 2 * i+1;
	T temp = data[i]; 
	while (j <= high)
	{
		if (j < high&&data[j] < data[j + 1])
			j++;
		if (temp < data[j])
		{
			data[i] = data[j];
			i = j;
			j = 2 * i+1;
		}
		else
		{
			break;
		}
	}
	data[i] = temp;

}
template<typename T>
void MyClass<T>::HeapSort(void)
{
	int i;
	T temp;
	for (i = length / 2-1; i >=0; i--)
	{
		Sift(i, length-1);
	}
	for (i = length-1; i >0; i--)
	{
		temp = data[0];
		data[0] = data[i];
		data[i] = temp;
		Sift(0, i-1);
	}
}
template<typename T>
void MyClass<T>::Merge2(int low, int mid, int high)
{
	int i = low;
	int s = mid;
	int j = mid + 1;
	int t = high;

	T *temp = new T[high - low + 1];
	int k = 0;

	while (i <= s&&j <= t)
	{
		if (data[i] <= data[j])
		{
			temp[k] = data[i];
			k++;
			i++;
		}
		else
		{
			temp[k] = data[j];
			k++;
			j++;
		}
	}
	while (i <= s)
	{
		temp[k] = data[i];
		k++;
		i++;
	}
	while (j <= t)
	{
		temp[k] = data[j];
		k++;
		j++;
	}
	for (int n = 0; n < high - low + 1; n++)
	{
		data[low + n] = temp[n];
	}
	delete[]temp;
}
template<typename T>
void MyClass<T>::MergePass2(int len)
{
	int i;
	for (i = 0; i + 2 * len - 1 < length; i = i + 2 * len)
	{
		Merge2(i, i + len - 1, i + 2 * len - 1);
	}
	if (i + len - 1 < length)
		Merge2(i, i + len - 1, length - 1);
}
template<typename T>
void MyClass<T>::MergeSort2(void)
{
	int len;
	for (len = 1; len < length; len *= 2)
		MergePass2(len);
}


#endif

主函数：main.cpp

#include"All_SortAlgorithm.h"

int main()
{
	const int N = 10;
	int Array[N] = { -6, -8, 7, 9, 10, 11, 3, -2, 4, 0 };
	MyClass<int> myclass;
	cout << "原始数组数据：";
	myclass.CreateArray(Array, N);
	myclass.Disp();
	//===
	//cout << "简单直接插入排序：";
	//myclass.DirectInsertSort();
	//myclass.Disp();
	//===
	/*cout << "折半插入排序：";
	myclass.BInaryInsertSort();
	myclass.Disp();*/
	//===
	/*cout << "希尔排序：";
	myclass.ShellSort();
	myclass.Disp();*/
	//===
	/*cout << "冒泡排序：";
	myclass.BubleSort();
	myclass.Disp();*/
	//===
	/*cout << "快速排序：";
	myclass.QuickSort();
	myclass.Disp();*/
	//===
	/*cout << "选择法排序：";
	myclass.SelectSort();
	myclass.Disp();*/
	//===
	cout << "堆排序：";
	myclass.HeapSort();
	myclass.Disp();
	
	//===
	/*cout << "归并排序：";
	myclass.MergeSort2();
	myclass.Disp();*/
	return 0;
}