单链表操作

实验目的

实验要求

二叉树操作

前言

软件技术基础实验分为四个部分，涵盖了堆栈的操作、单链表操作、二叉树操作以及查找与排序。在课本的附录页面，提供了基础的C语言源码。鉴于本学期选修了C++，我对这些源码进行了一些修改，并补充了扩展的编程要求，且提供了一些思考题。本人因为最常使用的还是Python，所以曾经研究并手写实现过查找与排序算法，当然后面我也补充了C++版本的源码。本篇博客主要面向SWUST的同学们，旨在解释一些关键的部分，帮助大家顺利完成实验并理解其中的要点。

实验环境：Windows 11、Vistual Studio 2022、PyCharm Community Edition 2021.3.1。

堆栈的操作

实验目的

掌握栈的定义；
掌握栈基本操作的实现，并能用于解决实际问题；

实验要求

用顺序存储结构实现栈的基本操作：Push,pop,isempty,isfull,createstack；

利用栈的基本操作实现conversion()函数，该函数能将任意输入的十进制整数转化为二进制形式表示。

扩展要求：修改程序将任意输入的十进制修改程序将任意输入的十进制整数转化为八进制、十六进制形式表示。

#include<iostream>
#include<cmath>

const int maxsize = 1024;
using namespace std;
typedef int datatype;

//用于规定栈的大小和栈顶
typedef struct {
    datatype elements[maxsize];
    int Top;
}Stack;
//创建空栈
void setStackNull(Stack* S) {
    S->Top = -1;
}
//判满
int isfull(Stack* S) {
    if (S->Top >= maxsize - 1)
        return 1;
    else
        return 0;
}
//判空
int isempty(Stack* S) {
    if (S->Top < 0)
        return 1;
    else
        return 0;
}
//压栈
void push(Stack* S, datatype E) {
    if (isfull(S))
        cout << "Stack Overflow" << endl;
    else {
        S->Top++;
        S->elements[S->Top] = E;
    }
}
//出栈
datatype* pop(Stack* S) {
    datatype* temp;
    if (isempty(S)) {
        cout << "Stack Underflow" << endl;
        return NULL;
    }
    else {
        temp = (datatype*)malloc(sizeof(datatype));
        *temp = S->elements[S->Top];
        S->Top--;
        return (temp);
    }
}
//十进制整数转化为二进制数
void conversion(int n) {
    Stack S;
    setStackNull(&S);
    int r, m;
    r = n;
    while (r) {
        m = r % 2;
        if (isfull(&S))
            cout << "Over flow" << endl;
        else
            push(&S, m);
        r = r / 2;
    }
    cout << "转换后的二进制为：" << endl;
    while (!isempty(&S)) {
        cout << *(pop(&S));
    }
    cout << endl;
}
void conversion2(int n, int r) {
    Stack S;
    int x;
    setStackNull(&S);
    int f = n;
    while (f) {
        if (isfull(&S))
            cout << "Over flow" << endl;
        else
            push(&S, f % r);
        f /= r;
    }
    cout << "数据" << n << "转化为" << r << "进制后的结果为：";
    while (!isempty(&S)) {
        x = *(pop(&S));
        if (x >= 10) {
            cout << (char)('A' + x - 10);
        }
        else {
            cout << x;
        }
    }
    cout << endl;
}
int main() {
    int num;
    cout << "请输入要转换为二进制的十进制数据：" << endl;
    cin >> num;
    conversion(num);

    //扩展3功能
    int n, r;
    cout << "请输入转化的数字以及进制位:" << endl;
    cin >> n >> r;
    conversion2(n, r);

    double mu;
    int nu;
    cout << "请输入m进制转化为n进制中m和n:" << endl;
    cin >> mu >> nu;
    cout << "请输入需要转换的数据:" << endl;
    char arra[1024];
    cin >> arra;
    int s = strlen(arra);
    int sum = 0;
    double j = 0;
    for (int i = s - 1; i >= 0; i--) {
        sum += (arra[i] - '0') * pow(mu, j);
        j++;
    }
    conversion2(sum, nu);
    return 0;
}

