【排序算法】

冒泡排序，快速排序，插入排序，希尔排序，选择排序，堆排序，计数排序C++实现

const int SIZE = 20;
int Data[SIZE] = { 13,2,4,17,6,10,5,20,8,14,9,15,3,12,6,8,11,18,16,7 };

//2 3 4 5 6 6 7 8 8 9 10 11 12 13 14 15 16 17 18 20

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

void swap(int* arr, int minIndex, int index)
{
	int tmp = arr[minIndex];
	arr[minIndex] = arr[index];
	arr[index] = tmp;
}

//冒泡排序
TEST_CASE("1:Test Sort Algorithm", "[bubble]")
{
	for (int k = SIZE - 1; k > 0; k--)
	{
		int i = 1;
		for (int i = 0; i < k; i++)
		{
			int j = i + 1;
			if (Data[i] > Data[j])
			{
				int tmp = Data[j];
				Data[j] = Data[i];
				Data[i] = tmp;
			}
		}
	}
	printarray(Data, SIZE);
}

//{ 13, 2, 4, 17, 6, 10, 5, 20, 8, 14, 9, 15, 3, 12, 6, 8, 11, 18, 16, 7 }
//简单插入
TEST_CASE("2:Test Sort Algorithm", "[insertsort]")
{
	for (int nEnd = 1; nEnd < SIZE; nEnd++)
	{
		int nCompare = Data[nEnd];
		for (int i = nEnd; i >= 1; i--)
		{
			if (nCompare <= Data[i - 1])
			{
				Data[i] = Data[i - 1];
				Data[i - 1] = nCompare;
			}
			else
			{
				break;
			}
		}
	}

	printarray(Data, SIZE);
}

//{ 13, 2, 4, 17, 6, 10, 5, 20, 8, 14, 9, 15, 3, 12, 6, 8, 11, 18, 16, 7 }
//选择排序
TEST_CASE("3:Test Sort Algorithm", "[selectsort]")
{
	
	for (int index = 0; index < SIZE - 1; index++)
	{
		int nMin = Data[index];

		for (int i = index + 1; i < SIZE; i++)
		{
			if (Data[i] < nMin)
			{
				Data[index] = Data[i];
				Data[i] = nMin;
				nMin = Data[index];
			}
		}
	}

	printarray(Data, SIZE);
}

//{ 13, 2, 4, 17, 6, 10, 5, 20, 8, 14, 9, 15, 3, 12, 6, 8, 11, 18, 16, 7 }
//堆排序 O(nlogn)
void heapsort(int* arr, int size, int index)
{
	int minIndex = index;
	int l = 2 * minIndex + 1;
	int r = 2 * minIndex + 2;

	if (l < size && arr[l] < arr[minIndex])
	{
		minIndex = l;
	}

	if (r < size && arr[r] < arr[minIndex])
	{
		minIndex = r;
	}

	if (minIndex != index)
	{
		swap(arr, minIndex, index);
		heapsort(arr, size, minIndex);
	}
}

TEST_CASE("4:Test Sort Algorithm", "[heapsort]")
{
	//第一步：保证每个节点的数比子节点要小
	for (int i = (SIZE / 2) - 1; i >= 0; i--)
	{
		heapsort(Data, SIZE, i);
	}

	//第二步：交换首尾
	for (int End = SIZE -1; End >= 1; End--)
	{
		swap(Data, End, 0);
		heapsort(Data, End, 0);
	}
	printarray(Data, SIZE);
}


//希尔排序
TEST_CASE("5:Test Sort Algorithm", "[hillsort]")
{
	for (int step = SIZE / 2; step >= 1; step = step / 2)
	{
		for (int i = 0; i < step; i++)
		{
			int nCurrentIndex = i;
			int nNextIndex = nCurrentIndex + step;

			while (nNextIndex < SIZE)
			{
				int nSwapIndex = nNextIndex;
				int nLastIndex = nSwapIndex - step;
				while (nLastIndex >= 0 && Data[nSwapIndex] < Data[nLastIndex])
				{
					swap(Data, nLastIndex, nSwapIndex);
					nSwapIndex = nLastIndex;
					nLastIndex = nLastIndex - step;
				}
				nNextIndex = nNextIndex + step;				
			}
		}
	}
	printarray(Data, SIZE);
}

//计数排序
int maxnum(int* Data, int size)
{
	int max = Data[0];
	for (int i = 1; i < size; i++)
	{
		if (Data[i] > max)
		{
			max = Data[i];
		}
	}
	return max;
}

int minnum(int* Data, int size)
{
	int min = Data[0];
	for (int i = 1; i < size; i++)
	{
		if (Data[i] < min)
		{
			min = Data[i];
		}
	}
	return min;
}

TEST_CASE("6:Test Sort Algorithm", "[countsort]")
{
	int max = maxnum(Data, SIZE);
	int min = minnum(Data, SIZE);

	int arrSize = max - min + 1;
	int* newArray = new int[arrSize];
	memset(newArray, 0, sizeof(int) * arrSize);
	for (int i = 0; i < SIZE; i++)
	{
		newArray[Data[i] - min] += 1;
	}

	for (int i = 0; i < arrSize + 1; i++)
	{
		int num = min + i;
		for (int j = 0; j < newArray[i]; j++)
		{
			cout << num << " ";
		}
	}
	cout << endl;
}

TEST_CASE("7:Test Sort Algorithm", "[bucketsort]")
{
	int max = maxnum(Data, SIZE);
	int min = minnum(Data, SIZE);

	int arrSize = 5; //暂定5个桶
	std::vector<int>* p = new std::vector<int>[arrSize];

	for (int i = 0; i < SIZE; i++)
	{
		int step = (max - min) / (arrSize - 1);
		int index = ((Data[i] - min) / step) ;
		p[index].push_back(Data[i]);
	}
	
	for (int j = 0; j < 5; j++)
	{
		for (auto it = p[j].begin(); it != p[j].end(); it++)
		{
			std::cout << *it << "\t";
		}
		std::cout << std::endl;
	}
}


void quicksort(int* Data, int nLIndex, int nRIndex)
{
	int nFirstIndex = nLIndex;
	int nLastIndex = nRIndex;
	int nBaseData = Data[nFirstIndex];

	while (nLIndex != nRIndex)
	{
		//从右边开始找第一个小于BaseData的值
		while (nLIndex != nRIndex)
		{
			if (Data[nRIndex] < nBaseData)
			{
				swap(Data, nLIndex, nRIndex);
				nLIndex++;
				break;
			}
			else
			{
				nRIndex--;
			}
		}

		//从左边开始找第一个大于BaseData的值
		while (nLIndex != nRIndex)
		{
			if (Data[nLIndex] > nBaseData)
			{
				swap(Data, nLIndex, nRIndex);
				nRIndex--;
				break;
			}
			else
			{
				nLIndex++;
			}
		}
	}
	Data[nLIndex] = nBaseData;
	printarray(Data, SIZE);

	if (nFirstIndex < nLIndex - 1)
		quicksort(Data, nFirstIndex, nLIndex - 1);

	if (nLastIndex > nLIndex + 1)
		quicksort(Data, nLIndex + 1, nLastIndex);
}

//快速排序
TEST_CASE("8:Test Sort Algorithm", "[quicksort]")
{
	quicksort(Data, 0, SIZE - 1);
	printarray(Data, SIZE);
}