C++八大排序

#include<iostream>
#include <string.h>
#include<vector>
using namespace std;
//-----------------------------------电脑有点问题，导致虚拟机里面的东西不能拉出到主机上，所以目前没有可执行文件。可运行命令 gcc /path/main.cpp -o main  生成可执行文件。

void showMenu()
{
	cout << "***************************" << endl;
	cout << "******  1、冒泡排序  ******" << endl;
	cout << "******  2、快速排序  ******" << endl;
	cout << "******  3、插入排序  ******" << endl;
	cout << "******  4、希尔排序  ******" << endl;
	cout << "******  5、选择排序  ******" << endl;
	cout << "******  6、堆排序    ******" << endl;
	cout << "******  7、归并排序  ******" << endl;
	cout << "******  8、基数排序  ******" << endl;
	cout << "******  9、重新开始  ******" << endl;
	cout << "******  0、退出      ******" << endl;
	cout << "***************************" << endl;
}


int* createArray(int arr[],int n) 
{
	for (int i = 0; i < n; i++) 
	{
		cin >> arr[i];
	}
	return arr;
}

void printArray(int arr[], int len) 
{
	for (int i = 0; i < len; i++) 
	{
		cout << arr[i] << " ";
	}
	cout << endl;
}

void bubbleSort(int arr[], int len) 
{
	for (int i = 0; i < len - 1; i++) 
	{
		for (int j = 0; j < len - i - 1; j++) 
		{
			if (arr[j] > arr[j + 1])
			{
				swap(arr[j], arr[j + 1]);
			}
		}
	}
}

void quickSort(int arr[], int start, int end)
{
	if (start >= end)
	{
		return;
	}
	int pivot = arr[start];
	int i = start;
	int j = end;
	while (i < j)
	{
		while (arr[j] >= pivot && i < j)
		{
			j--;
		}
		arr[i] = arr[j];
		while (arr[i] <= pivot && i < j)
		{
			i++;
		}
		arr[j] = arr[i];
	}
	arr[i] = pivot;
	quickSort(arr, start, i - 1);
	quickSort(arr, i + 1, end);
}

void insertSort(int arr[], int len)
{
	for (int i = 1; i < len; i++)
	{
		for (int j = i; j >=1 && arr[j] < arr[j - 1]; j--)
		{
			swap(arr[j], arr[j - 1]);
		}
	}
}

void shellSort(int arr[], int len)
{
	for (int step = len / 2; step >= 1; step /= 2)
	{
		for (int i = 0; i < step; i++)
		{
			for (int j = i; j < len; j += step)
			{
				for (int k = j; k >= step && arr[k] < arr[k - step]; k -= step)
				{
					swap(arr[j], arr[j + 1]);
				}
			}
		}
	}
}

void selectSort(int arr[], int len)
{
	
	for (int i = 0; i < len-1; i++)
	{
		int flag = i;
		for (int j = i; j < len; j++)
		{
			if (arr[j] < arr[flag])
			{
				flag = j;
			}
		}
		swap(arr[i], arr[flag]);
	}
}


void heap(int arr[], int len, int root)
{
	int lchild = root * 2 + 1;             //  子结点的位置=2*（父结点位置）+1
	if (lchild < len)
	{
		int flag = lchild;
		int rchild = lchild + 1;
		if (rchild < len)
		{
			if (arr[rchild] > arr[flag])
			{
				flag = rchild;
			}
		}
		if (arr[root] < arr[flag])
		{
			swap(arr[root], arr[flag]);
			heap(arr, len, flag);
		}
	}
}
void heapSort(int arr[], int len)
{
	for (int i = len / 2-1; i >= 0; i--)   //  length/2-1是最后一个非叶节点，此处"/"为整除
	{
		heap(arr, len, i);
	}
	for (int j = len - 1; j > 0; j--)
	{
		swap(arr[0], arr[j]);
		heap(arr, j, 0);
	}
}

