沙雕作业-----Sort

Sort.h

#pragma once
#define MAX_LENGTH 10000
#define MIN_LENGTH 10

using namespace std;

class Sort
{
public:
	int * random_data;
	int random_length;

	void StraightInsertionSort(int data[], int length);
	void BinaryInsertionSort(int data[], int length);
	void TwoWayInsertionSort(int data[], int length);
	void ShellSort(int data[], int length);
	void BubbleSort(int data[], int length);

	void QuickSort(int data[], int length, int low = 0, int high = 9);

	void SelectionSort(int data[], int length);
	void TreeSelectionSort(int data[], int length);

	void HeapSort(int data[], int length);
	void AdjustHeap(int data[], int length, int start);

	void MergingSort(int data[], int length, int low = 0, int high = 9);
	void RadixSort(int data[], int length);

	void UI();
	void CreateRadomNumber();
public:
	int Mod(int x, int y);
	void ShowReasult(int data[], int length);
};

Sort.cpp

#include "stdafx.h"
#include "Sort.h"
#include "iostream"
#include <stdlib.h>

using namespace std;

int Sort::Mod(int x, int y)
{
	if (x < 0)
	{
		return (x % y) + y;
	}
	else
	{
		return x % y;
	}
}

void Sort::ShowReasult(int data[], int length)
{
	int i;
	for (i = 0;i < length;i++)
	{
		cout << "   " << data[i] << "   ";
	}
	cout << endl;
}

void Sort::StraightInsertionSort(int data[], int length)
{
	int temp;
	int i, j;
	for (i = 1;i < length;i++)
	{
		if (data[i] < data[i - 1])
		{
			temp = data[i];
			data[i] = data[i - 1];
			for (j = i - 1;temp < data[j] && j >= 0;j--)
			{
				data[j] = data[j - 1];
			}
			data[j + 1] = temp;
		}
	}
}

void Sort::BinaryInsertionSort(int data[], int length)
{
	int temp;
	int low = 0;
	int high;
	int middle;
	int i, j;
	for (i = 1;i < length;i++)
	{
		temp = data[i];
		low = 0;
		high = i - 1;
		while (low <= high)
		{
			middle = (low + high) / 2;
			if (temp < data[middle])
			{
				high = middle - 1;
			}
			else
			{
				low = middle + 1;
			}
		}
		for (j = i;j > low;j--)
		{
			data[j] = data[j - 1];
		}
		data[low] = temp;
	}
}

void Sort::TwoWayInsertionSort(int data[], int length)
{
	int * link = new int[length];
	link[0] = data[0];
	int head = 0;
	int tail = 0;
	int i, j;
	for (i = 1;i < length;i++)
	{
		if (data[i] <= link[head])
		{
			head = Mod(head - 1, length);
			link[head] = data[i];
		}
		else if (data[i] >= link[tail])
		{
			tail = Mod(tail + 1, length);
			link[tail] = data[i];
		}
		else
		{
			for (j = tail;data[i] < link[j];j = (j - 1) % length)
			{
				link[Mod(j + 1, length)] = link[Mod(j, length)];
			}
			link[j + 1] = data[i];
			tail = Mod(tail + 1, length);
		}
	}
}

void Sort::ShellSort(int data[], int length)
{
	int temp;
	int i, j;
	for (i = length / 2;i > 0;i--)
	{
		for (j = i;j < length;j++)
		{
			if (data[j] < data[j - i])
			{
				temp = data[j];
				data[j] = data[j - i];
				data[j - i] = temp;
			}
		}
	}
}

void Sort::BubbleSort(int data[], int length)
{
	int temp;
	int i, j;
	for (i = 0;i < length;i++)
	{
		for (j = i + 1;j < length;j++)
		{
			if (data[j] < data[i])
			{
				temp = data[i];
				data[i] = data[j];
				data[j] = temp;
			}
		}
	}
}

