数据结构实验报告9--三种平均时间复杂度为O(nlogn)的内部排序算法的实现

实验内容及要求：

输入n个整数，用快速排序、堆排序与2路归并排序算法实现由小到大排序并输出排序结果。要求排序数据及排序结果用字符文件实现输入与输出。

实验目的：掌握快速排序、堆排序与2路归并排序算法。

#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
#include<vector>
#include<fstream>
#define MAX_SIZE 20 //定义数据的最大个数为20
using namespace std;

class MySort
{
public:
    MySort() = default;
   
    //归并排序
    void mergeSort(vector<int>& arr, int l, int r);
    void merge(vector<int>& arr, int l, int mid, int r);
    //堆排序
    void heapSort(vector<int>& arr);
    void heapAjust(vector<int>& arr, int start, int end);
    //快速排序
    void quickSort(vector<int>& arr, int l, int r);
    int partition(vector<int>& arr, int l, int r);
    //输出到文件
    void OutPut(vector<int>& arr);
    //从文件读取数据
    void InPut(vector<int>& arr);
    //获取私有属性a(也可以将向量a定义为public)
    vector<int> getA();

    ~MySort() = default;
private:
    vector<int> a; //存取从文件读入的字符
};



int main()
{
    MySort sort;
    vector<int> arr0 = sort.getA();
    //文件读入
    sort.InPut(arr0);
    
    vector<int> arr1 = sort.getA();
    vector<int> arr2 = sort.getA();
    vector<int> arr3 = sort.getA();

   
    //快排
    sort.quickSort(arr1,0,arr1.size()-1);
    sort.OutPut(arr1);
    //归并
    sort.mergeSort(arr2, 0, arr2.size() - 1);
    sort.OutPut(arr2);
    //堆排序
    sort.heapSort(arr3);
    sort.OutPut(arr3);

    return 0;
}

vector<int> MySort::getA() {
    return a;
}
//文件读取
void MySort::InPut(vector<int>& arr) {
    fstream infile;
    infile.open("test01.txt", ios::in);
    int datalen = 0;
    if (infile.is_open())
        cout << "ok" << endl;
    else cout << "false" << endl;
    while (!infile.eof()) {
        infile >> datalen;
        a.push_back(datalen);
    }
    infile.close();
}
//文件输出
void MySort::OutPut(vector<int> & arr) {
    ofstream outfile;
    outfile.open("output01.txt", ios::app);//选择的是app,运行一次会将运行的结果追加到文件中
    for (auto it : arr)
        outfile << it << " ";
    outfile << endl;
    outfile.close();
}
//归并排序
void MySort::mergeSort(vector<int>& arr, int l, int r) {
    if (l >= r)
        return;
    int mid = l + (r - l) / 2;
    mergeSort(arr, l, mid);
    mergeSort(arr, mid + 1, r);
    merge(arr, l, mid, r);
}

void MySort::merge(vector<int>& arr, int l, int mid, int r) {
    vector<int> tmp(r - l + 1);
    int i = 0;
    int p = l, q = mid + 1;
    while (p <= mid && q <= r) {
        if (arr[p] < arr[q])
            tmp[i++] = arr[p++];
        else tmp[i++] = arr[q++];
    }
    while (p <= mid)
        tmp[i++] = arr[p++];
    while (q <= r)
        tmp[i++] = arr[q++];
    for (int k = 0; k < r - l + 1; k++)
        arr[l + k] = tmp[k];
}
void MySort::heapSort(vector<int>& arr) {
    int n = arr.size();
    for (int i = n / 2 - 1; i >= 0; i--)
        heapAjust(arr, i, n - 1);
    for (int j = n - 1; j >= 1; j--) {
        swap(arr[0], arr[j]);
        heapAjust(arr, 0, j - 1);
    }

}
void MySort::heapAjust(vector<int>& arr, int start, int end) {
    int root = start;
    int child = 2 * root + 1;
    while (child <= end) {
        if (child + 1 <= end && arr[child + 1] > arr[child])
            child++;
        if (arr[child] > arr[root]) {
            swap(arr[child], arr[root]);
            root = child;
            child = 2 * root + 1;
        }
        else break;
    }
}
void MySort::quickSort(vector<int>& arr, int left, int right) {
    //区间内只剩一个没有数时，结束递归
    if (left >= right)
        return;
    int index = partition(arr, left, right);
    quickSort(arr, left, index - 1);
    quickSort(arr, index + 1, right);
}
int MySort::partition(vector<int>& arr, int left, int right) {
    int ref = arr[left];
    while (left < right) {
        while (left < right && arr[right] >= ref)
            right--;
        arr[left] = arr[right];
        while (left < right && arr[left] <= ref)
            left++;
        arr[right] = arr[left];
    }
    arr[left] = ref;
    return left;
}

运行实例:

input:

0 9 8 7 6 5 4 3  21 1 -1 -3 90

 

输出:

三个排序算法的输出到文件中

参考博客:(2条消息) 快速排序/堆排序/归并排序总结（C++版）_powerof10的博客-CSDN博客