void merge(int arr[], int tempArr[], int start, int mid,int end)
{
	//标记左半区第一个未排序的元素
	int l_pos = start;
		//标记右半区第一个未排序的元素
	int r_pos = mid+1;
	//临时数组元素的下表
	int pos = start;
	//合并
	while (l_pos <= mid && r_pos <= end)
	{
		if (arr[l_pos] < arr[r_pos])
		{
			tempArr[pos++] = arr[l_pos++];
		}
		else
		{
			tempArr[pos++] = arr[r_pos++];
		}
	}

	//合并左半区剩余的元素
	while (l_pos <= mid)
	{
		tempArr[pos++] = arr[l_pos++];
 	}
	//合并右半区剩余的元素
	while (r_pos <= end)
	{
		tempArr[pos++] = arr[r_pos++];
	}
	//把临时数组中合并后的元素复制回原来的数组
	while (start <= end)
	{
		arr[start] = tempArr[start];
		start++;
	}
	

}
void mergeSort(int arr[], int tempArr[], int start, int end)
{
	if (start < end)
	{
		int mid = (start + end) / 2;
		mergeSort(arr, tempArr,start, mid);
		mergeSort(arr, tempArr, mid + 1, end);
		merge(arr, tempArr, start, mid, end);
	}
}

int getMaxPos(int arr[],int len)
{
	int maxPos = 1;
	for (int i = 0; i < len; i++)
	{
		int pos = 0;
		int num = arr[i];
		while (num!=0)
		{
			num /= 10;
			pos ++;
		}
		if (pos > maxPos) maxPos = pos;
	}
	return maxPos;
}
void radixSort(int arr[], int len)
{
	int maxPos = getMaxPos(arr, len);
	int b[10][100];
	int Y = 1;
	//把数组的每一个数的数字位的值拿出来放到桶里
	for (int i = 1; i <= maxPos; i++)
	{
		//把桶清空
		memset(b, 0, sizeof(b));
		for (int j = 0; j < len; j++)
		{
			int num = arr[j] / Y % 10;
			//把数放入桶中
			b[num][++b[num][0]]= arr[j];
		}
		//把桶里的数据拿出来放回数组
		int arr_len = 0;
		for (int n = 0; n < 9; n++)
		{
			for (int m = 1; m <= b[n][0]; m++)
			{
				arr[arr_len++] = b[n][m];
			}
		}
		Y *= 10;
	}
}
/*
插帽龟，它很稳
插帽龟喜欢选帽插，插完就方了

八大排序算法主要分四类：
	插入排序：直接插入排序，希尔排序
	选择排序：直接选择排序，堆排序
	交换排序：冒泡排序，快速排序
	归并排序：二路归并排序，多路归并排序
	
	这里少了一个基数排序
*/

int main() 
{

	showMenu();
	int len;
	cout << "请输入需要定义的数组长度：";
	cin >> len;
	int * arr = new int[len];      
	//vector <int> arr(len, 1);
	cout << "请输入数组值，每输入一个值以回车结尾" << endl;
	arr = createArray(arr,len);
	cout << "原始数组：";
	printArray(arr, len);

	int select = 0;
	while (1)
	{
		cout << "请输入您的选择：" << endl;
		cin >> select;
		switch (select)
		{
		case 0:
			return 0;
		case 1:
			cout << "冒泡排序结果：";
			bubbleSort(arr, len);
			printArray(arr, len);
			break;
		case 2:
			cout << "快速排序结果：";
			quickSort(arr, 0, len - 1);
			printArray(arr, len);
			break;
		case 3:
			cout << "插入排序结果：";
			insertSort(arr, len);
			printArray(arr, len);
			break;
		case 4:
			cout << "希尔排序结果：";
			shellSort(arr, len);
			printArray(arr, len);
			break;
		case 5:
			cout << "选择排序结果：";
			selectSort(arr, len);
			printArray(arr, len);
			break;
		case 6:
			cout << "堆排序结果：";
			heapSort(arr, len);
			printArray(arr, len);
			break;
		case 7:
		{
			int* tempArr = (int*)malloc(len * sizeof(int));
			if (tempArr)
			{
				cout << "归并排序结果：";
				mergeSort(arr, tempArr, 0, len - 1);
				printArray(arr, len);
			}
			else
			{
				cout << "分配内存失败，无法进行归并排序，请再次尝试" << endl;
			}
		}
		break;
		case 8:
			cout << "基数排序结果：";
			radixSort(arr, len);
			printArray(arr, len);
			system("pause");
			break;
		case 9:
			system("cls");
			showMenu();
			int len;
			cout << "请输入需要定义的数组长度：";
			cin >> len;
			int* arr = new int[len];
			//vector <int> arr(len, 1);
			cout << "请输入数组值，每输入一个值以回车结尾" << endl;
			arr = createArray(arr, len);
			cout << "原始数组：";
			printArray(arr, len);
		}
	

	}
	




}