插入、希尔、冒泡、快速、选择排序C++实现

#include 
using namespace std;

void printRes(int a[], int n);
void insertSort(int a[], int n, bool flag);
void shellSort(int a[], int n, bool flag);
void bubbleSort(int a[], int n, bool flag);
void fastSort(int a[], int nl, int nr, bool flag);
void selectSort(int a[], int n, bool flag);
int main()
{
	//***********************定义要排序的数组***********************//
	int a[10] = { 51,26,56,89,23,-60,2,9,100,78 };
	cout << "排序前：" << endl;
	printRes(a,10);
	//*************************************************************//



	//*********************插入排序********************************//
	//从第一个开始，下标后移；
	//当前下标与下标之前的数比较，小于就替换，直到遇到大与的或者下标为0就结束
	cout << "顺序插入排序后：" << endl;
	insertSort(a, 10, true);
	printRes(a,10);

	cout << "逆序插入排序后：" << endl;
	insertSort(a, 10, false);
	printRes(a, 10);
	//************************************************************//



	//**********************希尔排序******************************//
	//将整个数组分成几个小数组进行直接插入排序
	//希尔排序是不稳定的
	cout << "顺序希尔排序后：" << endl;
	shellSort(a, 10, true);
	printRes(a, 10);

	cout << "逆序希尔排序后：" << endl;
	shellSort(a, 10, false);
	printRes(a, 10);
	//************************************************************//




	//**********************冒泡排序******************************//
	//从第一个数开始两两比较，最小的放到最左边
	//冒泡排序是稳定的
	cout << "顺序冒泡排序后：" << endl;
	bubbleSort(a, 10, true);
	printRes(a, 10);

	cout << "逆序冒泡排序后：" << endl;
	bubbleSort(a, 10, false);
	printRes(a, 10);
	//************************************************************//

	//**********************快速排序******************************//
	//分治+递归的思想
	//快速排序算法是不稳定的
	cout << "顺序快速排序后：" << endl;
	fastSort(a, 0,9, true);
	printRes(a, 10);

	cout << "逆序快速排序后：" << endl;
	fastSort(a, 0,9, false);
	printRes(a, 10);
	//************************************************************//

	//**********************选择排序******************************//
	//选择排序算法是不稳定的
	cout << "顺序选择排序后：" << endl;
	selectSort(a, 10, true);
	printRes(a, 10);

	cout << "逆序选择排序后：" << endl;
	selectSort(a, 10, false);
	printRes(a, 10);
	//************************************************************//
	

}

