各种排序方法（后续会更新）

好久没更博了，大三应该有更多的时间写东西。谢谢大家的支持！

//Sort_H.h
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

/*宏定义*/
#ifndef Sort_H
#define Sort_H

/*
	为了方便后面的桶排序,我们约定所要排列的数均不超过1000
*/

class Sort
{
public:
	Sort(int s);  //构造函数,初始化排序的数组
	int Size();
	void Insertion_sort();   //插入排序
	void Selection_sort();  //选择排序
	void Merge(int p,int q,int r);  //归并函数中的合并函数
	void merge_sort(int p,int r);  //归并排序
	void Merge_sort();  //合并
	void Bubble_sort();  //冒泡排序
	void Heap_sort();  //堆排序
	vector<int> Build_MAX_Heap(vector<int>& qq);   //建立最大堆
	void MAX_Heapify(vector<int>& qq,int index);   //维护最大堆
	int heap_size;  //堆大小
	void Quick_sort();   //快速排序
	void quickSort(vector<int> &list,int first,int last);  //快速排序中的划分
	int partition(vector<int> &list,int first,int last);   //划分数组list[first...last]
	void Bucket_Sort(vector<int> &list);   //桶排序
	void Bogo_Sort();
	void bogo_sort(vector<int> &list);
	/*
		Bogo排序（bogo-sort）是个既不实用又原始的排序算法，其原理等同将一堆卡片抛起，落在桌上后检查卡片是否已整齐排列好，若非就再抛一次。
		其名字源自Quantum bogodynamics，又称bozo sort、blort sort或猴子排序（参见无限猴子定理）。
		无限猴子定理：让一只猴子在打字机上随机地按键，当按键时间达到无穷时，几乎必然能够打出任何给定的文字，比如莎士比亚的全套著作。
	*/
	void Shuffle(vector<int> &list);
	bool Inorder(vector<int> list);
private:
	vector<vector<int>> Bucket;
	vector<int> A;
	int size;
};
	 

#endif 

//Sort.cpp

#include "Sort_H.h"
#include <iostream>
#include <vector>
#include <algorithm>
#include <ctime>
#include <cstdlib>
using namespace std;
const int MAX = 60000;
const int NUM = 3;


Sort::Sort(int s)
{
	size = s;
	cout << "请初始化数组里各个元素:" << endl;
	A.resize(s);
	int i;
	for(i = 0;i < size;i++)
	{
		cin >> A[i] ;
	}
	cout << "未排序前数组类各个元素分别为:" << endl;
	for(i = 0;i < size;i++)
		cout << A[i] << "  ";
	cout << endl;
}

int Sort::Size()
{
	return size;
}

void Sort::Insertion_sort()
{
	int key;
	int i,j;
	for(i = 1;i < size;i++)
	{
		key = A[i];
		j = i - 1;
		while(j >= 0 && key < A[j])
		{
			A[j+1] = A[j];
			j--;
		}
		A[j+1] = key;
	}
	cout << "将插入排序处理后序列为:" << endl;
	for(i = 0;i < size;i++)
		cout << A[i] << "  " ;
	cout << endl;
}

//冒泡排序
void Sort::Bubble_sort()
{
	int i,j;
	for(i = 0;i < size;i++)
	{
		for(j = size - 1;j > i ;j--)
		{
			if(A[j] < A[j-1])
				swap(A[j],A[j-1]);
		}
	}
	cout << "将冒泡排序处理后序列为:" << endl;
	for(i = 0;i < size;i++)
		cout << A[i] << "  " ;
	cout << endl;
}

//选择排序
void Sort::Selection_sort()
{
	int i,j;
	for(i = 0;i < size;i++)
	{
		int index = i;
		for(j = i;j < size;j++)
		{
			if(A[index] > A[j])
			{
				index = j;
			}
		}
		swap(A[i],A[index]);
	}
	cout << "将选择排序处理后序列为:" << endl;
	for(i = 0;i < size;i++)
		cout << A[i] << "  " ;
	cout << endl;
}

//合并过程
//起于p,终于r,分割点为q
void Sort::Merge(int p,int q,int r)
{
	int i,j,k;
	int n1 = q - p + 1;
	int n2 = r - q;
	vector<int> L;
	vector<int> R;
	L.resize(n1+1);
	R.resize(n2+1);
	for(i = 0;i < n1;i++)
	{
		L[i] = A[p+i];
	}
	for(i = 0;i < n2;i++)
	{
		R[i] = A[q+i+1];
	}
	//哨兵值
	L[n1] = MAX;
	R[n2] = MAX;
	i = j = 0;
	for(k = p;k <= r;k++)
	{
		if(L[i] <= R[j])
		{
			A[k] = L[i];
			i++;
		}
		else
		{
			A[k] = R[j];
			j++;
		}
	}
}


void Sort::merge_sort(int p,int r)
{
	if(p < r)
	{
		int q = (p + r)/2;
		merge_sort(p,q);
		merge_sort(q + 1,r);
		Merge(p,q,r);
	}
}

//归并排序
void Sort::Merge_sort()
{
	merge_sort(0,Size() - 1);
	cout << "将归并排序处理后序列为:" << endl;
	for(int i = 0;i < size;i++)
		cout << A[i] << "  " ;
	cout << endl;
}


