顺序栈、循环链表、链栈的基本操作（链队待更新）

熟人看不到

已于 2023-12-02 22:32:13 修改

阅读量411

点赞数

分类专栏：数据结构及算法 C语言数据结构文章标签：数据结构算法 c语言链表学习

于 2023-11-16 21:42:07 首次发布

本文链接：https://blog.csdn.net/qq_73625278/article/details/134451215

版权

C语言同时被 3 个专栏收录

27 篇文章 1 订阅

订阅专栏

数据结构及算法

5 篇文章 0 订阅

订阅专栏

数据结构

4 篇文章 0 订阅

订阅专栏

实验一：建立顺序栈实现入栈、出栈和输出栈内元素值

一算法设计思路

二源程序代码

三运行结果截图

实验二：建立循环队列实现入队出队和输出队列元素值

一算法设计思路

二源程序代码

三运行结果截图

实验三：实现链栈的基本操作：构造、销毁、清空、是否栈空、返回链栈长度、取栈顶元素、入栈新元素、栈顶元素出栈、遍历链栈。

一实验内容及要求

实验内容：

1. 编程实现栈的如下功能：

（1）根据输入的栈中元素个数n和各元素值建立一个顺序栈，并输出栈中各元素值。

（2）将数据元素e入栈，并输出入栈后的顺序栈中各元素值。

（3）将顺序栈中的栈顶元素出栈，并输出出栈元素的值和出栈后顺序栈中各元素值。

2. 编程实现队列的如下功能：

（1）根据输入的队列长度n和各元素值建立一个循环顺序表表示的队列（循环队列），并输出队列中各元素值。

（2）将数据元素e入队，并输出入队后的队列中各元素值。

（3）将循环队列的队首元素出队，并输出出队元素的值和出队后队列中各元素值。

3. 以下实验题目二选一

（1）建立链式栈，实现栈的初始化、进栈、出栈等典型操作。

（2）建立链队列，实现队列的初始化、进队、出队、判空、判满、遍历等典型操作。

二实验要求：

1.键盘输入数据；

2.屏幕输出运行结果。

3.要求记录实验源代码及运行结果。

4.运行环境：CodeBlocks/Dev c++/VC6.0等C编译环境

三实验过程及运行结果

实验一：建立顺序栈实现入栈、出栈和输出栈内元素值

一算法设计思路

包含五个功能函数和一个主函数：OutputStack(Stack s)、InitialStack(Stack &s)、PushSingel(Stack& s)、Push(Stack& s)、Pop(int &x,Stack &s)、main()

OutputStack(Stack s)：接受一个栈作为参数。该函数的作用是输出栈中的元素。首先，定义一个指针变量p，并将其初始化为栈顶元素的地址，接下来，使用while循环遍历栈中的元素。循环的条件是p不等于栈底元素的地址。在循环内部，每次迭代将p指向前一个元素。

InitialStack(Stack &s)：初始化一个栈，接受一个栈对象s作为参数。首先声明了一个整数变量n，用于存储栈中最大元素的个数。接着，使用new关键字动态分配一个大小为maxSize的整型数组，并将其地址赋给栈对象s的base属性。这样，栈对象的base属性就指向了栈的起始位置。最后，将栈对象的top属性设置为base属性的值，表示栈顶的位置与栈底的位置相同。

PushSingel(Stack& s)：首先，函数检查栈是否已满。如果栈顶位置减去栈底位置大于等于栈的最大容量，说明栈已满。函数会提示用户输入要入栈的元素，并将其存储在变量x中。然后，函数将x的值赋给栈顶位置，并将栈顶位置加1，表示栈顶向下移动了一个位置。最后，函数再次调用OutputStack(s)函数来显示当前栈的状态。

Push(Stack& s)：首先，函数检查栈是否已满。如果栈顶位置减去栈底位置大于等于栈的最大容量，说明栈已满。如果栈未满，函数会提示用户输入要入栈的元素个数，并将其存储在变量n中。然后，使用一个循环来逐个输入要入栈的元素。在每次循环中，函数再次检查栈是否已满。如果栈未满，函数会提示用户输入第i+1个要入栈的元素，并将其存储在变量x中。然后将x的值赋给栈顶位置，并将栈顶位置加1，表示栈顶向下移动了一个位置。最后，函数调用OutputStack(s)函数来显示当前栈的状态。