void shellSort(int a[], int n,bool flag)
{
	if (flag)
	{
		for (size_t step = n/2; step > 0; step = step /2)
		{//每次步长缩小一倍
			for (size_t i = 0; i < step; i++)
			{
				for (size_t j = i+ step; j < n; j+= step)
				{
					int temp = a[j];
					int k = j - step;
					while (k>=0&&(a[k]>temp))
					{
						a[k + step] = a[k];
						k = k - step;
					}
					a[k + step] = temp;
				}
			}
		}
	}
	else
	{
		for (size_t step = n / 2; step > 0; step = step / 2)
		{//每次步长缩小一倍
			for (size_t i = 0; i < step; i++)
			{
				for (size_t j = i + step; j < n; j += step)
				{
					int temp = a[j];
					int k = j - step;
					while (k >= 0 && (a[k] < temp))
					{
						a[k + step] = a[k];
						k = k - step;
					}
					a[k + step] = temp;
				}
			}
		}
	}
}
void insertSort(int a[], int n, bool flag)
{
	if (flag)
	{
		//开始插入排序，顺序排序
		for (size_t i = 1; i < n; i++)
		{//第一个不需要比较，所以从第二个开始排，索引值为1
			int temp = a[i];//将值临时保存
			int j = i - 1;//往前比较，取下标
			while (j >= 0 && (a[j] > temp))//一直往前比，下标指向的位置一直向前，所以循环
			{
				a[j + 1] = a[j];//如果前面的大，便将前面的值挪到此时下标代表的值
				j--;//下标往前再挪做循环
			}
			a[j + 1] = temp;//将本轮要排序的值放到当前下标的后一位，如果前面的值小于这个值，while不进入，本轮到此为止，否则一直替换到j=-1
		}
	}
	else
	{
		//开始逆序排序
		for (size_t i = 1; i < 10; i++)
		{
			int temp = a[i];
			int j = i - 1;
			while (j >= 0 && (a[j] < temp))
			{
				a[j + 1] = a[j];
				j--;
			}
			a[j + 1] = temp;
		}
	}
}
void bubbleSort(int a[], int n, bool flag)
{
	if (flag)
	{
		for (size_t i = 0; i < n; i++)
		{		
			for (size_t j = i + 1; j < n; j++)
			{
				int temp = a[i];
				if (a[j] < a[i])
				{
					a[i] = a[j];
					a[j] = temp;
				}
			}
		}
	}
	else
	{
		for (size_t i = 0; i < n; i++)
		{			
			for (size_t j = i + 1; j < n; j++)
			{
				int temp = a[i];
				if (a[j] > a[i])
				{
					a[i] = a[j];
					a[j] = temp;
				}
			}
		}
	}
	
}
void fastSort(int a[], int nl,int nr, bool flag)
{//初始时，nl=0,nr=n-1
	if (flag)
	{
		int l = nl;//左下标位置
		int r = nr;//右下标位置
		int temp = a[l];//轴心位置数据值
		bool rightOrleftFlag = true;//下标左移还是右移,初始右移
		if (nl<nr)
		{//该if判断用于跳出递归
			while (l < r)
			{//找到第一次比较后的基准下标，实现初次分治
				if (rightOrleftFlag)
				{
					if (a[r] >= temp)
					{
						r--;
						continue;
					}
					a[l] = a[r];
					l++;
					rightOrleftFlag = false;
					continue;
				}
				else
				{
					if (a[l] <= temp)
					{
						l++;
						continue;
					}
					a[r] = a[l];
					r--;
					rightOrleftFlag = true;
					continue;
				}
			}
			a[l] = temp;
			fastSort(a, nl, l, true);//用递归实现左边序列的不断分治
			fastSort(a, l + 1, nr, true);//用递归实现右边序列的不断分治
		}
	}
	else
	{
		int l = nl;//左下标位置
		int r = nr;//右下标位置
		int temp = a[l];//轴心位置数据值
		bool rightOrleftFlag = true;//下标左移还是右移,初始右移
		if (nl < nr)
		{//该if判断用于跳出递归
			while (l < r)
			{//找到第一次比较后的基准下标，实现初次分治
				if (rightOrleftFlag)
				{
					if (a[r] <= temp)
					{
						r--;
						continue;
					}
					a[l] = a[r];
					l++;
					rightOrleftFlag = false;
					continue;
				}
				else
				{
					if (a[l] >= temp)
					{
						l++;
						continue;
					}
					a[r] = a[l];
					r--;
					rightOrleftFlag = true;
					continue;
				}
			}
			a[l] = temp;
			fastSort(a, nl, l, false);//用递归实现左边序列的不断分治
			fastSort(a, l + 1, nr, false);//用递归实现右边序列的不断分治
		}
	}
	

}
void selectSort(int a[], int n, bool flag)
{
	if (flag)
	{
		for (size_t i = 0; i < n - 1; i++)
		{
			int location = i;
			for (size_t j = i + 1; j < n; j++)
			{
				if (a[j] < a[location])
				{
					location = j;
					a[location] = a[j];
				}
			}
			if (i != location)
			{
				int temp = a[i];
				a[i] = a[location];
				a[location] = temp;
			}
		}
	}
	else
	{
		for (size_t i = 0; i < n - 1; i++)
		{
			int location = i;
			for (size_t j = i + 1; j < n; j++)
			{
				if (a[j] > a[location])
				{
					location = j;
					a[location] = a[j];
				}
			}
			if (i != location)
			{
				int temp = a[i];
				a[i] = a[location];
				a[location] = temp;
			}
		}
	}
	

}
void printRes(int a[], int n)
{
	for (size_t i = 0; i < n; i++)
	{
		cout <<i<<":"<< a[i] << endl;
	}
}