c++模板类快速排序

```cpp
#include <assert.h>
#include <iostream>

using namespace  std;

template < typename T, int ONE_TIME_NUM = 16 >

class Vector
{
public:
	Vector()
	{
		data_ptr_ = NULL;
		max_size_ = 0;
		count_ = 0;
	}

	virtual ~Vector()
	{
		empty();
	}

	inline int count() const
	{
		return count_;
	}
	inline int size() const
	{
		return count_;
	}
	inline int max_size() const
	{
		return max_size_;
	}

	void insert(const int index, const T& data)
	{
		assert(index > -1 && index <= count_);

		if (count_ >= max_size_)
			reserve((max_size_ > 0) ? max_size_ * 2 : ONE_TIME_NUM);

		if (index < count_)
		{
			memmove(data_ptr_ + index + 1, data_ptr_ + index, sizeof(T)* (count_ - index));
		}

		data_ptr_[index] = data;
		count_++;
	}
	int add(const T& data)
	{
		if (count_ >= max_size_)
			reserve((max_size_ > 0) ? max_size_ * 2 : ONE_TIME_NUM);

		memcpy(data_ptr_ + count_, &data, sizeof(data));
		count_++;
		return count_ - 1;
	}

	int push_back(const T& data)
	{
		return add(data);
	}

	inline const T& get(const int index) const
	{
		assert(index > -1 && index < count_);
		return data_ptr_[index];
	}

	inline void set(const int index, const T& item)
	{
		assert(index > -1 && index < count_);
		data_ptr_[index] = item;
	}

	int index(const T& data) const
	{
		int i;

		for (i = count_ - 1; i > -1; --i)
		{
			if (data_ptr_[i] == data)
			{
				return i;
			}
		}

		return -1;
	}

	void remove(const int index)
	{
		assert(index > -1 && index < count_);

		remove(index, 1);
	}

	void remove(const int index, const int count)
	{
		assert(index + count <= count_);

		if (count > 0)
		{
			memmove(data_ptr_ + index, data_ptr_ + index + count, sizeof(data_ptr_[0]) * (count_ - index - count));
			count_ -= count;
		}
	}

	virtual void empty()
	{
		clear();
		max_size_ = 0;

		if (data_ptr_)
		{
			free(data_ptr_);
			data_ptr_ = NULL;
		}
	}

	inline void clear()
	{
		count_ = 0;
	}

	inline void trunc(const int count)
	{
		assert(count > -1 && count <= max_size_);
		count_ = count;
	}

	virtual void reserve(int count)
	{
		if (count > count_ && count != max_size_)
		{
			max_size_ = count;
			data_ptr_ = (T*)realloc(data_ptr_, sizeof(T)* count);
		}
	}

	inline void addList(const Vector<T>& list)
	{
		addArray((T*)list, list.count_);
	}

	inline void addArray(T* data, int length)
	{
		if (count_ + length > max_size_)
			reserve(count_ + length);

		memcpy(data_ptr_ + count_, data, length * sizeof(T));
		count_ += length;
	}

	int add_item(const T& item)
	{
		//id加到列表中
		int low = 0;
		int high = this->count_ - 1;

		while (low <= high)
		{
			int mid = ((unsigned)(low + high)) >> 1;
			const T& mid_item = this->data_ptr_[mid];

			if (mid_item < item)
				low = mid + 1;
			else
				high = mid - 1;
		}

		this->insert(low, item);
		return low;
	}

	inline void display()
	{
		for (int i = 0; i < count_; ++i)
		{
			printf("%d  ",data_ptr_[i]);
		}
		printf("\n");
	}

	inline void qsorts(int left, int right)
	{
		unsigned int i, j;
		T mid;

		if (left < right)
		{
			mid = data_ptr_[(left + right) >> 1];      // 取中间值做基准
			i = left;
			j = right;

			while (1)  //这个while循环是将比中间值大的全部交换到右边,比中间值小的全部放在左边
			{
				while (data_ptr_[j] > mid) //在右边找到比中间值小的位置
				{
					j--;
				}

				while (data_ptr_[i] < mid)//在左边找到比中间值大的位置
				{
					i++;
				}
				/*while (arr[--j] >= mid);
				while (arr[++i] < mid);*/

				if (i >= j)
					break;

				//找到后交换
				T a;
				a = data_ptr_[i];
				data_ptr_[i] = data_ptr_[j];
				data_ptr_[j] = a;

//				display();
			}
//			display();
			qsorts(left, i - 1); //将[0,i-1]范围内的又重新执行上面步骤 这里的i可以是[0,5]
			qsorts(j + 1, right);// 将[j + 1, 10]范围内的又重新执行上面步骤 这里的j可以是[6, 10]
		}
	}

	inline int push(const T& data)
	{
		return add(data);
	}

	inline T pop()
	{
		if (count_ > 0)
		{
			count_--;
			return data_ptr_[count_];
		}

		throw "stack was empty";
	}

	inline operator T* () const
	{
		return data_ptr_;
	}

protected:
	T*	data_ptr_;
	int	max_size_;
	int	count_;
};

class student
{
public:
	int id_;
	int score_;

	//重载不等判断的运算符
	inline bool operator != (const student& data) const
	{
		return id_ != data.id_;
	}

	inline bool operator > (const student& data) const
	{
		if (score_ == data.score_)
		{
			return id_ > data.id_;
		}
		return score_ < data.score_;
	}

	inline bool operator < (const student& data) const
	{
		if (score_ == data.score_)
		{
			return id_ < data.id_;
		}
		return score_ > data.score_;
	}
	student() : id_(0), score_(0){}
	student(int id,int score) : id_(id), score_(score){}
};

int main()
{
	Vector<int> vec;
	vec.push_back(2);
	vec.push_back(7);
	vec.push_back(11);
	vec.push_back(10);
	vec.push_back(12);
	vec.push_back(4);
	vec.push_back(8);
	vec.push_back(1);
	vec.push_back(3);
	vec.push_back(9);
	vec.push_back(13);
	vec.push_back(5);
	vec.push_back(6);

	Vector<int> array;
	array.addList(vec);
	array.qsorts(0, array.count()-1);

	array.display();
	/*for (int i = 0; i < vec.size(); i++)
		cout << vec[i] << "  ";*/

	int arr1[] = {2,1,4,12,8,9,14,13,6,10,11,3,5,7};
	Vector<int> array2;
	array2.addArray(arr1,sizeof(arr1)/sizeof(arr1[0]));

	array2.qsorts(0,array2.count() - 1);
	array2.display();

	//如果是自定义类型 需要重载比较运算符
	Vector<student> array3;
	array3.add_item(student(1, 10));
	array3.add_item(student(2, 8));
	array3.add_item(student(3, 11));
	array3.add_item(student(4, 7));
	array3.add_item(student(5, 9));
	array3.add_item(student(6, 12));
	array3.add_item(student(7, 12));

	array3.qsorts(0, array3.count() - 1);

	for (int i = 0; i < array3.size(); i++)
		cout << "("<< array3[i].id_ << "," << array3[i].score_ << ")";

	cout << endl;
	system("pause");
	return 0;
}