Pop(int &x,Stack &s)：用于从栈中弹出一个元素函数首先检查栈是否为空，如果栈为空，则输出"栈空！"并返回。如果栈不为空，函数将执行以下操作：1. 将栈顶元素的值赋给变量x。2. 输出被删除的栈顶元素是x。3. 如果栈不是空的（即栈底指针不等于栈顶指针），则调用OutputStack(s)函数来显示当前栈的状态。4. 如果栈是空的（即栈底指针等于栈顶指针），则输出"目前栈空！"。

二源程序代码

#define _CRT_SECURE_NO_WARNINGS 1                                                                           

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <math.h>

#include <iostream>



using namespace std;



/*1. 编程实现栈的如下功能：

（1）根据输入的栈中元素个数n和各元素值建立一个顺序栈，并输出栈中各元素值。

（2）将数据元素e入栈，并输出入栈后的顺序栈中各元素值。

（3）将顺序栈中的栈顶元素出栈，并输出出栈元素的值和出栈后顺序栈中各元素值。

*/

//没有栈满那句提示，能一直输入？

typedef struct Stack

{

    int *base=NULL;

    int* top=NULL;

    int maxSize=0;

};

void OutputStack(Stack s)

{

    cout << "目前栈中的元素从上到下为：\n" << endl;

    int* p = s.top;

    while (p!=s.base)

    {

        p--;

        cout << *p << " ";

    }

    puts("");

}

void InitialStack(Stack &s)

{

    int n;//n代表栈的元素个数

    printf("请输入栈中最大元素的个数：");

    scanf("%d", &n);

    s.maxSize = n;

   

    /*s.base = (int*)malloc( sizeof(int)*s.maxSize);*/

    s.base = new int[s.maxSize];

    s.top = s.base;



    //s.base=new int(s.maxSize)//此操作是把s.base指针开辟一个空间，初始值变为s.maxsize;

    //以下两种都可以开辟一个数组空间，并把首地址指向s.base

     //s.base = (int*)malloc(5 * s.maxSize);*/ /*[区别？] */

}

void PushSingel(Stack& s)

{

    if (s.top - s.base >= s.maxSize)

    {

        printf("栈已满!\n");

        OutputStack(s);



        return;

    }

   

    for (int i = 0; i < 1; i++)

    {

        int x;

        printf("请输入本次要入栈的元素:\n");

        scanf("%d", &x);

        *s.top = x;

        s.top++;

    }

    OutputStack(s);

}

void Push(Stack& s)

{

    if (s.top - s.base >= s.maxSize)

    {

        printf("栈已满!\n");

        OutputStack(s);  return;}

    printf("请输入本次要入栈的元素个数:\n");

    int n;

    scanf("%d", &n);

    for (int i = 0; i < n; i++)

    {

        if (s.top - s.base >= s.maxSize)

        {

             printf("栈已满!\n");

             OutputStack(s);

             return;

        }

        int x;

        printf("请输入第%d个要入栈的元素:\n", i + 1);

        scanf("%d", &x);

        *s.top = x;

        s.top++;

    }

    OutputStack(s);

}

void Pop(int &x,Stack &s)

{

    if (s.base == s.top)

    {

        printf("栈空！\n"); return;

    }

    x = *--s.top;

    printf("被删除的栈顶元素是：%d\n", x);

    if (!(s.base == s.top))

    OutputStack(s);

    else

    {

        cout << "目前栈空！" << endl;

    }

}

int main()

{

    Stack s;

    int PopVal;

    int choice;


    InitialStack(s);

    //Push(s);

    //OutputStack(s);

    //Pop(PopVal, s);

    while (1)

    {

        printf("\n1.批量元素入栈\n");

        printf("2.单个元素入栈\n");

        printf("3.栈顶元素出栈\n");

        printf("4.输出栈内元素\n");

        printf("5.退出\n");

        printf("请输入要执行的操作的选项:\n");

        scanf("%d", &choice);

        switch (choice)

        {

        case 1:

             Push(s);

             break;

        case 2:

             PushSingel(s);

             break;

        case 3:

             Pop(PopVal,s);

             break;

        case 4:

             OutputStack(s);

             break;

        case 5:

             exit(1);

             break;

        default:

             printf("请输入正确选项\n");

             break;

        }

    }

    return 0;

}

