数据结构实验 实验一 线性表、堆栈和队列的操作与实现

一、实验目的
1、线性表的链表实现：遍历、查找、插入、删除、翻转
2、栈的链式存储结构实现：入栈、出栈
3、队列的链式存储结构的实现：入队、出队
4、线性表、栈和队列的应用实现
二、使用仪器、器材
微机一台
操作系统：WinXP
编程软件：C++
三、实验内容及原理
1、线性表的链表实现
(1) 用随机函数生成10个3位整数(100~999)，把这些整数存于链表中；
(2) 输出链表的内容；
(3) 读入一个整数，查看该整数是否在表中，若在，输出其位置(首位置为1)；
(4) 读入一个整数，以及要插入的位置，把该整数插入到链表中，输出链表的内容(要求判断输入的位置是否合理)；
(5) 读入一个整数，若该整数在链表里，删除该整数，输出链表的内容；
(6) 把链表的内容翻转，输出链表的内容。
2、栈的链式存储结构实现
(1) 用随机函数生成10个3位整数(100~999)，把这些整数应用入栈操作存于堆栈中，在入栈接口处设置断点①，按“F5”启动调试，按“F10”逐句执行，直到数据全部入栈。程序暂停时观察栈顶数据和栈顶位置；
(2) 应用出栈操作输出堆栈的内容，在出栈接口处设置断点②，按“F5”启动调试，按“F10”逐句执行，直到所有数据完全出栈，程序暂停时观察栈顶数据和栈顶位置的变化。
3、队列的链式存储结构的实现
(1) 用随机函数生成10个3位整数(100~999)，把这些整数应用入队操作存于队列中；
(2) 应用遍历操作输出队列的内容；
(3) 把队列的内容翻转，应用出队操作输出队列的内容。
4、线性表、栈和队列的应用实现
(1) 用随机函数生成10个3位整数(100~999)，把这些整数存于单链表中，然后读入一个整数，以该值为基准把单链表分割为两部分，所有小于该值的结点排在大于或等于该值的结点之前。
(2) 假设一个字符串中可以包含三种括号：( )[ ]{}，且这三种括号可以按任意次序嵌套使用(如：“…[…{…}…[…]…]…(…)” 为合法嵌套，“…[…{… )…[…]…]…(…)”为不合法嵌套)。编写判别给定表达式中所含括号是否正确配对出现的算法，如果是合法嵌套则返回为true，如果是不符合法嵌套则返回为false。
(3) 用队列求解迷宫问题的最短路径

#include<iostream>
#include<ctime>
using namespace std;
struct LNode
{
   
    int data;
    LNode* next;
};
void createList(LNode*& L, int n)      //尾插法创建链表
{
   
    L = new LNode;
    L->next = NULL;
    LNode* r;
    r = L;
    LNode* p;
    srand(unsigned(time(NULL)));
    for (int i = 0; i < n; i++)
    {
   
        p = new LNode;
        p->data = rand() % (999 - 100 + 1) + 100;
        p->next = NULL;
        r->next = p;
        r = p;
    }
}
void print(LNode*& p)                //遍历链表
{
   
    LNode* q;
    q = p->next;
    while (q != NULL)
    {
   
        cout << q->data << " ";
        q = q->next;
    }
    cout << endl;
}
int find(LNode*& L, int e)            //查找整数在链表中的位置
{
   
    int local = 1;
    LNode* p;
    p = L->next;
    while(p&&p->data!=e)
    {
   
        local++;
        p = p->next;
    }
    if (p == NULL)
    {
   
        local = -1;
    }
    return local;
}
void Insert(LNode*& L, int i, int e)           //把整数插进链表中
{
   
    LNode* p = L;
    int j = 0;
    while (p && (j < i - 1))
    {
   
        p = p->next;
        j++;
    }
    if (p == NULL || j > i - 1)
    {
   
        cout << "插入位置不合理,程序已退出！" << endl;
        exit(0);
    }
    LNode* s = new LNode;
    s->data = e;
    s->next = p->next;
    p->next = s;
}
void Delete(LNode*& L, int i)                  //删除链表中的指定整数
{
   
    LNode* p = L;
    int j = 0;
    while ((p->next) && (j < i - 1))
    {
   
        p = p->next;
        j++;
    }
    LNode*q = p->next;
    p->next = q->next;
    delete q;
}
void roll(LNode*&L)                    //翻转链表
{
   
    if (L == NULL || L->next == NULL)
    {
   
        return;
    }
    LNode* p = L;
    LNode* q = L->next;
    while (q->next != NULL)
    {
   
        LNode* r = q->next;
        q -> next = r->next;
        r->next = p->next;
        p->next = r;
    }
}
int main()
{
   
    int a,b;
    LNode* p;
    createList(p, 10);
    print(p);
   
    cout << "输入一个整数,查找它在链表中的位置(不存在则输出-1)：";
    cin >> a;
    b = find(p, a);
    if (b != -1)
        cout << "位置为：" << b << endl;
    else
        cout << b << endl;

    int c, d;
    cout << "输入一个整数，以及它要插进链表的位置:";
    cin >> c >> d;
    Insert(p, d, c);
    cout << "输出改变后的链表" << endl;
    print(p);

    int e, f;
    cout << "输入想要删除的整数：" << endl;
    cin >> e;
    f = find(p, e);
    if (f != -1)
    {
   
        cout << "整数在链表中" << endl;
    }
    else
    {
   
        cout << "整数不在链表中" << endl;
        exit(0);
    }
    Delete(p, f);
    cout << "输出删除该整数后的链表" << endl;
    print(p);

    roll(p);
    cout << "输出翻转后的链表" << endl;
    print(p);
}

#include<iostream>
#include<ctime>
using namespace std;
struct LNode
{
   
    int data;
    LNode* next;
};
void Push(LNode*& L, int &e)
{
   
    L = NULL;
    LNode* p = new LNode;
    p->data = e;
    p->next = L