void Sort::Heap_sort()
{
	vector<int> result;
	result = Build_MAX_Heap(A);
	heap_size = A.size();
	A.clear();
	int i;
	for(i = result.size();i >= 2;i--)
	{
		swap(result[0],result[i-1]);
		A.push_back(result[i-1]);
		result.pop_back();
		heap_size--;
		MAX_Heapify(result,0);
	}
	A.push_back(result[0]);
	cout << "将堆排序处理后序列为:" << endl;
	for(int i = 0;i < size;i++)
		cout << A[i] << "  " ;
	cout << endl;
}

vector<int> Sort::Build_MAX_Heap(vector<int> & qq)
{
	vector<int> result;
	int n = qq.size();
	result = qq;
	int i;
	for(i = n/2;i >= 1;i--)
	{
		MAX_Heapify(result,i-1);
	}
	return result;
}

void Sort::MAX_Heapify(vector<int>& qq,int index)  //维护最大堆
{
	int left = 2*index + 1;
	int right = 2*index + 2;
	int largest ;
	if(index > qq.size()/2 -1)
		;
	if(left < qq.size() && qq[left] < qq[index])
		largest = left;
	else
		largest = index;
	if(right < qq.size() && qq[right] < qq[largest])
		largest = right;
	if(largest != index)
	{
		swap(qq[index],qq[largest]);
		MAX_Heapify(qq,largest);
	}
}

int Sort::partition(vector<int> &list,int first,int last)
{
	int pivot = list[first];
	int low = first + 1;
	int high = last;

	while(high > low)
	{
		//从左端向前
		while(low <= high && list[low] <= pivot)
			low++;
		//从右端向后
		while(low <= high && list[high] > pivot)
			high--;

		//交换表中两个元素
		if(high > low)
		{
			int temp = list[high];
			list[high] = list[low];
			list[low] = temp;
		}
	}

	while(high > first && list[high] >= pivot)
		high--;

	//交换pivot和list[high]
	if(pivot > list[high])
	{
		list[first] = list[high];
		list[high] = pivot;
		return high;
	}
	else
		return first;
}

void Sort::quickSort(vector<int> &list,int first,int last)
{
	if(last > first)
	{
		int pivotIndex = partition(list,first,last);
		quickSort(list,first,pivotIndex - 1);
		quickSort(list,pivotIndex + 1,last);
	}

}

void Sort::Quick_sort()
{
	quickSort(A,0,A.size()-1);
	cout << "将快速排序处理后序列为:" << endl;
	for(int i = 0;i < size;i++)
		cout << A[i] << "  " ;
	cout << endl;
}

void Sort::Bucket_Sort(vector<int> &list)
{
	Bucket.resize(10);
	int i,j,k;
	for(i = 0;i < list.size();i++)
	{
		Bucket[list[i] % 100].push_back(list[i]);
	}
	j = 0;
	for(i = 0;i < 10;i++)
	{
		if(!Bucket[i].empty())
		{
			for(k = 0;k < Bucket[i].size();k++)
				list[j++] = Bucket[i][k];
		}
	}
	for(i = 0;i < 10;i++)
		Bucket[i].clear();
	for(i = 0;i < list.size();i++)
	{
		Bucket[list[i] / 10 % 10].push_back(list[i]);
	}
	j = 0;
	for(i = 0;i < 10;i++)
	{
		if(!Bucket[i].empty())
		{
			for(k = 0;k < Bucket[i].size();k++)
				list[j++] = Bucket[i][k];
		}
	}
	for(i = 0;i < 10;i++)
		Bucket[i].clear();
	for(i = 0;i < list.size();i++)
	{
		Bucket[list[i] / 100].push_back(list[i]);
	}
	j = 0;
	for(i = 0;i < 10;i++)
	{
		if(!Bucket[i].empty())
		{
			for(k = 0;k < Bucket[i].size();k++)
				list[j++] = Bucket[i][k];
		}
	}
	cout << "将桶排序处理后序列为:" << endl;
	for(int i = 0;i < size;i++)
		cout << list[i] << "  " ;
	cout << endl;
}

void Sort::Bogo_Sort()
{
	bogo_sort(A);
}

void Sort::bogo_sort(vector<int> &list)
{
	while(!Inorder(list))
		Shuffle(list);
	cout << "将猴子排序处理后序列为:" << endl;
	for(int i = 0;i < size;i++)
		cout << list[i] << "  " ;
	cout << endl;
}

void Sort::Shuffle(vector<int> &list)
{
	int i;
	int length = list.size();
	srand(time(0));
	for(i = 0;i < list.size();i++)
	{
		int num = rand() % length;
		int temp = list[num];
		list[num] = list[i];
		list[i] = temp;
	}
}

bool Sort::Inorder(vector<int> list)
{
	for (int i = 0; i < list.size() - 1; i++) {
        if (list[i] > list[i+1]) 
			return false;
    }
    return true;
}


		

	

//test.cpp

#include <iostream>
#include <vector>
#include "Sort_H.h"
using namespace std;
int main()
{
	Sort s(6);
	//s.Insertion_sort();
	//s.Bubble_sort();
	//s.Selection_sort();
	//s.Merge_sort();
	//s.Heap_sort();
	//s.Quick_sort();
	s.Bogo_Sort();
	return 0;
}