三运行结果截图

实验二：建立循环队列实现入队出队和输出队列元素值

一算法设计思路

包含五个功能函数和一个主函数：OutQueue(Queue q)、InitialQueue(Queue &q)、InQueue(Queue &q)、Pop(int &x,Queue&q)、InQueueSingle(Queue& q)、main()

OutQueue(Queue q)：该函数的作用是输出队列中的元素。首先，函数检查队列是否为空。如果队列的队尾指针q.rear等于队头指针q.top，则表示队列为空，函数会输出"队空！"。如果队列不为空通过循环遍历队列中的元素。循环从队头指针q.top开始，直到队尾指针q.rear的前一个位置（使用模运算实现循环）。在每次循环中，函数会打印出当前位置的元素值。最后，函数输出一个空行。

InitialQueue(Queue &q)：这段代码是一个初始化队列的函数。它接受一个队列对象作为参数，并设置队列的最大元素个数、队列的基地址、队头指针和队尾指针。首先，通过printf函数提示用户输入队列中可以存储的最大元素个数，并将其存储在变量n中。然后，将n + 1赋值给队列对象的maxsize属性，表示队列的最大容量为n + 1。使用new关键字动态分配一个大小为q.maxsize的整型数组，并将其地址赋值给队列对象的base属性，用于存储队列的元素。将队列的队头指针top和队尾指针rear都初始化为0，表示队列为空。

InQueue(Queue &q)：用于将元素插入队列中。函数接受一个引用参数q，表示要操作的队列对象。函数首先检查队列是否已满，如果满了则输出提示信息并返回。否则，它会要求用户输入要入队元素的个数，然后循环执行以下步骤：1.提示用户输入第i个要入队的元素。2. 读取输入的元素值。3. 将元素值存储在队列的尾部位置。4. 再次检查队列是否已满，如果满了则输出提示信息5. 如果队列未满，则将队列的尾部指针向后移动一位，以便下一个元素入队。6. 循环结束后，调用OutQueue函数打印队列的内容。

Pop(int &x,Queue&q)：用于从队列中删除并返回队尾元素。函数接受两个参数：一个整数引用x和一个队列对象q。函数首先声明了一个指针变量p，接下来，函数检查队列是否为空。如果队列为空（即q.rear == q.top），则输出提示信息。否则，函数将队尾元素赋值给x，并将队列的顶部指针向后移动一位（即q.top++）。最后，函数调用OutQueue的函数来打印队列的内容。

InQueueSingle(Queue& q)：用于将一个元素插入队列中。函数接受一个引用参数q，表示要操作的队列对象。函数首先检查队列是否已满，如果队列已满（即 (q.rear + 1) % q.maxsize == q.top），则输出提示信息"队列已满！"并返回。接下来，函数使用一个循环来执行入队操作。循环只执行一次，因此只会将一个元素插入队列中。在每次循环中，函数会提示用户输入要入队的元素，并将其存储在变量ele中。然后，函数将该元素赋值给队列的下一个可用位置，即q.base[q.rear] = ele。再次检查队列是否已满，如果队列已满，则输出提示信息"队列已满！"并返回。否则，将队列的尾部指针向后移动一位，以便下一个元素入队，即q.rear = (q.rear + 1) % q.maxsize。最后，函数调用OutQueue的函数来打印队列的内容。

二源程序代码

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <math.h>

#include <iostream>



using namespace std;



typedef struct Queue

{

    int maxsize;

    int* base;

    int top;

    int rear;

};



void OutQueue(Queue q)

{

    if (q.rear == q.top)

    {

        printf("\n队空！");

    }

    else

    {

        printf("目前队列中元素有：");

    for (int i = q.top; i != q.rear; i = (i + 1) % q.maxsize)

    {

        printf("%d ", q.base[i]);

    }

    }

    puts("");



}

void InitialQueue(Queue &q)