代码实现了一个栈数据结构，并提供了一些基本的栈操作函数。栈是一种具有后进先出（LIFO）特性的数据结构，通过压栈和出栈操作实现数据的存储和检索。

具体的代码功能如下：

定义了一个结构体 Stack，包含一个数组 elements 用于存储栈的元素，以及一个整数 Top 用于表示栈顶的位置。
setStackNull 函数用于将栈置空，即将栈顶 Top 设置为 -1。
isfull 函数用于判断栈是否已满，如果栈顶位置 Top 大于等于 maxsize-1，则表示栈已满。
isempty 函数用于判断栈是否为空，如果栈顶位置 Top 小于 0，则表示栈为空。
push 函数用于将元素压入栈中，如果栈已满，则输出 "Stack Overflow"。
pop 函数用于将栈顶元素弹出，并返回其值。如果栈为空，则输出 "Stack Underflow"，并返回 NULL。
conversion 函数用于将十进制整数转换为二进制数。通过除以 2 的余数来逐步转换，并将余数依次压入栈中。然后从栈中依次弹出并输出二进制数。
conversion2 函数用于将一个十进制整数转换为指定进制的数。类似于 conversion 函数，但这里除以的不是 2，而是通过参数 r 指定的进制。
主函数 main 提供了用户交互的界面，可以输入一个十进制数进行转换，以及扩展功能3的操作。

单链表操作

实验目的

掌握线性表的链式存储结构：(1)线性表的链式存储原理；(2)链式存储结构的优缺点；(3)掌握线性表在链式存储结构上的运算
掌握结构体的应用以及数据结点的生成：(1)结构体的定义；(2)动态存储分配函数的使用；(3)强制类型转换的方法
掌握指针的应用：(1)巩固指针的含义和用法；(2)结构体指针的使用

实验要求

完成链表带头结点尾插入法函数。

完成按序号查找函数。

完成插入函数。

扩展要求：完成删除函数。

#include <iostream>
using namespace std;
typedef char datatype;

struct Node {
    datatype data;
    Node* next;
};
typedef Node* linklist;

linklist createlist() {
    char ch;
    linklist head, s, r;
    head = new Node();
    r = head;
    cout << "请输入字符生成链表，以‘#’结束" << endl;
    cin.get(ch);
    while (ch != '#') {
        s = new Node();
        s->data = ch;
        r->next = s;
        r = s;
        cin.get(ch);
    }
    r->next = NULL;  //链表的结束
    return head;   //头指针
}

linklist get(linklist head, int i) {
    int j;        
    linklist p;      
    p = head;
    j = 0;
    while (p->next != NULL && j < i) {  
        p = p->next;
        j++;
    }
    if (i == j)
        return p;
    else
        return NULL;
}

linklist deletelink(linklist head, int i) {
    linklist p = head, q;
    int j = 0;

    while (p ->next != NULL) {  
        j++;
        if (j == i) {
            q = p->next;
            p->next = q->next;
            delete q;
            return head;
        }
        else {
            p = p->next;
        }
    }
    cout << "error" << endl;
    return head;
}

void insertById(linklist head, int i, char x) {
    linklist s, p;
    int j;
    s = new Node();
    s->data = x;
    p = head;
    j = 0;
    while (p != NULL && j < i) {
        j++;
        p = p->next;
    }
    if (p != NULL) {
        s->next = p->next;
        p->next = s;
    }
    else {
        cout << "结点未找到！" << endl;
    }
}

int main() {
    linklist head, r;
    int num;

    head = createlist();
    cout << "链表信息为：";
    r = head->next;
    while (r) {
        cout << r->data;
        r = r->next;
    }
    cout << endl;

    cout << "请输入要查询的序号：" << endl;
    cin >> num;
    r = get(head, num);
    if (r == NULL)
        cout << "没有查到" << endl;
    else
        cout << "查找的结果为：" << r->data << endl;

    cout << "请输入要删除的序号：" << endl;
    int i;
    cin >> i;
    head = deletelink(head, i);
    cout << "删除后链表信息为：";
    r = head->next;
    while (r) {
        cout << r->data;
        r = r->next;
    }
    cout << endl;

    cout << "请输入要插入的序号和字符：" << endl;
    int N;
    char x;
    cin >> N >> x;
    insertById(head, N, x);
    cout << "插入后链表信息为：";
    r = head->next;
    while (r) {
        cout << r->data;
        r = r->next;
    }

    return 0;
}

