线性表、栈和队列的应用实现

简介: 线性表、栈和队列的应用实现

线性表、栈和队列的应用实现

(1) 用随机函数生成10个3位整数(100~999),把这些整数存于单链表中,然后读入一个整数,以该值为基准把单链表分割为两部分,所有小于该值的结点排在大于或等于该值的结点之前。

(2) 假设一个字符串中可以包含三种括号:( )[ ]{},且这三种括号可以按任意次序嵌套使用(如:“…[…{…}…[…]…]…(…)” 为合法嵌套,“…[…{… )…[…]…]…(…)”为不合法嵌套)。编写判别给定表达式中所含括号是否正确配对出现的算法,如果是合法嵌套则返回为true,如果是不符合法嵌套则返回为false。

(3) 用队列求解迷宫问题的最短路径

(1)

#include <iostream>
#include<math.h>
#include<ctime>
using namespace std;
#define OK 1
#define ERROR 0
typedef int Status;
typedef int LElemType;
typedef int SElemType;
typedef int QElemType;
typedef struct LNode {
  LElemType data;
  struct LNode* next;
  LNode* LRear;
  int length;
}LNode, * LinkList;
//创建空表
Status EmList(LinkList& L)
{
  L = new LNode;
  L->next = NULL;
  L->LRear = L;
  L->length = 0;
  return OK;
}
//链表的存储
Status StoreElem(LinkList& L, LElemType& e)
{
  LNode* p = new LNode;
  p->data = e;
  p->next = NULL;
  L->LRear->next = p;
  L->LRear = p;
  L->length++;
  return OK;
}
// 输出链表内容
Status ShowElem(LinkList& L)
{
  LNode* p = L->next;
  cout << "链表输出:" << endl;
  for (int i = 0; i < L->length; i++)
  {
    cout << p->data << ends;
    p = p->next;
  }
  cout << endl << endl;
  return OK;
}
Status CreateList(LinkList& L)
{
  for (int i = 0; i < 10; ++i)
  {
    int j = rand() % 900 + 100;
    StoreElem(L, j);
  }
  ShowElem(L);
  LElemType measure;
  cout << "请输入一个整数,以该值为基准把单链表分割为两部分" << endl;
  cin >> measure;
  LNode* flag = L;
  for (int i = 0, j = 10; i < j; i++)
  {
    if (flag->next->data >= measure)
    {
      L->LRear->next = flag->next;
      L->LRear = flag->next;
      flag->next = flag->next->next;
      L->LRear->next = NULL;
    }
    else flag = flag->next;
  }
  ShowElem(L);
  return OK;
}
int main()
{
  time_t t;   // 定义时间变量
  srand((unsigned)time(&t));  //由时间确定随机序列,执行一次
  LinkList L;
  EmList(L);
  CreateList(L);
}

(2)

#include<iostream>
#include<string>
#include<stack>
#include<map>
using namespace std;
bool judge(string s) {
    map<char, char> map_s = { {'(',')'},{'[',']'},{'{','}'} };
    stack<char> temp;
    for (int i = 0; i < s.length(); ++i) {
        if (map_s.find(s[i]) != map_s.end())
            temp.push(map_s[s[i]]);
        else {
            if (temp.empty())
                return false;
            if (s[i] == temp.top())
                temp.pop();
            else
                return false;
        }
    }
    if (temp.empty())
        return true;
    else
        return false;
}
int main()
{
    string str;
    while (1)
    {
        getline(cin, str);
        if (str.length() == 0) break;
        if (judge(str)) puts("合法嵌套");
        else puts("非法嵌套");
    }
    return 0;
}

(3)

