排序

#include <iostream>
#include <stack>
#include <cassert>
using namespace std;

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

void inserting_Sort()//插入排序
{
	int arr[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
	int size = sizeof(arr) / sizeof(arr[0]);
	int end = 1;

	while (end < size)
	{
		for (int i = end; i > 0; i--)
		{
			if (arr[i] < arr[i - 1])
				swap(arr[i], arr[i - 1]);
			else
				break;
		}
		end++;
	}
	PrintArr(arr, size);
}

void Shell_Sort()//希尔排序
{
	int arr[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
	int size = sizeof(arr) / sizeof(arr[0]);
	int glag = 3;

	while (glag)
	{
		//glag = glag / 3 + 1;
		int end = glag;
		while (end < size)
		{
			for (int i = end; end > 0; end-=glag)
			{
				if (arr[end] < arr[end - glag])
					swap(arr[end], arr[end - glag]);
				else
					break;
			}
			end++;
		}
		glag--;
	}
	PrintArr(arr, size);
}

void Select_Sort()//选择排序
{
	int arr[] = { 0, 8, 7, 6, 5, 4, 3, 2, 1, 9 };
	int size = sizeof(arr) / sizeof(arr[0]);

	int min = 0;
	int max = 0;
	int left = 0;
	int right = size - 1;

	while (left < right)
	{
		for (int i = left + 1; i <= right; i++)
		{
			if (arr[i] < arr[min])
				min = i;
			if (arr[i] > arr[max])
				max = i;
		}
		if (max == left || min == right)
		{
			swap(arr[left], arr[min]);
			max = min;
			if (max != right)
				swap(arr[max], arr[right]);
		}
		else
		{
			swap(arr[left], arr[min]);
			swap(arr[right], arr[max]);
		}
		left++;
		right--;
		min = max = left;
	}
	PrintArr(arr, size);
}

void CreatHeap(int* arr, int parent, int size)
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		if (child + 1 < size && arr[child] < arr[child + 1])
			child = child + 1;
		if (arr[child] > arr[parent])
			swap(arr[child], arr[parent]);
		parent = child;
		child = child * 2 + 1;
	}
}

void Heap_Sort()//堆排序
{
	int arr[] = { 6, 5, 4, 9, 8, 7, 3, 2, 1, 0 };
	//int arr[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int size = sizeof(arr) / sizeof(arr[0]);

	for (int i = (size - 2) / 2; i >= 0; i--)
	{
		CreatHeap(arr, i, size);
	}

	for (int i = size - 1; i > 0; i--)
	{
		swap(arr[0], arr[i]);
		CreatHeap(arr, 0, i);
	}

	PrintArr(arr, size);
}

int PartSort1(int* arr, int left, int right)
{
	int key = arr[--right];

	while (left < right)
	{
		while (arr[left] <= key)
			left++;
		while (arr[right] >= key)
			right--;
		if (left < right)
			swap(arr[left], arr[right]);
	}
	swap(arr[left], arr[key]);
	return left;
}

void QuickSort1(int* arr, int left, int right)//快排1
{
	int div = PartSort1(arr, left, right);
	if (left < div - 1)
		QuickSort1(arr, left, div);
	if (div + 1 < right)
		QuickSort1(arr, div + 1, right);
}

int PartSort2(int* arr, int left, int right)
{
	int key = arr[--right];
	int blank = right;

	while (left < right)
	{
		while (left < right && arr[left] <= key)
			left++;
		arr[blank] = arr[left];
		blank = left;

		while (left < right && arr[right] >= key)
			right--;
		arr[blank] = arr[right];
		blank = right;
	}
	arr[blank] = key;

	return blank;
}

void QuickSort2(int* arr, int left, int right)//快排2
{
	if (left < right)
	{
		int div = PartSort2(arr, left, right);
		QuickSort2(arr, left, div);
		QuickSort2(arr, div + 1, right);
	}
}