这段代码实现了链表的创建、查找、删除和插入等基本操作。

具体的代码功能如下：

定义了一个结构体 Node，包含一个数据成员 data 和一个指向下一个节点的指针 next。
定义了一个类型别名 linklist，表示指向链表节点的指针。
createlist 函数用于创建一个链表，用户输入字符并生成链表，以 '#' 结束输入。
get 函数用于根据序号获取链表中对应节点的指针，遍历链表直到找到对应位置的节点，返回该节点的指针。
deletelink 函数用于删除链表中指定位置的节点，遍历链表直到找到对应位置的节点，删除该节点并释放内存。
insertById 函数用于在链表的指定位置插入一个节点，遍历链表直到找到对应位置的节点，插入新节点并更新指针。
在主函数 main 中，通过调用上述函数来执行链表的创建、查找、删除和插入操作，并在控制台输出相应的结果。

二叉树操作

实验目的

掌握二叉树的二叉链表存储结构。掌握二叉树的二叉链表存储结构。
掌握利用二叉树创建方法。
掌握二叉树的先序、中序、后序的递归实现方法。

实验要求

编写创建如图1-1所示二叉树的函数，函数名：create。

编写递归实现二叉树的中序、先序和后序遍历算法。函数名分别为inorder,preorder,postorder。

编写主函数测试以上二叉树的创建和遍历函数。

图1-1

#include <iostream>
#include <cstdlib>
using namespace std;

const int maxsize = 1024;
typedef char datatype;
typedef struct node {
    datatype data;
    struct node* lchild;
    struct node* rchild;
} Bitree;

Bitree* CreateTree() {
    char ch;                       //接收用户输入的节点值
    Bitree* Q[maxsize];            //指针数组 Q，用于辅助构建二叉树，指针类型的数组构成队列
    int front, rear;               //用于指示数组 Q 的前后位置
    Bitree* root, * s;             //指针变量 root 和 s
    root = NULL;                   //初始时二叉树为空
    front = 1;                     //表示数组 Q 的初始状态
    rear = 0;

    cout << "请输入二叉树的各个结点，@表示虚结点，#表示结束：" << endl;
    cin >> ch;
    while (ch != '#') {
        cout << ch;
        s = NULL;            //s 初始化为 NULL
        if (ch != '@') {                                                      
            s = (Bitree*)malloc(sizeof(Bitree));                   
            s->data = ch;                       //节点值赋值给 s 的 data 成员
            s->lchild = NULL;//s 的左孩子指针 lchild 
            s->rchild = NULL; //s 的右孩子指针 lchild 
        }
        rear++;                                 //rear 增加 1，并将 s 存储在 Q 数组的对应位置
        Q[rear] = s;
        if (rear == 1)                          //rear 的值为 1，即为第一个节点，将 root 指向 s
            root = s;
        else {
            if (s && Q[front])
                if (rear % 2 == 0)
                    Q[front]->lchild = s;       //如果是偶数，则将s赋值给Q[front]节点的左孩子指针lchild
                else
                    Q[front]->rchild = s;
            if (rear % 2 == 1)                  //前节点是一个新的层级的节点
                front++;
        }                                       //指向下一层的节点,指针 front 向下移动
        cin >> ch;
    }
    return root;                                //返回二叉树的根节点指针root。
}

void preorder(Bitree* p) {
    if (p != NULL) {
        cout << " " << p->data << " ";
        preorder(p->lchild);                    //以当前节点 p 的左孩子作为参数，实现前序遍历左子树。
        preorder(p->rchild);
    }
}

void inorder(Bitree* p) {
    if (p != NULL) {
        inorder(p->lchild);                     //当前节点 p 的左孩子作为参数，实现中序遍历左子树
        cout << " " << p->data << " ";
        inorder(p->rchild);
    }
}