#include <iostream>
using namespace std;
#define OK 1
#define ERROR 0
typedef int Status;
typedef int QElemType;
//队列链式存储结构
typedef struct QNode
{
  QElemType idata;
  QElemType jdata;
  struct QNode* next;
}QNode, * QueuePtr;
typedef struct
{
  QueuePtr front;//队头指针
  QueuePtr rear;//队尾指针
}LinkQueue;
//创建空队列
Status InitQueue(LinkQueue& Q)
{
  Q.front = Q.rear = new QNode;
  Q.front->next = NULL;
  return OK;
}
//入队
Status InQueue(LinkQueue& Q, QElemType i, QElemType j)
{
  QNode* p = new QNode;
  p->idata = i;
  p->jdata = j;
  p->next = NULL;
  Q.rear->next = p;
  Q.rear = p;
  return OK;
}
//出队
Status DeQueue(LinkQueue& Q, int e)
{
  if (Q.front == Q.rear)  return ERROR;
  QNode* pQ = Q.front->next;  //p指向队头
  Q.front->next = pQ->next; //修改头结点指针域
  if (e == 1) //若是迷宫没有路,则e==0,不输出值
    cout << "a[ " << pQ->idata << " ][ " << pQ->jdata << " ]>" ;
  if (Q.rear == pQ) Q.rear = Q.front;  //最后元素被删,尾指针指向队头
  delete pQ;
  DeQueue(Q, e);
  return OK;
}
//求迷宫最短路径
Status LookFor(LinkQueue& Load, int* a, QElemType i, QElemType j)
{
  if (i == 5 && j == 5)
  {
    InQueue(Load, i, j);
    return OK;
  }
  if (a[(j + 1) + i * 6] == 0 && j != 5)
  {
    a[(j + 1) + i * 6] = 1;
    InQueue(Load, i, j);
    LookFor(Load, a, i, j + 1);
  }
  else if (a[j + (i + 1) * 6] == 0 && i != 5)
  {
    a[j + (i + 1) * 6] = 1;
    InQueue(Load, i, j);
    LookFor(Load, a, i + 1, j);
  }
  else if (a[(j - 1) + i * 6] == 0 && j != 0)
  {
    a[(j - 1) + i * 6] = 1;
    InQueue(Load, i, j);
    LookFor(Load, a, i, j - 1);
  }
  else if (a[j + (i - 1) * 6] == 0 && i != 0)
  {
    a[j + (i - 1) * 6] = 1;
    InQueue(Load, i, j);
    LookFor(Load, a, i, j - 1);
  }
  return OK;
}
//输出迷宫
void ShowMaze(int* a)
{
  cout << "迷宫:" << endl;
  for (int i = 0; i < 6; i++)
  {
    for (int j = 0; j < 6; j++)
      cout << a[i * 6 + j] << ends;
    cout << endl;
  }
}
int main()
{
  LinkQueue Load;
  InitQueue(Load);
  int flag = 1;//用来控制出队时是否要输出值
  int a[6 * 6] =    //创建迷宫,1为障碍,0为道路
  {
    0,0,0,1,0,1,
    1,1,0,0,0,1,
    1,1,0,0,0,0,
    0,0,0,1,0,1,
    0,1,1,1,1,1,
    0,0,0,0,0,0
  };
  ShowMaze(a);
  cout << "该迷宫路径:" << endl;
  LookFor(Load, a, 0, 0);
  if (Load.rear->idata != 5 || Load.rear->jdata != 5) //判断是否达到终点
  {
    flag = 0; cout << "错误,没有路" << endl;
    DeQueue(Load, flag);
  }
  else
  {
    flag = 1;
    cout << endl;
    DeQueue(Load, flag);
  }
  cout << endl << endl;
  int a0[6 * 6] =    //去不了终点的迷宫
  {
    0,1,1,1,0,1,
    0,0,0,1,1,1,
    1,0,0,0,0,1,
    1,0,1,1,0,1,
    1,1,1,1,0,1,
    1,1,1,1,0,0
  };
  ShowMaze(a0);
  LookFor(Load, a0, 0, 0);
  if (Load.rear->idata != 5 || Load.rear->jdata != 5)
  {
    flag = 0; cout << "错误,没有路" << endl; 
    DeQueue(Load, flag);
  }
  else
  {
    cout << "该迷宫路径:" << endl;
    flag = 1;
    cout << endl;
    DeQueue(Load, flag);
  }
  cout << endl << endl;
  int a2[6 * 6] =    //全是1的迷宫
  {
    1,1,1,1,1,1,
    1,1,1,1,1,1,
    1,1,1,1,1,1,
    1,1,1,1,1,1,
    1,1,1,1,1,1,
    1,1,1,1,1,1
  };
  ShowMaze(a2);
  cout << "该迷宫路径:" << endl;
  LookFor(Load, a2, 0, 0);
  if (Load.rear->idata != 5 || Load.rear->jdata != 5)
  {
    flag = 0; cout << "错误,没有路" << endl; 
    DeQueue(Load, flag);
  }
  else
  {
    flag = 1;
    cout << endl;
    DeQueue(Load, flag);
  }
  cout << endl << endl;
  int a1[6 * 6] =    //全是0的迷宫
  {
    0,0,0,0,0,0,
    0,0,0,0,0,0,
    0,0,0,0,0,0,
    0,0,0,0,0,0,
    0,0,0,0,0,0,
    0,0,0,0,0,0
  };
  ShowMaze(a1);
  cout << "该迷宫路径:" << endl;
  LookFor(Load, a1, 0, 0);
  if (Load.rear->idata != 5 || Load.rear->jdata != 5)
  {
    flag = 0; cout << "错误,没有路" << endl;
    DeQueue(Load, flag);
  }
  else
  {
    flag = 1;
    cout << endl;
    DeQueue(Load, flag);
  }
  cout << endl << endl;
}


