2021.11.28数据结构实验课作业——排序

1、 常用排序算法（必做题）

（1） 插入排序算法：

随机生成一组数据，分别进行直接插入排序和希尔排序，输出排序结果以及排序过程中数据比较和移动次数。

（2） 交换排序算法：

随机生成一组数据，分别进行起泡排序和快速排序，输出排序结果以及排序过程中数据比较和移动次数。

（3） 选择排序算法：

随机生成一组数据，分别进行简单选择排序和堆排序，输出排序结果以及排序过程中数据比较和移动次数。
/***************/
人生苦短，我用std::sort() （doge）

点击查看代码main.cpp

#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;
class Sort
{
public:
	Sort(int r[], int n);                           //构造函数，生成待排序序列
	~Sort();                                   //析构函数
	void InsertSort();                            //直接插入排序
	void ShellSort();                            //希尔排序
	void BubbleSort();                           //起泡排序
	void QuickSort(int first, int last);                //快速排序
	void SelectSort();                            //简单选择排序
	void HeapSort();                             //堆排序
	void MergeSort1(int first, int last);               //二路归并递归排序
	void MergeSort2();                           //二路归并非递归排序
	void Print();                                //输出序列 
private:
	int Partition(int first, int last);                   //快速排序，一次划分
	void Sift(int k, int last);                        //堆排序，堆调整
	void Merge(int first1, int last1, int last2);          //归并排序，合并相邻有序序列
	void MergePass(int h);                        //归并排序，一趟归并

	int* data;                                  //待排序序列
	int length;
};

Sort::Sort(int r[], int n)
{
	data = new int[n];
	for (int i = 0; i < n; i++)
		data[i] = r[i];
	length = n;
}

Sort :: ~Sort()
{
	delete[] data;
}

void Sort::Print()
{
	for (int i = 0; i < length; i++)
		cout << data[i] << "\t";
}

/***********************
直接插入排序算法
************************/
void Sort::InsertSort()
{
	int i, j, temp;
	int count=0;
	for (i = 1; i < length; i++) //排序进行length-1趟
	{
		temp = data[i]; //暂存待插记录
		for (j = i - 1; j >= 0 && temp < data[j]; j--) //寻找插入位置
		{
			data[j + 1] = data[j];
			data[j + 1] = temp;
			count++;
		}
		cout << "比较和移动次数为" << count << endl;
	}
}
/******************
希尔排序算法
*******************/
void Sort::ShellSort()
{
	int temp, d, i, j;
	int count = 0;
	for (d = length / 2; d >= 1; d = d / 2) //增量为d进行直接插入排序
	{
		for (i = d; i < length; i++) //进行一趟希尔排序
		{
			temp = data[i]; //暂存待插入记录
			for (j = i - d; j >= 0 && temp < data[j]; j = j - d)
			{
				data[j + d] = data[j]; //记录后移d个位置
				data[j + d] = temp;
				count++;
			}
		}
	}
	cout << "比较和移动次数为" << count << endl;
}
/*******************
起泡排序算法
********************/
void Sort::BubbleSort()
{
	int j, exchange, bound, temp;
	int count = 0;
	exchange = length - 1; //第一趟起泡排序的区间是[0~length-1]
	while (exchange != 0)
	{
		bound = exchange; exchange = 0;
		for (j = 0; j < bound; j++) //一趟起泡排序的区间是[0~bound]
			if (data[j] > data[j + 1]) {
				temp = data[j]; data[j] = data[j + 1]; data[j + 1] = temp;
				exchange = j; //记载每一次记录交换的位置
				count++;
			}
	}
	cout << "比较和移动次数为" << count << endl;
}
/*****************************
快速排序的一次划分算法
******************************/
int Sort::Partition(int first, int last)
{
	int i = first, j = last, temp; //初始化一次划分的区间
	while (i < j)
	{
		while (i < j && data[i] <= data[j]) j--; //右侧扫描
		if (i < j) {
			temp = data[i];	data[i] = data[j]; data[j] = temp;
			i++;
		}
		while (i < j && data[i] <= data[j])
			i++; //左侧扫描
		if (i < j) {
			temp = data[i]; data[i] = data[j]; data[j] = temp;
			j--;
		}
	}
	return i; // i为轴值记录的最终位置
}
/**********************
简单选择排序算法
***********************/
void Sort::SelectSort()
{
	int i, j, index, temp;
	int count = 0;
	for (i = 0; i < length - 1; i++) //进行length-1趟简单选择排序
	{
		index = i;
		for (j = i + 1; j < length; j++) //在无序区中选取最小记录
			if (data[j] < data[index]) index = j;
		if (index != i) {
			temp = data[i]; data[i] = data[index]; data[index] = temp;
			count++;
		}
	}
	cout << "比较和移动次数为" << count << endl;
}
/*******************
快速排序算法
********************/
void Sort::QuickSort(int first, int last)
{
	int count = 0;
	if (first >= last)
		return; //区间长度为1，递归结束
	else
	{
		int pivot = Partition(first, last); //一次划分
		QuickSort(first, pivot - 1); //对左侧子序列进行快速排序
		QuickSort(pivot + 1, last); //对右侧子序列进行快速排序
	}
}


int main()
{
	int number;
	cin >> number;
	
	int arr[50];
	for (int i = 0; i < number; i++)
	{
		arr[i] = i;//定义一个从0到n-1不重复的数组
	}
	srand(time(0));
	for (int i = 0; i < number; i++)
	{
		int j = rand() % number;//使j随机取0到n-1的数
		int temp = arr[i];//用temp存储第i个数
		arr[i] = arr[j];//将第j个数的数值赋值给第i个数
		arr[j] = temp;//将原先第i个数的数值赋值给第j个数
		//这一系列操作其实就是将0到n-1中的两个数互换位置，依旧保持不重复的数值
	}
	for (int i = 0; i < number; i++)
	{
		cout << arr[i] << endl;//输出打乱后的数组
	}
	Sort A(arr, number);
	cout << "直接插入排序：" << endl;
	A.InsertSort();
	cout << "希尔插入排序：" << endl;
	A.ShellSort();
	cout << "直接起泡排序：" << endl;
	A.BubbleSort();
	cout << "快速排序排序：" << endl;
	A.QuickSort(0,number);
	cout << "简单选择排序;" << endl;
	A.SelectSort();
	return 0;
}