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;
}