int PartSort3(int* arr, int left, int right)
{
	int pre = left - 1;
	int end = --right;

	while (left < right)
	{
		if (arr[left] < arr[right])
		{
			if (++pre != left)
				swap(arr[pre], arr[left]);
		}
		left++;
	}
	swap(arr[++pre], arr[end]);
	return pre;
}

void QuickSort3(int* arr, int left, int right)//快排3之前后指针法
{
	if (left < right)
	{
		int div = PartSort3(arr, left, right);
		QuickSort3(arr, 0, div);
		QuickSort3(arr, div + 1, right);
	}
}

void QuickSortNor1(int* arr, int left, int right)//快排1非递归
{
	assert(arr);
	stack<int> s;
	s.push(right);
	s.push(left);

	while (!s.empty())
	{
		int start = s.top();
		s.pop();
		int end = s.top();
		s.pop();

		int div = PartSort1(arr, start, end);

		if (start < div)
		{
			s.push(div);
			s.push(start);
		}
		if (end > div + 1)
		{
			s.push(end);
			s.push(div + 1);
		}
	}
}

void QuickSortNor2(int* arr, int left, int right)//快排2非递归
{
	assert(arr);
	stack<int> s;
	s.push(right);
	s.push(left);

	while (!s.empty())
	{
		int start = s.top();
		s.pop();
		int end = s.top();
		s.pop();

		int div = PartSort2(arr, start, end);

		if (start < div)
		{
			s.push(div);
			s.push(start);
		}
		if (end > div + 1)
		{
			s.push(end);
			s.push(div + 1);
		}
	}
}

void QuickSortNor3(int* arr, int left, int right)//快排2非递归
{
	assert(arr);
	stack<int> s;
	s.push(right);
	s.push(left);

	while (!s.empty())
	{
		int start = s.top();
		s.pop();
		int end = s.top();
		s.pop();

		int div = PartSort3(arr, start, end);

		if (start < div)
		{
			s.push(div);
			s.push(start);
		}
		if (end > div + 1)
		{
			s.push(end);
			s.push(div + 1);
		}
	}
}

void Merger(int* arr, int left, int mid, int right, int* tmp)
{
	int begin1 = left;
	int end1 = mid;
	int begin2 = mid + 1;
	int end2 = right;
	int index = left;

	while (begin1 <= end1 && begin2 <= end2)
	{
		if (arr[begin1] < arr[begin2])
			tmp[index++] = arr[begin1++];
		else
			tmp[index++] = arr[begin2++];
	}

	while (begin1 <= end1)
		tmp[index++] = arr[begin1++];
	while (begin2 <= end2)
		tmp[index++] = arr[begin2++];

	while (left <= right)
		arr[left++] = tmp[left];
}

void _MergerSort(int* arr, int left, int right, int* tmp)
{
	if (left >= right)
		return;

	int mid = left + ((right - left) / 2);
	_MergerSort(arr, left, mid, tmp);
	_MergerSort(arr, mid + 1, right, tmp);

	Merger(arr, left, mid, right, tmp);
	//memcpy(arr + left, tmp + left, (right - left + 1)*sizeof(int));
}

void MergerSort(int* arr, int left, int right)//归并排序
{
	int* tmp = new int[right - left];
	_MergerSort(arr, left, right - 1, tmp);
	delete[] tmp;
}


void CountSort(int* arr, int size)//计数排序
{
	int min = arr[0];
	int max = arr[0];
	for (int index = 0; index < size; index++)
	{
		if (arr[index] < min)
			min = arr[index];
		if (arr[index] > max)
			max = arr[index];
	}

	int* tmp = new int[max - min + 1];
	memset(tmp, 0, sizeof(int)*(max - min + 1));

	for (int i = 0; i < size; i++)
		tmp[arr[i] - min]++;

	int index = 0;
	for (int i = 0; i < (max - min + 1); i++)
	{
		if (tmp[i])
		{
			while (tmp[i]--)
				arr[index++] = i + min;
		}
	}
	delete[] tmp;
}