相关文章
|
5天前
|
存储 C语言 C++
【C++数据结构——栈与队列】顺序栈的基本运算(头歌实践教学平台习题)【合集】
本关任务:编写一个程序实现顺序栈的基本运算。开始你的任务吧,祝你成功!​ 相关知识 初始化栈 销毁栈 判断栈是否为空 进栈 出栈 取栈顶元素 1.初始化栈 概念:初始化栈是为栈的使用做准备,包括分配内存空间(如果是动态分配)和设置栈的初始状态。栈有顺序栈和链式栈两种常见形式。对于顺序栈,通常需要定义一个数组来存储栈元素,并设置一个变量来记录栈顶位置;对于链式栈,需要定义节点结构,包含数据域和指针域,同时初始化栈顶指针。 示例(顺序栈): 以下是一个简单的顺序栈初始化示例,假设用C语言实现,栈中存储
116 75
|
5天前
|
存储 C++ 索引
【C++数据结构——栈与队列】环形队列的基本运算(头歌实践教学平台习题)【合集】
【数据结构——栈与队列】环形队列的基本运算(头歌实践教学平台习题)【合集】初始化队列、销毁队列、判断队列是否为空、进队列、出队列等。本关任务:编写一个程序实现环形队列的基本运算。(6)出队列序列:yzopq2*(5)依次进队列元素:opq2*(6)出队列序列:bcdef。(2)依次进队列元素:abc。(5)依次进队列元素:def。(2)依次进队列元素:xyz。开始你的任务吧,祝你成功!(4)出队一个元素a。(4)出队一个元素x。
27 13
【C++数据结构——栈与队列】环形队列的基本运算(头歌实践教学平台习题)【合集】
|
5天前
|
存储 C语言 C++
【C++数据结构——栈与队列】链栈的基本运算(头歌实践教学平台习题)【合集】
本关任务:编写一个程序实现链栈的基本运算。开始你的任务吧,祝你成功!​ 相关知识 初始化栈 销毁栈 判断栈是否为空 进栈 出栈 取栈顶元素 初始化栈 概念:初始化栈是为栈的使用做准备,包括分配内存空间(如果是动态分配)和设置栈的初始状态。栈有顺序栈和链式栈两种常见形式。对于顺序栈,通常需要定义一个数组来存储栈元素,并设置一个变量来记录栈顶位置;对于链式栈,需要定义节点结构,包含数据域和指针域,同时初始化栈顶指针。 示例(顺序栈): 以下是一个简单的顺序栈初始化示例,假设用C语言实现,栈中存储整数,最大
31 9
|
5天前
|
C++
【C++数据结构——栈和队列】括号配对(头歌实践教学平台习题)【合集】
【数据结构——栈和队列】括号配对(头歌实践教学平台习题)【合集】(1)遇到左括号:进栈Push()(2)遇到右括号:若栈顶元素为左括号,则出栈Pop();否则返回false。(3)当遍历表达式结束,且栈为空时,则返回true,否则返回false。本关任务:编写一个程序利用栈判断左、右圆括号是否配对。为了完成本关任务,你需要掌握:栈对括号的处理。(1)遇到左括号:进栈Push()开始你的任务吧,祝你成功!测试输入:(()))
25 7
|
2月前
|
C语言
【数据结构】栈和队列(c语言实现)(附源码)
本文介绍了栈和队列两种数据结构。栈是一种只能在一端进行插入和删除操作的线性表,遵循“先进后出”原则;队列则在一端插入、另一端删除,遵循“先进先出”原则。文章详细讲解了栈和队列的结构定义、方法声明及实现,并提供了完整的代码示例。栈和队列在实际应用中非常广泛,如二叉树的层序遍历和快速排序的非递归实现等。
265 9
|
2月前
|
存储 算法
非递归实现后序遍历时,如何避免栈溢出?
后序遍历的递归实现和非递归实现各有优缺点,在实际应用中需要根据具体的问题需求、二叉树的特点以及性能和空间的限制等因素来选择合适的实现方式。
42 1
|
2月前
|
存储 缓存 算法
在C语言中,数据结构是构建高效程序的基石。本文探讨了数组、链表、栈、队列、树和图等常见数据结构的特点、应用及实现方式
在C语言中,数据结构是构建高效程序的基石。本文探讨了数组、链表、栈、队列、树和图等常见数据结构的特点、应用及实现方式,强调了合理选择数据结构的重要性,并通过案例分析展示了其在实际项目中的应用,旨在帮助读者提升编程能力。
80 5
|
2月前
|
存储 算法 Java
数据结构的栈
栈作为一种简单而高效的数据结构,在计算机科学和软件开发中有着广泛的应用。通过合理地使用栈,可以有效地解决许多与数据存储和操作相关的问题。
|
2月前
|
存储 JavaScript 前端开发
执行上下文和执行栈
执行上下文是JavaScript运行代码时的环境,每个执行上下文都有自己的变量对象、作用域链和this值。执行栈用于管理函数调用,每当调用一个函数,就会在栈中添加一个新的执行上下文。
|
2月前
|
存储
系统调用处理程序在内核栈中保存了哪些上下文信息?
【10月更文挑战第29天】系统调用处理程序在内核栈中保存的这些上下文信息对于保证系统调用的正确执行和用户程序的正常恢复至关重要。通过准确地保存和恢复这些信息,操作系统能够实现用户模式和内核模式之间的无缝切换,为用户程序提供稳定、可靠的系统服务。
59 4