{

    int n;

    printf("请输入队列中可以存储的最大元素个数：");

    scanf("%d", &n);

    q.maxsize = n + 1;

    q.base = new int[q.maxsize];

    q.top = 0;

    q.rear = 0;

}

void InQueue(Queue &q)

{

    if ((q.rear + 1) % q.maxsize == q.top)

    {

        printf("队列已满！\n");

        return;

    }

    int n;

    cout << "请输入要入队元素的个数:\n";

    scanf("%d", &n);

    for (int i = 0; i < n; i++)

    {

        int ele;

        printf("请输入第%d个要入队的元素：\n",i + 1);

        scanf("%d", &ele);

        q.base[q.rear] = ele;

   

        if ((q.rear + 1) % q.maxsize == q.top)

        {

             printf("队列已满！\n");

             OutQueue(q);



             return;

        }//如果满了不做操作

        else

             q.rear = (q.rear+1) % q.maxsize;//如果没满 移向下一个位置

    }

    OutQueue(q);

}





void Pop(int &x,Queue&q)

{

    int* p;

    if (q.rear == q.top)

    {

        cout << "队列为空,无元素可删除，请先添加元素！" << endl;

    }

    else

    {

        x = q.base[q.top];

        q.top++;

    }

    printf("被删除的元素是：%d", x);

    OutQueue(q);

}



void InQueueSingle(Queue& q)

{

    if ((q.rear + 1) % q.maxsize == q.top)

    {

        printf("队列已满！\n");

        return;

    }

    int n;



    for (int i = 0; i < 1; i++)

    {

        int ele;

        printf("请输入要入队的元素:", i + 1);

        scanf("%d", &ele);

        q.base[q.rear] = ele;



        if ((q.rear + 1) % q.maxsize == q.top)

        {

             printf("队列已满！\n");

             return;

        }//如果满了不做操作

        else

             q.rear = (q.rear + 1) % q.maxsize;//如果没满 移向下一个位置

    }

    OutQueue(q);

}

int main()

{

    Queue q;

    int PopVal;

    int choice;


    InitialQueue(q);

    while (1)

    {

        printf("\n1.批量元素入队\n");

        printf("2.单个元素入队\n");

        printf("3.栈顶元素出队\n");

        printf("4.输出队内元素\n");

        printf("5.退出\n");

        printf("请输入要执行的操作的选项:\n");

        scanf("%d", &choice);

        switch (choice)

        {

        case 1:

             InQueue(q);

             break;

        case 2:

             InQueueSingle(q);

             break;

        case 3:

             Pop(PopVal, q);

             break;

        case 4:

             OutQueue(q);

             break;

        case 5:

            exit(1);

             break;

        default:

             printf("请输入正确选项\n");

             break;

        }

    }

        return 0;

}

三运行结果截图

实验三：实现链栈的基本操作：构造、销毁、清空、是否栈空、返回链栈长度、取栈顶元素、入栈新元素、栈顶元素出栈、遍历链栈。

一、算法设计思路

包含五个功能函数和一个主函数：ExistLinkStack(LinkStackp &s)、EmptyLinkStack(LinkStackp& s)、InitialLinkStack(LinkStackp &cur)、ClearLinkStack(LinkStackp& cur)、DestoryLinkStack(LinkStackp &s)、InputLinkStack(LinkStackp& cur)、OutputLinkStack(LinkStackp cur)、GetLength(LinkStackp s)、GetTopEle(LinkStackp s)、 PopLinkStack(LinkStackp& s)、void ErgodicLinkStack(LinkStackp s)

ExistLinkStack(LinkStackp &s)：它接受一个指向LinkStack的指针作为参数。函数的目的是检查这个栈是否存在。如果栈不存在（即指针为NULL），则返回false；否则，返回true。

EmptyLinkStack(LinkStackp& s)：它接受一个指向链表栈的指针作为参数。该函数的作用是判断链表栈是否为空。函数内部通过检查链表栈的头节点的下一个节点是否为NULL来判断链表栈是否为空。如果头节点的下一个节点为NULL，则说明链表栈为空，返回true；否则，说明链表栈不为空，返回false。

InitialLinkStack(LinkStackp &cur)：这段代码是一个函数，用于初始化一个链栈。它接受一个指向链栈的指针作为参数，并执行以下操作：