void LSDSort(int* arr, int size)
{
	int digit = 0;
	int base = 1;
	for (int i = 0; i < size; i++)
	{
		while (arr[i] >= base)
		{
			digit++;
			base *= 10;
		}
	}

	int* tmp = new int[size];
	base = 1;

	while (digit--)
	{
		//统计某一位相同的树出现的系数
		int count[10] = { 0 };
		for (int i = 0; i < size; i++)
			count[arr[i] / base % 10]++;

		//计算某一位相同的数在临时空间的起始位置
		int startsite[10] = { 0 };
		for (int i = 1; i < size; i++)
			startsite[i] = startsite[i - 1] + count[i - 1];

		for (int i = 0; i < size; i++)
		{
			int site = arr[i] / base % 10;
			tmp[startsite[site]++] = arr[i];
		}

		memcpy(arr, tmp, sizeof(int)*size);
		base *= 10;
	}

	delete[] tmp;
}

int main()
{
	cout << "inserting_Sort:";
	inserting_Sort();

	cout << "Shell_Sort:";
	Shell_Sort();

	cout << "Select_Sort:";
	Select_Sort();

	cout << "Heap_Sort:";
	Heap_Sort();

	cout << "QuickSort1:";
	int arr1[] = { 2, 0, 4, 9, 3, 6, 8, 7, 1, 5 };
	QuickSort1(arr1, 0, sizeof(arr1) / sizeof(arr1[0]));
	PrintArr(arr1, sizeof(arr1) / sizeof(arr1[0]));

	cout << "QuickSort2:";
	int arr2[] = { 2, 0, 4, 9, 3, 6, 8, 7, 1, 5 };
	QuickSort2(arr2, 0, sizeof(arr2) / sizeof(arr2[0]));
	PrintArr(arr2, sizeof(arr2) / sizeof(arr2[0]));

	cout << "QuickSort3:";
	int arr3[] = { 2, 0, 4, 9, 3, 6, 8, 7, 1, 5 };
	QuickSort3(arr3, 0, sizeof(arr3) / sizeof(arr3[0]));
	PrintArr(arr3, sizeof(arr3) / sizeof(arr3[0]));

	cout << "QuickSortNor1:";
	int arr4[] = { 2, 0, 4, 9, 3, 6, 8, 7, 1, 5 };
	QuickSortNor1(arr4, 0, sizeof(arr4) / sizeof(arr4[0]));
	PrintArr(arr4, sizeof(arr4) / sizeof(arr4[0]));

	cout << "QuickSortNor2:";
	int arr5[] = { 2, 0, 4, 9, 3, 6, 8, 7, 1, 5 };
	QuickSortNor2(arr5, 0, sizeof(arr5) / sizeof(arr5[0]));
	PrintArr(arr5, sizeof(arr5) / sizeof(arr5[0]));

	cout << "QuickSortNor3:";
	int arr6[] = { 2, 0, 4, 9, 3, 6, 8, 7, 1, 5 };
	QuickSortNor3(arr6, 0, sizeof(arr6) / sizeof(arr6[0]));
	PrintArr(arr6, sizeof(arr6) / sizeof(arr6[0]));



	cout << "Merger:";
	int arr7[] = { 21, 25, 49, 25, 16, 8, 31, 41 };
	MergerSort(arr7, 0, sizeof(arr7) / sizeof(arr7[0]));
	PrintArr(arr7, sizeof(arr7) / sizeof(arr7[0]));

	cout << "CountSort:";
	int arr8[] = { 11, 14, 16, 18, 20, 3, 5, 7, 9 };
	CountSort(arr8, sizeof(arr8) / sizeof(arr8[0]));
	PrintArr(arr8, sizeof(arr8) / sizeof(arr8[0]));

	cout << "LSDSort:";
	int arr9[] = { 14, 12, 17, 45, 33, 37, 67, 68, 27, 23 };
	LSDSort(arr9, sizeof(arr9) / sizeof(arr9[0]));
	PrintArr(arr9, sizeof(arr9) / sizeof(arr9[0]));

	return 0;
}