【数据结构】实验：查找和排序算法

XY_墨莲伊

已于 2024-08-19 22:57:48 修改

阅读量824

点赞数 5

文章标签：排序算法算法

于 2024-08-11 21:22:53 首次发布

本文链接：https://blog.csdn.net/m0_73970214/article/details/141111801

版权

一、实验目的

掌握常用查找方法的基本思想及其实现技术；
了解各种查找方法的优缺点和适用范围，能对相关的算法进行性能分析
掌握常用排序方法的基本思想及其实现技术。
了解各种排序方法的优缺点和适用范围，能对相关的算法进行性能分析

二、实验要求

设计一个可实现各种查找的演示程序（如学生信息表）。
设计一个可实现各种排序的演示程序（如学生信息表）

方法提示：用顺序表存储，学生信息表可以直接从某个文件中导入。

参考数据结构(在实验2的基础上进行查找和排序）

typedef struct

{ char no[10];

char name[10];

int score[5];

int total;

}student;

typedef struct

{

student stu[MAXSIZE];

int len;

}SeqList;

1. 实现下列六种查找：（1）顺序查找；（2）二分查找；（3）二叉排序树的查找；（必须实现顺序查找）

2. 实现下列六种排序：（1）冒泡；（2）直接插入排序；（3）选择排序；（4）快速排序; （5）希尔排序；（6）堆排序（至少实现2种排序算法）

三、核心代码

二分查找

int BinarySearch(SeqList *list, char *name) {
    int low = 0;
    int high = list->len - 1;
    while (low <= high) {
        int mid = low + (high - low) / 2;
        int res = strcmp(list->stu[mid].name, name);
        if (res == 0) {
            return mid; // 找到
        } else if (res < 0) {
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    return -1; // 未找到
}

二叉排序树的插入

TreeNode* InsertTreeNode(TreeNode *root, student data) {
    if (root == NULL) {
        root = (TreeNode*)malloc(sizeof(TreeNode));
        root->data = data;
        root->left = root->right = NULL;
    } else if (strcmp(data.name, root->data.name) < 0) {
        root->left = InsertTreeNode(root->left, data);
    } else {
        root->right = InsertTreeNode(root->right, data);
    }
    return root;
}

二叉排序树的查找

TreeNode* SearchTreeNode(TreeNode *root, char *name) {
    if (root == NULL || strcmp(root->data.name, name) == 0) {
        return root;
    }
    if (strcmp(name, root->data.name) < 0) {
        return SearchTreeNode(root->left, name);
    } else {
        return SearchTreeNode(root->right, name);
    }
}

堆排序的辅助函数

void Heapify(student arr[], int n, int i) {
    int largest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    if (left < n && strcmp(arr[left].name, arr[largest].name) > 0)
        largest = left;
    if (right < n && strcmp(arr[right].name, arr[largest].name) > 0)
        largest = right;
    if (largest != i) {
        student swap = arr[i];
        arr[i] = arr[largest];
        arr[largest] = swap;
        Heapify(arr, n, largest);
    }
}

堆排序

void HeapSort(SeqList *list) {
    int n = list->len;
    int i;
    for (i = n / 2 - 1; i >= 0; i--)
        Heapify(list->stu, n, i);
    for (i = n - 1; i > 0; i--) {
        student temp = list->stu[0];
        list->stu[0] = list->stu[i];
        list->stu[i] = temp;
        Heapify(list->stu, i, 0);
    }
}

快速排序的辅助函数

int Partition(student arr[], int low, int high) {
    student pivot = arr[high];
    int i = (low - 1); 
    int j;
    for (j = low; j <= high - 1; j++) {
        if (strcmp(arr[j].name, pivot.name) < 0) {
            i++;
            student temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    student temp = arr[i + 1];
    arr[i + 1] = arr[high];
    arr[high] = temp;
    return (i + 1);
}

快速排序

void QuickSort(student arr[], int low, int high) {
    if (low < high) {
        int pi = Partition(arr, low, high);
        QuickSort(arr, low, pi - 1);
        QuickSort(arr, pi + 1, high);
    }
}