实验四 栈和队列的定义与实现（未完成）

最新推荐文章于 2021-12-09 16:26:35 发布
转载 最新推荐文章于 2021-12-09 16:26:35 发布 · 1.1k 阅读 · 3
文章标签：

#数据结构

本文介绍了一个关于栈和队列的数据结构实验，包括使用顺序栈和链栈解决括号匹配问题、判断回文序列，以及使用队列的不同存储结构解决实际问题等。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、 实验目的：
1. 深入了解栈的存储结构和运算特点。
2. 熟练掌握栈的基本运算。
3. 深入了解队列的特性。
4. 掌握队列的两种存储结构和运算方法。
二、 实验内容：
1. 栈：
分别使用顺序栈和链栈各完成以下栈的应用之一。
（1） 括号匹配问题。判断一个表达式中所含有多种括号是否匹配。
（2） 判断回文。 判断一个字符串的内容是否是回文
（3） 数制转换问题。将一个十进制数转换为十六进制形式输出。
例：26 转换为 1A
（4） 大数加法问题。将两个用字符串表示的大数，进行加法运算，并保存为和字符串。
2. 队列：
（1） 分别实现队列的顺序存储结构（循环队列），队列的链式存储结构。
（2） （选做）运用队列实现打印杨辉三角。
（1） 括号匹配问题。判断一个表达式中所含有多种括号是否匹配。
使用顺序栈解决：
接口Istack:

接口Istack：
package ch03;
public interface Istack
{
        public void clear();         //将一个已经存在的栈置为空
        public boolean isEmpty();//判断栈是否为空
        public int length();        //返回栈中个数据元素的个数
        public  Object peek();
                            //读取栈项元素，若栈为空，则返回为空
        public void push(Object x) throws Exception;
                                    //入栈：将数据元素压入栈顶
        public Object pop();        //出栈：删除并返回栈顶元素
}

顺序栈SqStack:

package ch03;
public class SqStack implements Istack
{
        private Object[]stackElem;  //对象数组
        private int top;
        //如果栈为空，top=0,否则表示栈顶元素的下一个存储位置

    //构造方法，构造一个存储空间容量为k的空栈
        public SqStack(int k)
        {
            top = 0;
            stackElem = new Object[k];
        }
        //栈置空
        public void clear()
        {
            top = 0;
        }

        //判断栈是否为空
        public boolean isEmpty()
        {
            return top == 0;
        }

        //求栈中数据元素的个数
        public int length()
        {
            return top;
        }

        //取栈顶元素
        public Object peek()
        {
            if(!isEmpty())
            {
                return stackElem[top-1];
            }
            else 
            return null;
        }

        //入栈
        public void push(Object x) throws Exception
        {
            if(top == stackElem.length)
             throw new Exception("栈已满！");
            else
                stackElem[top++]= x;
        }

        //出栈
        public Object pop()
        {
            if(isEmpty())
                return null;
            else
           return stackElem[--top];
        /*  {
                top = top-1;
                return stackElem[top];
            }*/
        }

        public void display()
        {
            for(int i = top-1;i>=0;i--)
            System.out.print(stackElem[top].toString()+" ");
        }
    }

测试类Example1.java:

package ch03;
import java.util.Scanner;
public class Example1
{
        private final int LEFT = 0;
        private final int RIGHT = 1;
        private final int OTHER = 2;

        //判断括号类型
        public int verifyFlag(String str)
        {
    if("(".equals(str)||"[".equals(str)||"{".equals(str)||"/*".equals(str))
        return LEFT;
        else if(")".equals(str)||"[".equals(str)||"{".equals(str)||"*/".equals(str))
        return RIGHT;
        else 
        return OTHER;
    }

    //检验左括号与右括号是否匹配
    public boolean match(String str1,String str2)
    {
    if("(".equals(str1)&&")".equals(str2)||"[".equals(str1)&&"]".equals(str2)||"{".equals(str1)&&"}".equals(str2)||"/*".equals(str1)&&"*/".equals(str2))
        return true;
        else
        return false;
    }