首先，检查链栈是否已经存在。如果不存在，则输出提示信息，并创建一个新的链栈对象，将其赋值给传入的指针变量cur。

然后，提示用户输入要储存的数据，以-1为结尾。

初始化链表头节点的下一个节点为NULL。

使用循环来读取用户输入的数据，直到输入的数据为-1为止。

在每次循环中，创建一个新的链表节点对象p，将用户输入的数据存储在节点的data成员中，并将当前节点的下一个节点设置为新创建的节点p。然后将指针变量cur更新为新创建的节点p。

最后，输出提示信息，表示数据已全部储存完毕。

ClearLinkStack(LinkStackp& cur)：这段代码是一个函数，用于清空一个链栈。它接受一个指向链栈的指针作为参数，并使用循环遍历链表，逐个释放节点的内存空间，直到链表为空。最后输出一条消息表示栈已被清空。

DestoryLinkStack(LinkStackp &s)：这段代码是一个函数，用于销毁一个链栈。它接受一个指向链栈的指针作为参数，并执行以下操作：首先，通过调用EmptyLinkStack函数检查链栈是否为空。如果链栈不为空，则继续执行下一步；否则，直接返回。调用ClearLinkStack函数清空链栈中的所有元素。将传入的指针s设置为NULL，表示链栈已被销毁。使用printf函数输出一条消息，提示用户栈已被销毁。

InputLinkStack(LinkStackp& cur)：这段代码是一个函数，用于将数据输入到一个链栈中。函数接受一个指向链栈的指针作为参数。首先，函数会检查链栈是否已经存在，如果不存在，则调用InitialLinkStack函数来初始化链栈。如果链栈已经存在，则会提示用户输入要储存的数据，以-1为结尾。接下来，函数使用循环来读取用户输入的数据，直到用户输入-1为止。在每次循环中，函数会创建一个新的节点，并将用户输入的数据存储在该节点的data成员中。然后，将新节点的next成员设置为当前链表的头节点，以便将新节点添加到链表的末尾。最后，更新当前链表的头节点为新节点。当用户输入-1时，循环结束。

OutputLinkStack(LinkStackp cur)：这段代码是一个函数，用于输出一个链栈的内容。函数接受一个指向链栈的指针作为参数。首先，函数会检查链栈是否存在，如果不存在，则输出"目前栈不存在！"。然后，函数会检查链栈是否为空，如果为空，则输出"目前栈为空！"。否则，函数会从栈顶开始遍历链栈，依次输出每个元素的值，直到栈底。最后，函数会输出换行符

。

ErgodicLinkStack(LinkStackp s)：这段代码是一个函数，它接受一个指向链表的指针作为参数。该函数的作用是遍历整个链表，直到到达链表的末尾。在函数内部，使用了一个while循环来遍历链表。循环的条件是s->next != NULL，表示当前节点的下一个节点不为空。在每次循环中，将指针s更新为下一个节点s = s->next，以便继续遍历链表。循环结束时，指针s将指向链表的最后一个节点，即链表的末尾。

GetLength(LinkStackp s)：这段代码是一个函数，它接受一个指向链表的指针作为参数。该函数的作用是计算链表的长度。首先，函数通过调用ExistLinkStack(s)来检查传入的指针是否为有效的链表。如果链表存在，则进入循环，否则直接返回-1表示链表不存在。在循环中，使用变量count来记录链表中的元素个数。每次循环时，将count加1，并将指针s更新为下一个节点s = s->next。当s->next为NULL时，表示已经到达链表的末尾，此时跳出循环。

最后，函数返回count作为链表的长度。

GetTopEle(LinkStackp s)：这段代码是一个函数，它接受一个指向链栈的指针作为参数。该函数的作用是获取链栈的栈顶元素。首先，函数会检查传入的链栈指针是否有效，即是否存在。如果链栈不存在，函数会输出"目前栈不存在！"并返回-1。

接下来，函数会检查链栈是否为空。如果链栈为空，函数会输出"目前栈空！"并返回-1。

最后，如果链栈存在且不为空，函数会返回链栈的栈顶元素的值。