/*
递归实现快速排序法
*/
void Sort::QuickSort(int data[], int length, int low, int high)
{
	int key = data[low];
	int left = low;
	int right = high;
	int temp;
	if (left < right)
	{
		while (left < right)
		{
			while (left < right&&key <= data[right])
			{
				right--;
			}
			temp = data[right];
			data[right] = data[left];
			data[left] = temp;
			while (left < right&&data[left] <= key)
			{
				left++;
			}
			temp = data[right];
			data[right] = data[left];
			data[left] = temp;
		}
		QuickSort(data, length, low, left - 1);
		QuickSort(data, length, left + 1, high);
	}
}

/*
在大顶堆基础上进行调整
*/
void Sort::AdjustHeap(int data[], int length, int start)
{
	int temp = data[start];
	int i;
	for (i = start * 2 + 1;i < length;i = i * 2 + 1)
	{
		if (i + 1 < length&&data[i + 1] > data[i])
		{
			i++;
		}
		if (data[i] > temp)
		{
			data[start] = data[i];
			start = i;
		}
		else
		{
			break;
		}
	}
	data[start] = temp;
}

void Sort::HeapSort(int data[], int length)
{
	/*
	从第一个非叶子节点开始自下而上,自右到左,构造大顶堆
	*/
	int i;
	for (i = length / 2 - 1;i >= 0;i--)
	{
		AdjustHeap(data, length, i);
	}
	/*
	取出堆顶元素并进行调整
	*/
	int temp;
	for (i = 1;i < length;i++)
	{
		temp = data[0];
		data[0] = data[length - i];
		data[length - i] = temp;
		AdjustHeap(data, length - i, 0);
	}
}

void Sort::MergingSort(int data[], int length, int low, int high)
{
	//监视点
	int watcher_data[10];
	int watcher_i;
	for (watcher_i = 0;watcher_i < 10;watcher_i++)
	{
		watcher_data[watcher_i] = data[watcher_i];
	}

	if (low < high)
	{
		/*
		后序递归
		*/
		int middle = (low + high) / 2;

		MergingSort(data, middle - low + 1, low, (low + high) / 2);
		MergingSort(data, high - middle + 2, (low + high) / 2 + 1, high);

		int head1 = low;
		int tail1 = middle;
		int head2 = middle + 1;
		int tail2 = high;

		int i = 0;
		/*
		申请辅助数组存放数据
		*/
		int * arr = new int[high - low + 1];
		while (head1 <= tail1 && head2 <= tail2)
		{
			if (data[head1] < data[head2])
			{
				arr[i++] = data[head1++];
			}
			else
			{
				arr[i++] = data[head2++];
			}
		}
		while (head1 <= tail1)
		{
			arr[i++] = data[head1++];
		}
		while (head2 <= tail2)
		{
			arr[i++] = data[head2++];
		}
		memcpy(data + low, arr, (high - low + 1) * sizeof(int));
	}
}

void Sort::CreateRadomNumber()
{
	random_length = rand() % (MAX_LENGTH - MIN_LENGTH + 1) + MIN_LENGTH;
	random_data = new int[random_length];

	int i;
	for (i = 0;i < random_length;i++)
	{
		random_data[i] = rand() % 100;
	}
}

void Sort::UI()
{
	int input;
	bool judge = true;
	while (judge)
	{
		cout << "0.创建随机数" << endl;
		cout << "1.直接插入排序" << endl;
		cout << "2.二分插入排序" << endl;
		cout << "3.希尔排序" << endl;
		cout << "4.快速排序" << endl;
		cout << "5.堆排序" << endl;
		cout << "6.归并排序" << endl;
		cout << "9.退出" << endl;
		cin >> input;
		switch (input)
		{
		case 0:
			CreateRadomNumber();
			break;
		case 1:
			StraightInsertionSort(random_data, random_length);
			break;
		case 2:
			BinaryInsertionSort(random_data, random_length);
			break;
		case 3:
			ShellSort(random_data, random_length);
			break;
		case 4:
			QuickSort(random_data, random_length, 0, random_length - 1);
			break;
		case 5:
			HeapSort(random_data, random_length);
			break;
		case 6:
			MergingSort(random_data, random_length, 0, random_length - 1);
			break;
		case 9:
			judge = false;
		default:
			break;
		}
		ShowReasult(random_data, random_length);
	}
}