void postorder(Bitree* p) {
    if (p != NULL) {
        postorder(p->lchild);
        postorder(p->rchild);
        cout << " " << p->data << " ";
    }
}

int main() {
    Bitree* root;
    root = CreateTree();
    cout << "\n先序遍历结果如下：" << endl;
    preorder(root);
    cout << "\n中序遍历结果如下：" << endl;
    inorder(root);
    cout << "\n后序遍历结果如下：" << endl;
    postorder(root);
    cout << endl;
    return 0;
}

这段代码实现了二叉树的基本操作。

具体的代码功能如下：

ch接收用户输入的节点值、指针数组 Q，用于辅助构建二叉树，指针类型的数组构成队列、front表示队列Q的前部位置，用于指示下一个节点应该插入到哪个位置、rear表示队列Q的尾部位置，用于指示当前队列中最后一个节点的位置
rear为奇数时，表示当前节点是一个新的层级的节点，需要递增front，以便在下一次插入节点时，将新节点链接到正确的父节点。front指示下一个节点的插入位置，rear表示当前队列中最后一个节点的位置
preorder、inorder、postorder为先序遍历、中序遍历、后续遍历
主函数main 中，通过调用上述函数来执行链表的创建、查找、删除和插入操作，并在控制台输出相应的结果

查找与排序

实验目的

了解数据查找的一系列方法：(1)了解查找表的分类；(2)掌握折半查找法的原理
掌握各种排序（简单插入，简单选择，冒泡排序，快速排序等）方法及适用场合，并能在解决实际问题时灵活应用。
了解查找与排序在实际生活中的应用。

实验要求

顺序查找：首先从键盘输入一个数据序列生成一个顺序表，然后从键盘上任意输入一个值，在顺序表中进行查找。

折半查找：任意输入一组数据作为各数据元素的键值，首先将此序列进行排序，然后在该有序表上使用折半查找算法进行对给定值的查找。

对于给定的某无序序列，分别用直接插入、希尔排序、快速排序等方法进行排序，并输出每种排序下的各趟排序结果。

查找算法

基本要求是做这两个，重点还是理解折半查找。

a.顺序查找


#include <iostream>
#include <vector>
using namespace std;

typedef int datatype;
typedef struct
{
    vector<datatype> elem;
    int length;
} Stable;

void create(Stable* l)
{
    cout << "请输入顺序表的内容:" << endl;
    for (int i = 0; i < l->length; i++)
    {
        datatype data;
        cout << "l.elem[" << i + 1 << "] = ";
        cin >> data;
        l->elem.push_back(data);
    }
}

void s_search(const Stable* l, datatype k)
{
    bool found = false;
    for (int i = 0; i < l->length; i++)
    {
        if (l->elem[i] == k)
        {
            cout << "查找成功." << endl;
            found = true;
            cout << "l.elem[" << i + 1 << "] = " << k << endl;
        }
    }
    if (!found)
    {
        cout << "没有找到数据" << k << "！" << endl;
    }
}

int main()
{
    Stable table;
    datatype key;

    cout << "请输入顺序表的长度: ";
    cin >> table.length;

    create(&table);

    cout << "创建的顺序表内容:" << endl;
    for (int i = 0; i < table.length; i++)
    {
        cout << "l.elem[" << i + 1 << "] = " << table.elem[i] << endl;
    }

    cout << "输入查找关键字: ";
    cin >> key;

    s_search(&table, key);

    return 0;
}

示例：

b.折半查找

#include <iostream>
using namespace std;

const int MAX = 100;

typedef struct {
    int element[MAX + 1];
    int length;
} Stable;

void create_seq(Stable* l)
{
    cout << "请输入顺序表的内容:" << endl;
    for (int i = 0; i < l->length; i++)
    {
        cout << "l.element[" << i + 1 << "] = ";
        cin >> l->element[i];
    }
}

void sort_seq(Stable* l)
{
    int flag, t;
    for (int i = 0; i < l->length - 1; i++)
    {
        flag = 0;
        for (int j = 0; j < (l->length) - 1 - i; j++)
        {
            if (l->element[j] > l->element[j + 1])
            {
                t = l->element[j + 1];
                l->element[j + 1] = l->element[j];
                l->element[j] = t;
                flag = 1;
            }
        }
        if (flag == 0)
            break;
    }
}