PopLinkStack(LinkStackp& s)：这是一个函数，它接受一个指向链栈的指针s作为参数。这个函数的主要目的是从链栈中弹出一个元素。函数首先检查链栈是否存在或者是否为空。如果链栈不存在或者为空，函数将输出一条错误消息，并返回-1。

如果链栈存在并且不为空，函数将执行以下操作：

1. 创建一个临时指针p，并将其指向链栈的下一个节点。

2. 将链栈的当前节点的数据复制到变量re中。

3. 释放链栈当前节点的内存。

4. 将链栈的指针s设置为临时指针p，从而跳过当前节点，直接指向下一个节点。

5. 输出被删除的元素的值。

6. 调用OutputLinkStack函数，以显示更新后的链栈

二源程序代码

3. 以下实验题目二选一

（1）建立链式栈，实现栈的初始化、进栈、出栈等典型操作。

（2）建立链队列，实现队列的初始化、进队、出队、判空、判满、遍历等典型操作。

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <math.h>

#include <iostream>



using namespace std;

typedef struct LinkStack

{

    int data;

    struct LinkStack* next;

}*LinkStackp;

bool ExistLinkStack(LinkStackp &s)

{

    if (s==NULL)

        return false;

    else

        return true;

}//销毁后判断栈是否存在，如果不存在则新建



bool EmptyLinkStack(LinkStackp& s)

{

    if (s->next == NULL)

        return true;

    else

        return false;

}//是否为空



void InitialLinkStack(LinkStackp &cur)

{

    if (!ExistLinkStack(cur))

    {

        cout << "目前无已存在的链栈，已为您建立新的链栈" << endl;

        cur = new LinkStack;

    }

   

   

        printf("请输入要储存的数据，以-1为结尾\n");

        int data = 0;

        cur->next = NULL;



        while (data != -1)

        {

             scanf("%d", &data);

            if (data != -1)

             {

                 LinkStackp p = new LinkStack;

                 p->data = data;

                 p->next = cur;

                 cur = p;

             }

        }

        cout << "数据已全部储存完毕！" << endl;

   

}//初始化链栈

void ClearLinkStack(LinkStackp& cur)

{

    LinkStackp initai=cur;//标记初始位置

    while (cur ->next!=NULL)

    {

        LinkStackp p = cur->next;

        free(cur);

        cur = p;

    }

    cout << "栈已被清空！" << endl;

}//清空



void DestoryLinkStack(LinkStackp &s)

{

    if(!EmptyLinkStack(s))

    ClearLinkStack(s);

   

    s = NULL;

    printf("栈已被销毁！\n");

}//销毁链栈  //是否存在栈函数？ 初始化进行修改？再创建一个栈？

//11.14 销毁之后 再入栈的时候 栈底也有数值了 销毁没写对

void InputLinkStack(LinkStackp& cur)

{

    if (!ExistLinkStack(cur))

        InitialLinkStack(cur);

    else

    {

        printf("请输入要储存的数据，以-1为结尾\n");

        int data;

        scanf("%d", &data);



        while (data != -1)

        {

             if (data != -1)

             {

                 LinkStackp p = new LinkStack;

                 p->data = data;

                 p->next = cur;

                 cur = p;

             }

             scanf("%d", &data);

        }

        cout << "数据已全部储存完毕！" << endl;

    }

}//输入栈元素



void OutputLinkStack(LinkStackp cur)

{

    if (!ExistLinkStack(cur))

        printf("目前栈不存在！\n");

    if (EmptyLinkStack(cur))

    {

        cout<<"目前栈为空！"<<endl;

    }

    else

    {

        cout << "栈内元素从栈顶到栈底以此为" << endl;

             while (cur->next != NULL)

             {

                 cout << cur->data << " ";

                     cur = cur->next;

             }

        cout << endl;

    }

}//输出



void ErgodicLinkStack(LinkStackp s)

{

    while (s->next != NULL)

    {

        s = s->next;

    }

}//遍历



int GetLength(LinkStackp s)

{

    if (ExistLinkStack(s))

    {

        int count = 0;

        while (s->next != NULL)

        {

             count++;

             s = s->next;

        }

        return count;

    }

    else

    return -1;



}//返回长度



int GetTopEle(LinkStackp s)