    private boolean isLegal(String str) throws Exception
    {
        if(!"".equals(str)&&str!=null)
        {
            SqStack S = new SqStack(100);
            int length = str.length();
            for(int i=0;i<length;i++)
            {
                char c = str.charAt(i);
                String t = String.valueOf(c);
                if(i!= length)
                {
                    if(('/') == c && '*' == str.charAt(i + 1) ||('*'==c && '/'==str.charAt(i+1)))
                    {
                        t = t.concat(String.valueOf(str.charAt(i+1)));
                        ++i;
                    }
                }
                if(LEFT == verifyFlag(t))
                {
                    S.push(t);
                }
                else if (RIGHT == verifyFlag(t))
                {
                    if(S.isEmpty()||!match(S.pop().toString(),t))
                    {
                        throw new Exception("错误！Java语句不合法！！！");
                    }
                }
            }
            if(!S.isEmpty())
            throw new Exception("错误:java 语句不合法！");
            return true;
        }
        else 
            throw new Exception("错误;java 语句为空！");
    }

    public static void main(String []args) throws Exception
    {
        Example1 e1 = new Example1();
        System.out.println("请输入分Java语句:");
        Scanner sc = new Scanner(System.in);
        if(e1.isLegal(sc.nextLine()))
        System.out.println("java语句合法！");
        else
        System.out.println("错误！Java语句不合法！");
    }
}

运行结果：
这里写图片描述

（2） 判断回文。 判断一个字符串的内容是否是回文

