数据结构快速排序与堆排序的实现

最新推荐文章于 2023-01-29 14:19:25 发布

Zix1ng

最新推荐文章于 2023-01-29 14:19:25 发布

阅读量1k

点赞数

分类专栏：数据结构文章标签：数据结构排序算法算法

本文链接：https://blog.csdn.net/Zix1ng/article/details/122048774

版权

数据结构专栏收录该内容

3 篇文章 0 订阅

订阅专栏

堆排序：

（1）问题描述

对于无序正整数序列，写程序用堆排序算法将其排序成按值非递减有序序列。

（2）输入描述

文本文件“input.txt”中保存了n个测试用例，文件以-1结束。每个用例的第一行m表示待排序正整数序列的元素个数，第二行为该序列的m个正整数。

（3）输出描述

输出结果保存在文本文件“output.txt”中。对于每个测试用例均有二行输出，第一行输出“Case #:##”，#表示用例的编号（1…n），##表示排序后有序序列的元素个数，第二输出##个按值非递减有序元素。

快速排序

（1）问题描述

对于任意的无序正整数序列，写程序用快速排序算法将其排序成按值非递减有序序列。

（2）输入描述

文本文件“input.txt”中保存了n个测试用例，文件以-1结束。每个用例的第一行m表示第一个待排序整数序列的元素个数，第二行为该序列的m个元素。

（3）输出描述

（4）输入示例

10 1 8 4 30

35 60 50 2 20 4 86

38 100 45

-1

（5）输出示例

Case 1:5

4 8 10 30

Case 2:7

2 4 20 35 50 60 86

Case 3:3

38 45 100


#include<stdio.h>
#include<stdlib.h>

typedef int ElementType;
#define MAX_SIZE 5000
#define SWAP(x,y,t)((t) = (x) , (x) = (y), (y) = (t))
#define LeftChild(i) (2*(i)+1) 
int ReadDataFile(FILE* fin, ElementType A[], int& n);
void WriteDataFile(ElementType A[], FILE* fout, int CaseID, int N);
void heapSort(ElementType A[], int N);
void PercDown(ElementType A[], int i, int N);
void Quicksort(ElementType A[], int left, int right);
int Partition(ElementType A[], int left, int right);

void  main() {
    ElementType A[MAX_SIZE];
    FILE* fin, * fout;
    int n;
    int CaseID = 0;
    fin = fopen("input.txt", "r");
    fout = fopen("output.txt", "w");
    while (1) {
        if (ReadDataFile(fin, A, n) == -1)break;
        heapSort(A, n);
        /*Quicksort(A, 0, n-1);*/
        WriteDataFile(A, fout, ++CaseID, n);
    }
    fclose(fout);
    fclose(fin);
    system("pause");
}
int ReadDataFile(FILE* fin, ElementType A[], int& N) {
    fscanf(fin, "%d", &N);
    if (N == -1) return N;
    for (int i = 0; i < N; i++) {
        fscanf(fin, "%d", &A[i]);
    }
    return 0;

}
void WriteDataFile(ElementType A[], FILE* fout, int CaseID, int N) {
    fprintf(fout, "CaseID: %d\n", N);
    for (int i = 0; i < N; i++) {
        fprintf(fout, "%10d", A[i]);
    }
    fprintf(fout, "\n");
}
void heapSort(ElementType A[], int N) {
    int i;
    ElementType temp;
    for (i = N / 2; i >= 0; i--) /* BuildHeap */
        PercDown(A, i, N);
    for (i = N - 1; i > 0; i--) {
        SWAP(A[0], A[i], temp); /* DeleteMax */
        PercDown(A, 0, i);

    }
}
void PercDown(ElementType A[], int i, int N) {
    int Child;
    ElementType Tmp;
    for (Tmp = A[i]; LeftChild(i) < N; i = Child)
    {
        Child = LeftChild(i);
        if (Child != N - 1 && A[Child + 1] > A[Child])
            Child++;
        if (Tmp < A[Child])
            A[i] = A[Child];
        else
            break;
    }
    A[i] = Tmp;

}
void Quicksort(ElementType A[], int left, int right) {
    if (left < right) {
        int nextWhere = Partition(A, left, right);
        Quicksort(A, left, nextWhere - 1);
        Quicksort(A, nextWhere + 1, right);
    }
}
int Partition(ElementType A[], int left, int right) {
    ElementType pivot = A[left];
    ElementType temp;
    while (left < right) {
        while (pivot < A[right]) --right;
        while (pivot > A[left]) ++left;
        SWAP(A[right], A[left], temp);
    }
    A[left] = pivot;
    return left;
}