{

    if (!ExistLinkStack(s))

    {

        cout << "目前栈不存在！" << endl; return -1;

    }

    else if (EmptyLinkStack(s))

    {   cout << "目前栈空！\n" << endl;

    return -1;

}

    else

    {

       

        return s->data;

    }

}//取栈顶元素



int PopLinkStack(LinkStackp& s)

{

    if ( !ExistLinkStack(s)|| EmptyLinkStack(s))

    {

        cout << "目前栈不存在，或为空！" << endl;

        return -1;

    }

    else

    {

    int res=0;

    LinkStackp p = s->next;

    res = s->data;

    free(s);



    s = p;

    cout << "被删除的元素是" << res << endl;

    OutputLinkStack(s);

    }

}

int main()

{

    int Val;

    int choice;


    ios::sync_with_stdio(0);

    cin.tie(0);//cout cin快，对函数中使用是否有效？

    LinkStack s;

    LinkStackp cur = &s;

    InitialLinkStack(cur);

    //OutputLinkStack(cur);

    while (1)

    {

        printf("\n1.批量元素入栈\n");

        printf("2.输出栈内元素\n");

        printf("3.清空栈\n");

        printf("4.栈顶元素出栈\n");

        printf("5.销毁栈\n");

        printf("6.输出栈顶元素\n");

        printf("7.查看目前链栈的长度\n");

        printf("8.退出\n");

        printf("请输入要执行的操作的选项:\n");

        scanf("%d", &choice);

        switch (choice)

        {

        case 1:

             InputLinkStack(cur);

             break;

        case 2:

             OutputLinkStack(cur);

             break;

        case 3:

             ClearLinkStack(cur);

             break;

        case 4:

             PopLinkStack(cur);

             break;

        case 5:

             DestoryLinkStack(cur);

             break;

        case 6:

        if(GetTopEle(cur)!=-1)

             cout << "目前栈顶元素是：" << GetTopEle(cur) << endl;

             break;

        case 7:

             if (GetLength(cur) == -1)

                 cout << "链栈不存在！" << endl;

             else

                 cout << GetLength(cur)<< endl;

             break;

        case 8:

             exit(1);

        default:

             printf("请输入正确选项\n");

             break;

        }

    }

    return 0;

}

三运行结果截图

四调试情况、设计技巧及体会

实验中出现的典型错误和修改方法：

顺序栈中所遇问题：

1. 内存分配错误：在创建顺序栈时，需要动态分配内存空间给栈的各个节点。内存分配失败或出现异常，可能会导致程序崩溃或产生不可预期的结果。

2. 栈溢出：当栈满时，再进行入栈操作会导致栈溢出。需要设置一个变量来记录栈的当前大小，并在入栈前判断该变量是否已经达到了栈的最大容量。

3. 栈下溢：当栈空时，再进行出栈操作会导致栈下溢。同样需要设置一个变量来记录栈的当前大小，并在出栈前判断该变量是否为零。

4. 错误的元素访问：在对栈中的元素进行访问、修改或删除操作时，可能会出现索引越界的错误。需要确保访问的元素位置在栈的有效范围内。

5. 忘记释放内存：在使用完顺序栈后，需要释放其占用的内存空间。可以使用循环来逐个释放栈的节点的内存空间。

6. 错误的入栈和出栈顺序：在实现顺序栈时，需要注意入栈和出栈的顺序。例如，先进行入栈操作再进行出栈操作，或者反过来，都可能导致不符合预期的结果。

7. 没有输出结果：在实现顺序栈的功能时，需要确保每次操作后都能输出栈中的元素值。可以在每次操作后使用循环遍历栈，并输出其中的元素值。

实现循环队列中所遇问题：

1. 下标越界：循环队列使用两个指针分别表示队头和队尾，如果计算或操作不当，可能会导致下标越界错误。例如，当队尾指针加1后超过数组长度时，应该将其重置为0；同样地，当队头指针减1后小于0时，也应该将其重置为数组长度-1。

2. 入队和出队操作的合法性检查：在进行入队和出队操作之前，需要先判断队列是否已满或空。如果未进行合法性检查，可能会导致数据丢失或产生错误的输出结果。

