一些排序算法的简单实现

// 排序算法.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<vector>
#include<iostream>
#include<algorithm>
#include<iomanip>
using namespace std;
const int MaxNum = 24;
void vecprint(vector<int> const & num)
{
	cout << endl;
	for (int i = 0; i < MaxNum; i++)
	{
		cout << setw(2) << setfill('0') << i << " ";
	}
	cout << endl;
	for (auto i : num)
	{
		cout << setw(2) << setfill('0') << i << " ";
	}
	cout << endl;
}

/*冒泡排序
比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
*/

void BubbleSort(vector<int> & num)
{
	size_t lenth = num.size();
	bool flag = false;
	do
	{
		for (int i = 1; i < lenth; i++)
		{
			flag = false;
			if(num[i] < num[i - 1])
			{
				flag = true;
				swap(num[i], num[i - 1]);
			}
		}
		lenth--;
	} while (flag);

}


/*选择排序
第一趟从n个元素的数据序列中选出关键字最小/大的元素并放在最前/后位置，
下一趟从n-1个元素中选出最小/大的元素并放在最前/后位置。
以此类推，经过n-1趟完成排序。*/
void SelectSort(vector<int> & num)
{
	size_t lenth = num.size();
	int MinElement = 0;
	MinElement = num[0];
	int MinElementPos = 0;
	for (int j = 0; j < lenth; j++)
	{
		MinElementPos = j;
		for (int i = j + 1; i < lenth; i++)
		{
			if (num[i] < num[MinElementPos])
			{
				MinElementPos = i;
			}
		}
		swap(num[j], num[MinElementPos]);
	}
}



/*插入排序
插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，
从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序*/
void InsertSort(vector<int> & num)
{
	size_t lenth = num.size();
	int tmppos = 0;
	for (int i = 1; i < lenth; i++)
	{
		tmppos = i;
		for (int j = i-1 ; j >= 0; j--)
		{
			if (num[tmppos] < num[j])
			{
				swap(num[tmppos], num[j]);
				tmppos--;
			}
			else
			{
				break;
			}
		}
	}

}
/*归并排序  分治法*/

void MergeArr(int a[], int first, int mid, int last, int temp[])
{
	int i = first, j = mid + 1;
	int m = mid, n = last;
	int k = 0;

	while (i <= m && j <= n)
	{
		if (a[i] <= a[j])
			temp[k++] = a[i++];
		else
			temp[k++] = a[j++];
	}

	while (i <= m)
		temp[k++] = a[i++];

	while (j <= n)
		temp[k++] = a[j++];

	for (i = 0; i < k; i++)
		a[first + i] = temp[i];
}

void mergesort(int a[], int first, int last, int temp[])
{
	if (first < last)
	{
		int mid = (first + last) / 2;
		mergesort(a, first, mid, temp);    //左边有序  
		mergesort(a, mid + 1, last, temp); //右边有序  
		MergeArr(a, first, mid, last, temp); //再将二个有序数列合并  
	}
}

bool MergeSort(vector<int> & num)
{
	int n = num.size();
	int *a = new int[n];
	memcpy(a, &num[0], n * sizeof(int));
	int *p = new int[n];
	if (p == NULL)
		return false;
	mergesort(a, 0, n - 1, p);
	delete[] p;
	delete[] a;
	return true;
}

/*快速排序*/

int Partition(int a[], int low, int high)
{
	int x = a[high];//将输入数组的最后一个数作为主元，用它来对数组进行划分
	int i = low - 1;//i是最后一个小于主元的数的下标
	for (int j = low; j < high; j++)//遍历下标由low到high-1的数
	{
		if (a[j] < x)//如果数小于主元的话就将i向前挪动一个位置，并且交换j和i所分别指向的数
		{
			int temp;
			i++;
			temp = a[i];
			a[i] = a[j];
			a[j] = temp;
		}
	}
	//经历上面的循环之后下标为从low到i（包括i）的数就均为小于x的数了，现在将主元和i+1位置上面的数进行交换
	a[high] = a[i + 1];
	a[i + 1] = x;
	return i + 1;
}
void QuickSort(int a[], int low, int high)
{
	if (low < high)
	{
		int q = Partition(a, low, high);
		QuickSort(a, low, q - 1);
		QuickSort(a, q + 1, high);
	}
}
/*堆排序*/

int main()
{
	vector<int> num;
	for (int i = 0; i < MaxNum; i++)
	{
		num.push_back(i);
	}
	random_shuffle(num.begin(), num.end());
	vecprint(num);
	//BubbleSort(num);
	//vecprint(num);

    //InsertSort(num);
	//MergeSort(num);
	int n = num.size();
	int *a = new int[n];
	memcpy(a, &num[0], n * sizeof(int));
	QuickSort(a, 0, MaxNum - 1);
	
	//vecprint(num);
	for (int i = 0; i < MaxNum; i++)
	{
		cout << a[i] << " ";
	}
	delete[] a;
    return 0;
}