//判断字符序列是否为回文序列，若是则返回true,否则返回false;
        public Boolean isPalindSeq(String str)
        {
            LinkStack S = new LinkStack();
            int i = 0;
            for(i = 0;i< str.length;i++)
            {   
                S.push(str.charAt(i));
                char c = ((Character)S.pop().charValue();
                if(c!=str.charAt(i))
                return false;
            }
                return true;
        }

（4） 使用链栈解决大数加法问题

接口Istack：

package ch01;
public interface Istack
{
        public void clear();            //将一个已经存在的栈置为空
        public boolean isEmpty();               //判断栈是否为空
        public int length();            //返回栈中个数据元素的个数
        public  Object peek();
                            //读取栈项元素，若栈为空，则返回为空
        public void push(Object x) throws Exception;
                                        //入栈：将数据元素压入栈顶
        public Object pop();            //出栈：删除并返回栈顶元素  
}

结点类Node：

package ch01;
public class Node
{
    public Object data;
        public Node next;

        public Node()
        {
            this(null,null);
        }

        public Node(Object data)
        {
            this(data,null);
        }

        public Node(Object data,Node next)
        {
            this.data = data;
            this.next = next;
        }
}

链栈LinkStack：

package ch01;
public class LinkStack implements Istack
{
        private Node top;

        public void clear()
        {
            top = null;
        }   

        public boolean isEmpty()
        {
            return top == null;
        }

        public int  length()
        {
            Node p = top;
            int length = 0;
            while(p != null)
            {
                p = p.next;
                ++length;
            }
            return length;
        }

        //取栈顶元素并返回其值
        public Object peek()
        {
            if(!isEmpty())
                return top.data;
            else
                return null;
        }

        //入栈
        public void push(Object x)
        {
            Node p = new Node(x);
            p.next = top;
            top = p;
        }

        //出栈
        public Object pop()
        {
            if(isEmpty())
            {
                return null;
            }
            else
            {
                Node p = top;
                top = top.next;
                return p.data;
            }
        }

        public void display()
        {
            Node p = top;
            while(p!= null)
            {
                System.out.println((p.data.toString() + " "));
                p = p.next;
            }
        }
}

Example2：

package ch03;
public class Example2
{
        public String add(String a,String b) throws Exception
        {
            LinkStack sum = new LinkStack();
            LinkStack sA = numSplit(a);
            LinkStack sB = numSplit(b);
            int Sum;
            boolean isCarry = false;
            while(!sA.isEmpty()&&!sB.isEmpty())
            {
                Sum = (Integer)sA.pop() + (Integer)sB.pop();
                if(isCarry)
                {
                    Sum ++;
                    isCarry = false;
                }
                if(Sum>=10)
                {
                    Sum =Sum-10;
                    sum.push(Sum);
                    isCarry = ture;
                }
                else
                {
                    sum.push(Sum);
                }
            }
            LinkStack temp = !sA.isEmpty()?sA:sB;
            while(!temp.isEmpty())
            {
                if(isCarry)
                {
                    int t = (Integer)temp.pop();
                    ++t;
                    if(t>=10)
                    {
                        t = t-10;
                        sum.ppush(t);
                    }
                    else
                    {
                        sum.push(t);
                        isCarry = false;
                    }
                }
                else
                    sum.push(temp.pop());
            }
            if(isCarry)
            {
                sum.push(1);
            }
            String str = new String();
            while(!sum.isEmpty())
            str = str.concat(sum.pop().toString());
            return str;
        }

        public LinkStack numSplit(String str) throws Exception
        {
            LinkStack s = new LinkStack();
            for(int i=0;i<str.length();i++)
            {
                char c = str.charAt(i);
                if(' ' == c)
                    continue;
                else if('0'<= c &&'9'>=c)
                    s.push(Integer.valueOf(String.valueOf(c)));
                else
                throw new Exception("错误：输入了非数字型字符");
            }
            return s;
        }

        public static void main(String []args) throws Exception
        {
            Example2 e = new Example2();
            System.out.println("两个大数的和:"+       e.add("12345678","12345678"));
         }
    }

队列的顺序存储结构如下：
接口：IQueue

public interface IQueue
{
    public void clear();                                //将队列置为空队列
    public boolean isEmpty();                       //判断队列是否为空
    public int length();                    //返回队中中中数据元素的个数
    public Object peek();                       //读取队首元素并返其值
    public void offer(Object x ) throws Exception;
                                    //将数据元素x插入使其成为新的队尾元素
    public Object poll();
                        //删除队首元素并返回其值，若队列为空，则返回为空
}

定义类CircleSqQueue实现接口：

public class CircleSqQueue implements IQueue
{
    private Object[]Elem;
    private int front ;                                     //队首元素
    private int rear;           //队尾不空，指向队尾元素的下一个存储空间

    //构造方法
    public CircleSqQueue(int maxSize)
    {
        front = rear = 0;
        Elem = new Object[maxSize];
    }

    public void clear()
    {
        front  = rear = 0;
    }   

    public boolean isEmpty()
    {
        return front  == rear ;
    }

    public int length()
    {
        return (rear -front+Elem.length)%Elem.length;
    }

    public Object peek()
    {
        if(front  == rear )
            return null;
        else 
            return Elem[front];
    }

    public void offer (Object x) throws Exception
    {
        if((rear +1 )%Elem.length == front )
        throw new Exception("队列已满！");
        else
        {
            Elem[rear]  = x;
            rear =(rear + 1) % Elem.length;
        }
    }
    public Object poll()
    {
        if(front == rear)
            return null;
        else
        {
            Object t = Elem[front];
            front = (front + 1) % Elem.length;
            return t;
        }
    }
    public void display()
    {
        if(!isEmpty())
        {
            for(int i = front;i!=rear; i = (i+1)%Elem.length)
                System.out.println(Elem[i].toString() + " ");
        }
        else 
            System.out.println("此队列为空！");
    }
}

队列的链式存储结构如下：
结点类Node：

package ch01;
public class Node
{
    public Object data;
    public Node next;

    public Node (Object data,Node next)
    {
        this.data = data;
        this.next = next;
    }

    public Node()
    {
        this(null,null);
    }

    public Node(Object data)
    {
        this(data,null);
    }
}

IQueue接口：

package ch01;
public interface IQueue
{
    public void clear();                                //将队列置为空队列
    public boolean isEmpty();                       //判断队列是否为空
    public int length();                    //返回队中中中数据元素的个数
    public Object peek();                       //读取队首元素并返其值
    public void offer(Object x ) throws Exception;
                                    //将数据元素x插入使其成为新的队尾元素
    public Object poll();
                        //删除队首元素并返回其值，若队列为空，则返回为空
}

LinkQueue类：

package ch01;
import ch01.Node;
public class LinkQueue implements IQueue
{
    private Node front;
    private Node rear;

    public LinkQueue()
    {
        front = rear = null;
    } 

    public void clear()
    {
        front =rear = null;
    }

    public boolean isEmpty()
    {
        return front == null;
    }

    public int length ()
    {
        Node p = front;
        int length = 0;
        while(p != null)
        {
            p = p.next;
            ++length;
        }
        return length;
    }

    public Object peek()
    {
        if(front != null)
           return front.data;
        else
          return null;
    }

    public void offer(Object x)
    {
        Node p = new Node(x);
        if(front!=null)
        {
            rear.next = p;
            rear = p;
        }
        else 
            front = rear = p;
    }

    public Object poll()
    {
        if(front != null)
        {
            Node p = front;
            front =front.next;
            if(p == rear)
                    rear = null;
            return p.data;
        }
        else
                return null;
    }
}
实验四 顺序栈和链队列的操作
zuyan266的专栏
11-27 2361
实验四 顺序栈和链队列的操作 一．实验目的 1．掌握栈的顺序存储结构；验证顺序栈及其基本操作的实现；验证栈的操作特性。 2．掌握队列的链接存储结构；验证链队列的存储结构和基本操作的实现；验证队列的操作特性。 二．问题描述 1．建立一个空栈；对已建立的栈进行插入、删除、取栈顶元素等基本操作。 2．建立一个空队列；对已建立的队列进行插入、删除、取队列元素等基本操作。 三．
数据结构栈和队列（五）栈的顺序存储结构和链式存储结构的实现
青红造了个大白之成长记
07-08 1万+
一、 实验目的1. 熟悉栈的特点（先进后出）及栈的抽象类定义；2. 掌握栈的顺序存储结构和链式存储结构的实现；3. 熟悉队列的特点（先进先出）及队列的抽象类定义；4. 掌握栈的顺序存储结构和链式存储结构的实现；二、实验要求1. 复习课本中有关栈和队列的知识；2. 用C++语言完成算法和程序设计并伤及调试通过；三、实验题目与要求1. 停车场问题——栈和队列的应用【问题描述】设停车场是一个可停放 n ...
《实验四》（栈和队列）
10-28 158
1 //实验课内容 2 #include<stdio.h> 3 #include<stdlib.h> 4 #include<conio.h> 5 #define TRUE 1 6 #define FALSE 0 7 #define OK 1 8 #define ERROR 0 9 #define ...
实验四 栈和队列的基本操作的实现
ai bohang 的博客
02-11 2825
#include&amp;amp;amp;lt;stdio.h&amp;amp;amp;gt; #include&amp;amp;amp;lt;stdlib.h&amp;amp;amp;gt; #define TRUE 1 #define FALSE 0 #define ERROR 0 #define OK 1 #define OVERFLOW 0 #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10
数据结构——栈和队列 02（杨辉三角队列解法）
herui7322的博客
01-25 3599
队列处理模式： 整个数据处理过程模型即是一个队列的形式。 杨辉三角的队列解法，编程输出几行杨辉三角形； 【】杨辉三角是由二项式（a+b）的 n 次方（n=1,2,3…）展开后各项的系数排成的三角形，它的特点是左右两边全是1，从第二行起，中间的每一个数是上一行里相邻两个数之和。 算法描述： 在每行之间插入一个0作为行的分隔标记，形成的系数序列存在数组queue[]中。 设 front 指向要求和的...
用链表实现队列和栈
qq_43568109的博客
03-12 366
1.定义队列接口 public interface MyQueue { int size(); boolean isEmpty(); void offer(Integer value); int poll(); int peek(); } 2.设计接口的实现类 首先队列是一个容器，要设置容器的各种方法，我们需要一些原料，这里我选择两个节点和一个表示容器大小的N，头节点first用于获取队列头部元素，last指向队列尾部，同时也作为一个游标，来循环访问队列各个元素。
3.实验三 顺序栈和队列.doc
最新发布
10-17
在本实验报告中，主要涉及到顺序栈和循环队列的设计和基本操作。 顺序栈的实现： 1. 使用顺序存储的方式实现栈时，通常采用数组作为数据存储结构。 2. 栈的指针top指示栈顶位置，初始状态时top通常设置为-1，表示栈...
C++数据结构实验二：深入理解栈和队列的应用及实现
3. 栈和队列的结构体类型定义及操作实现： - 顺序栈：通常使用数组和一个索引变量来表示栈顶。 - 链栈：使用链表实现栈，每个节点包含数据和指向下一个节点的指针。 - 循环队列：利用数组实现队列，并使用头尾...
数据结构上机实验_栈和队列的应用_迷宫问题 （含代码和报告）
07-18
**实验背景**：本实验旨在加深学生对数据结构中栈和队列的理解，并通过实际编程应用的方式掌握这两种数据结构的特点及其应用场景。栈和队列作为两种基本的数据结构，在算法设计、程序开发等多个领域都有着广泛的应用...
检查一个算术表达式中的括号是否正确匹配。
12-29
设计算法： 检查存储在单链表中的算术表达式 s 所包含的括号—— “(” 与 “)” 、 “[” 与 “]” 、 “{” 与 “}”是否正确匹配； 1、 创建单链表 s，通过用户逐个字符输入，完成 s 的初始化。 2、 编写程序实现函数 Check，并输出检查结果。 3、 为增强程序的可读性，对程序中较难理解的语句要有准确、清晰的注释。 由教师随机给出测试数据，程序能够反馈括号是否匹配，如果不匹配，指出第一个不匹配所在位置
java对应入队出栈_Java队列入队和堆栈出栈算法实现
weixin_36205997的博客
02-27 231
2008-05-22 回答class LinkedList //定义双项链表{char data;LinkedList back;LinkedList forward;}interface Access //定义从队列和栈存取操作的接口{void put(char c);char get();}class Queue implements Access //定义队列类{private Linked...
数据结构实验报告（三）
cqc1161的博客
10-24 2378
数据结构实验报告（三） 一、实验名称 实验三  栈和队列的基本操作实现及其应用 二、实验目的 1、熟练掌握栈和队列的结构特点，掌握栈和队列的顺序存储和链式存储结构和实现。 2、学会使用栈和队列解决实际问题。 三、实验内容 1.自己确定结点的具体数据类型和问题规模： 分别建立一个顺序栈和链栈，实现栈的压栈和出栈操作。 分别建立一个顺序队列和链队列，实现队列的入队和出队操作。 2.
第一阶段
a8153285的博客
08-20 266
Javase 转载于:https://www.cnblogs.com/Koma-vv/p/9194172.html
第8章作业
weixin_41892818的博客
04-08 200
import java.util.Scanner;public class Bank { public static void main(String[] args) {  Scanner in=new Scanner(System.in);  for (int i = 0; i &lt; 3; i++) {   System.out.println("请输入取款密码：");   String p...
educoder数据结构与算法 队列 第1关：实现一个顺序存储的队列
热门推荐
qq_54008392的博客
12-09 1万+
任务描述 本关任务：实现 step1/SeqQueue.cpp 中的SQ_IsEmpty、SQ_IsFull、SQ_Length、SQ_In和SQ_Out五个操作函数，以实现判断队列是否为空、是否为满、求队列长度、队列元素入队和出队等功能。 相关知识 队列是一个插入操作和删除操作受到限制的线性表数据结构。队列的插入和删除被限制在表的两端，即插入操作只能在表的一端进行，而删除操作只能在表的另一端进行，因此队列又称先进先出表。 顺序存储的队列 队列既可以采用顺序存储，也可以采用链接存储来实现。下面给出
实验3：栈和队列的基本操作实现及其应用——十进制转换为二进制
hpnynljy的博客
10-12 4128
实验3：栈和队列的基本操作实现及其应用一、实验目的1、   熟练掌栈和队列的结构特点，掌握栈和队列的顺序存储和链式存储结构和实现。2、      学会使用栈和队列解决实际问题。二、实验内容1、自己确定结点的具体数据类型和问题规模：分别建立一个顺序栈和链栈，实现栈的压栈和出栈操作。分别建立一个顺序队列和链队列，实现队列的入队和出队操作。2、设计算法并写出代码，实现一个十将二进制转换成2进制数。3、选...
实验4：栈和队列的基本操作实现及其应用
wujiancai1163的博客
10-31 894
一、实验目的 1、 熟练掌栈和队列的结构特点，掌握栈和队列的顺序存储和链式存储结构和实现。 2、 学会使用栈和队列解决实际问题。 二、实验内容 1、 自己确定结点的具体数据类型和问题规模： 分别建立一个顺序栈和链栈，实现栈的压栈和出栈操作。 三、源程序 #include using namespace std; const int Maxsize=100; template clas
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值