3. 假溢出：循环队列是按照先进先出的原则进行入队和出队的，但在某些情况下可能会出现假溢出现象。即当队列已满时，继续执行入队操作会导致数据覆盖原有的元素。为了避免这种情况，可以在入队前判断队列是否已满，并采取相应的处理措施，如提示用户或者丢弃新元素。

4. 并发访问冲突：如果在多线程环境下使用循环队列，可能会出现并发访问冲突的问题。为了解决这个问题，可以使用互斥锁或其他同步机制来保证对队列的操作是原子性的。

5. 内存泄漏：在使用动态分配内存的方式实现循环队列时，需要注意释放不再使用的内存空间，以避免内存泄漏问题。可以通过手动调用delete或free函数来释放内存空间。

实现链栈基本操作中所遇问题：

1. 空指针异常：如果尝试访问空指针所指向的节点，将会导致空指针异常。因此，在使用链表之前需要先进行判空操作。

2. 内存泄漏：如果在链表中插入或删除节点时没有正确地释放内存空间，可能会导致内存泄漏。为了避免这种情况，可以使用智能指针来自动管理内存。

3. 循环引用：在实现链表时，需要注意避免出现循环引用的情况。这可能导致程序陷入无限循环或者无法正常退出。可以通过设置一个标记节点来检测循环引用并采取相应的处理措施。

4. 并发访问冲突：如果在多线程环境下使用链表，可能会出现并发访问冲突的问题。为了解决这个问题，可以使用互斥锁或其他同步机制来保证对链表的操作是原子性的。

5. 栈溢出：当链表的长度超过系统允许的最大长度时，可能会导致栈溢出错误。为了避免这种情况，可以在插入元素前检查链表的长度，并在必要时采取相应的处理措施，如弹出旧元素或提示用户。

实验中学到的技巧和积累的经验：

在完成实现顺序栈、循环队列和链栈的实验之后，我深刻体会到了数据结构的重要性和灵活性。

首先，通过实现这些基础的数据结构，我对它们的特性和工作原理有了更深入的理解。顺序栈是一种先进后出的数据结构，只能在栈顶进行插入和删除操作；循环队列是一种首尾相接的数据结构，可以在队头和队尾进行插入和删除操作；而链栈则是一种基于链表实现的栈结构，具有更高的灵活性和可扩展性。通过编写代码实现这些数据结构，我更加清楚地了解了它们的内部实现原理和逻辑。

这个实验让我意识到数据结构的设计和选择对程序的效率和性能有着重要的影响。不同的数据结构适用于不同的场景和问题，选择合适的数据结构能够提高程序的运行效率和减少不必要的资源消耗。例如，在实现循环队列时，需要考虑如何避免假溢出的问题，以及如何在多线程环境下保证并发访问的正确性。通过思考和实践，我学会了根据具体需求来选择合适的数据结构，并优化其性能。

此外，这个实验也提高了我的编程能力和解决问题的能力。在实现过程中，我遇到了很多错误和困难，但通过不断调试和排错，最终成功地实现了这些数据结构。这个过程锻炼了我的逻辑思维能力、问题分析和解决能力，同时也加深了我对编程语言和算法的理解。

总的来说，通过完成这个实验，我不仅学到了具体的数据结构和算法知识，更重要的是培养了一种系统思维和解决问题的能力。这对我今后的学习和工作都具有重要的意义。我相信在今后的实践中，我会更加注重数据结构的选择和应用，以写出更高效、更优雅的代码。

熟人看不到

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
顺序栈、循环链表、链栈的基本操作（链队待更新）

1. 编程实现栈的如下功能：（1）根据输入的栈中元素个数n和各元素值建立一个顺序栈，并输出栈中各元素值。（2）将数据元素e入栈，并输出入栈后的顺序栈中各元素值。（3）将顺序栈中的栈顶元素出栈，并输出出栈元素的值和出栈后顺序栈中各元素值。2. 编程实现队列的如下功能：（1）根据输入的队列长度n和各元素值建立一个循环顺序表表示的队列（循环队列），并输出队列中各元素值。（2）将数据元素e入队，并输出入队后的队列中各元素值。（3）将循环队列的队首元素出队，并输出出队元素的值和出队后队列中各元素值。
复制链接

扫一扫