int sea_self(const Stable* l, int k, int low, int high)
{
    if (low > high)
    {
        cout << "没有找到查找的值" << endl;
        return -1;
    }
    int mid = (low + high) / 2;
    if (l->element[mid] == k)
    {
        cout << "查找成功" << endl;
        cout << "l[" << mid + 1 << "] = " << k << endl;
        return mid;
    }
    else
    {
        if (l->element[mid] < k)
            return sea_self(l, k, mid + 1, high);
        else
            return sea_self(l, k, low, mid - 1);
    }
}

int main()
{
    Stable table;
    int key;

    cout << "请输入线性表的长度：";
    cin >> table.length;

    create_seq(&table);

    sort_seq(&table);

    cout << "排序后的数据" << endl;
    for (int i = 0; i < table.length; i++)
    {
        cout << "l[" << i + 1 << "] = " << table.element[i] << endl;
    }

    cout << "请输入查找的值：" << endl;
    cin >> key;

    sea_self(&table, key, 0, table.length - 1);

    return 0;
}

示例：

排序算法

实现插入排序、希尔排序、快速排序。

a.Python

# 插入排序
def insert_sort(R):
    for i in range(1, len(R)):
        temp = R[i]
        j = i - 1
        while j >= 0 and temp['key'] < R[j]['key']:
            R[j + 1] = R[j]
            j -= 1
        R[j + 1] = temp

# 希尔排序
def shell_sort(R):
    n = len(R)
    h = n // 2
    while h > 0:
        for j in range(h, n):
            temp = R[j]
            i = j - h
            while i >= 0 and temp['key'] < R[i]['key']:
                R[i + h] = R[i]
                i -= h
            R[i + h] = temp
        h //= 2

# 快速排序
def partition(R, low, high):                                  #用于划分数组并返回基准元素的位置。它通过交换元素的方式将小于基准的元素放在基准的左边，大于基准的元素放在基准的右边。
    i = low
    j = high
    pivot = R[i]
    while i < j:
        while i < j and R[j]['key'] >= pivot['key']:
            j -= 1
        if i < j:
            R[i] = R[j]
            i += 1
        while i < j and R[i]['key'] < pivot['key']:
            i += 1
        if i < j:
            R[j] = R[i]
            j -= 1
    R[i] = pivot
    return i

def quick_sort(R, low, high):
    if low < high:
        pivot_pos = partition(R, low, high)
        quick_sort(R, low, pivot_pos - 1)
        quick_sort(R, pivot_pos + 1, high)

if __name__ == "__main__":
    # 26 5 37 1 61 11 59 15 48 19
    s = 11
    R = [{'key': 0} for _ in range(s)]

    # 插入排序
    print("请输入使用插入算法排序的10个数据，以空格分隔:")
    input_str = input()
    input_list = input_str.split()
    for i in range(1, s):
        R[i]['key'] = int(input_list[i-1])
    print("插入排序之前:")
    for i in range(1, s):
        print(R[i]['key'], end="\t")
    insert_sort(R)
    print("\n插入排序之后:")
    for i in range(1, s):
        print(R[i]['key'], end="\t")

    # 希尔排序
    print("\n请输入使用希尔算法排序的10个数据，以空格分隔:")
    input_str = input()
    input_list = input_str.split()
    for i in range(s-1):
        R[i]['key'] = int(input_list[i])
    print("\n希尔排序之前:")
    for i in range(s-1):
        print(R[i]['key'], end="\t")
    shell_sort(R)
    print("\n希尔排序之后:")
    for i in range(s-1):
        print(R[i]['key'], end="\t")

    # 快速排序
    print("\n请输入使用快排算法排序的10个数据，以空格分隔:")
    input_str = input()
    input_list = input_str.split()
    for i in range(1, s):
        R[i]['key'] = int(input_list[i-1])
    print("\n快排排序之前:")
    for i in range(1, s):
        print(R[i]['key'], end="\t")
    quick_sort(R, 1, s-1)
    print("\n快排排序之后:")
    for i in range(1, s):
        print(R[i]['key'], end="\t")

示例：

b.C++

#include<iostream>
#include<ctime>
#include<cstdio>
#include<cstring>
using namespace std;
const int s = 11;
typedef char datatype;
typedef struct
{
    int key;
    datatype others;//记录的其他域
} rectype;
/*插入排序*/
void InsertSort(rectype R[])
{
    int i, j;
    for (i = 2; i < s; i++)//插入的数据分别在1到n当中
    {
        memcpy(&R[0], &R[i], sizeof(rectype));
        j = i - 1;
        while (R[0].key < R[j].key)
        {
            R[j + 1] = R[j];//将关键字大于R[i].key 记录后移
            j--;
        }
        R[j + 1] = R[0];
    }
}
/*希尔排序*/
void ShellSort(rectype R[], int n)
{
    int i, j, h;
    rectype temp;
    h = n / 2;
    while (h > 0)
    {
        for (j = h; j <= n - 1; j++)
        {
            temp = R[j];
            i = j - h;
            while ((i >= 0) && temp.key < R[i].key)
            {
                R[i + h] = R[i];
                i = i - h;
            }
            R[i + h] = temp;

        }
        h /= 2;//增量为1排序后终止算法
    }

}
int Partition(rectype R[], int l, int h)
{
    int i, j;
    rectype temp;
    i = l;
    j = h;
    temp = R[i];//快排第一次的基准
    int flag = 1;//修改flag
    while (flag)
    {
        while ((R[j].key >= temp.key) && (i < j))
            j--;
        if (i < j)
            R[i++] = R[j];
        while ((R[i].key < temp.key) && (i < j))
            i++;
        if (i < j)
            R[j--] = R[i];
        if (i == j)
            flag = 0;
    }//这段可以结合快排算法结合理解
    R[i] = temp;
    return i;
}
void QuickSort(rectype R[], int s1, int t1)
{
    int i;
    if (s1 < t1)
    {
        i = Partition(R, s1, t1);//对R[s1]~R[t1]作划分
        QuickSort(R, s1, i - 1);
        QuickSort(R, i + 1, t1);
    }
}
int main()
{
    // /t的含义是跳格
    rectype R[s];
    int i;
    /*插入测试*/
    cout << "请输入使用插入算法排序的10个数据" << endl;
    for (i = 1; i < s; i++)
    {
        cin >> R[i].key;
    }
    cout << "插入排序之前" << endl;
    for (i = 1; i < s; i++)
    {
        cout << R[i].key << "\t";
    }
    InsertSort(R);
    cout << endl << "插入排序之后" << endl;
    for (i = 1; i < s; i++)
    {
        cout << R[i].key << "\t";
    }
    /*希尔测试*/
    cout << endl << "请输入使用希尔算法排序的10个数据" << endl;
    for (i = 0; i < s - 1; i++)
    {
        cin >> R[i].key;
    }
    cout << endl << "希尔排序之前" << endl;
    for (i = 0; i < s - 1; i++)
    {
        cout << R[i].key << "\t";
    }
    ShellSort(R, 10);
    cout << endl << "希尔排序之后" << endl;
    for (i = 0; i < s - 1; i++)
    {
        cout << R[i].key << "\t";
    }
    /*快排测试*/
    cout << endl << "请输入使用快排算法排序的10个数据" << endl;
    for (i = 1; i < s; i++)
    {
        cin >> R[i].key;
    }
    cout << endl << "快排排序之前" << endl;
    for (i = 1; i < s; i++)
    {
        cout << R[i].key << "\t";
    }
    QuickSort(R, 1, 10);
    cout << endl << "快排排序之后" << endl;
    for (i = 1; i < s; i++)
    {
        cout << R[i].key << "\t";
    }
}

示例：

实验总结

祝各位同学能够顺利的完成实验，师兄先给未来的大佬们敬杯茶。

SWUST软件技术基础实验笔记

前言

堆栈的操作

实验目的

实验要求

单链表操作

实验目的

实验要求

二叉树操作

实验目的

实验要求

查找与排序

实验目的

实验要求

查找算法

排序算法

实验总结

猜你喜欢