栈和队列

1. 栈

1.1 概念

栈是一种基于先进后出(FILO)的数据结构,是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出
的原则存储数据,先进入的数据被压入栈底,最后的数据在栈顶,需要读数据的时候从栈顶开始弹出数据(最后一
个数据被第一个读出来)。
我们称数据进入到栈的动作为压栈,数据从栈中出去的动作为弹栈。

在这里插入图片描述

1.2 代码实现

设计思路:

定义一个链表,入栈时每次都往头结点的下一个元素插(第一个结点),弹栈时也是从第一个结点开始弹起

//栈
public class Stack<T> implements Iterable<T>{
    //记录首结点
    private Node head;
    //栈中元素的个数
    private int N;
    private class Node{
        public T item;
        public Node next;
        public Node(T item, Node next) {
            this.item = item;
            this.next = next;
        }
    }
    public Stack() {
        this.head = new Node(null,null);
        this.N=0;
    }
    //判断当前栈中元素个数是否为0
    public boolean isEmpty(){
        return N==0;
    }
    //获取栈中元素的个数
    public int size(){
        return N;
    }
    //把t元素压入栈
    public void push(T t){
        //找到首结点指向的第一个结点
        Node oldFirst = head.next;
        //创建新结点
        Node newNode = new Node(t, null);
        //让首结点指向新结点
        head.next = newNode;
        //让新结点指向原来的第一个结点
        newNode.next=oldFirst;
        //元素个数+1;
        N++;
    }
    //弹出栈顶元素
    public T pop(){
        //找到首结点指向的第一个结点
        Node oldFirst = head.next;
        if (oldFirst==null){
            return null;
        }
        //让首结点指向原来第一个结点的下一个结点
        head.next=oldFirst.next;
        //元素个数-1;
        N--;
        return oldFirst.item;
    }
}

1.3 括号匹配问题

问题描述:

给定一个字符串,里边可能包含"()"小括号和其他字符,请编写程序检查该字符串的中的小括号是否成对出现。
	例如:
        "(上海)(长安)":正确匹配
        "上海((长安))":正确匹配
        "上海(长安(北京)(深圳)南京)":正确匹配
        "上海(长安))":错误匹配
        "((上海)长安":错误匹配

分析思路:

1. 创建一个栈来存储左括号
2. 循环遍历栈中的元素,依此拿到每个元素
3. 判断该字符是左括号,如果是,则放入栈中
4. 判断字符是不是右括号,如果不是,继续下层循环
5. 如果是右括号,则从栈中弹出一个元素
6. 判断元素t是否为null,如果不是,则证明有对应的左括号,如果不是,则证明没有对应的左括号
7. 循环结束后,判断栈中还有没有剩余的左括号,如果有,则不匹配,如果没有,则匹配

代码实现:

//括号匹配问题
public class BracketsMatch {
    public static void main(String[] args) {
        String str = "(fdafds(fafds)())";
        boolean match = isMatch(str);
        System.out.println(str + "中的括号是否匹配:" + match);
    }
    /**
    * 判断str中的括号是否匹配
    * @param str 括号组成的字符串
    * @return 如果匹配,返回true,如果不匹配,返回false
    */
    public static boolean isMatch(String str) {
        //1.创建一个栈用来存储左括号
        Stack<String> chars = new Stack<>();
        //2.从左往右遍历字符串,拿到每一个字符
        for (int i = 0; i < str.length(); i++) {
            String currChar = str.charAt(i) + "";
            //3.判断该字符是不是左括号,如果是,放入栈中存储
            if (currChar.equals("(")) {
                 chars.push(currChar);
            } else if (currChar.equals(")")) {//4.判断该字符是不是右括号,如果不是,继续下一次循环
                //5.如果该字符是右括号,则从栈中弹出一个元素t;
                 String t = chars.pop();
                //6.判断元素t是否为null,如果不是,则证明有对应的左括号,如果不是,则证明没有对应的左括号
                 if (t == null) {
                     return false;
                  }
             }
        }
        //7.循环结束后,判断栈中还有没有剩余的左括号,如果有,则不匹配,如果没有,则匹配
        if (chars.size() == 0) {
            return true;
        } else {
            return false;
        }
    }
}

1.4 逆波兰表达式问题

逆波兰表达式是波兰逻辑学家J・卢卡西维兹(J・ Lukasewicz)于1929年首先提出的一种表达式的表示方法,后缀表
达式的特点:运算符总是放在跟它相关的操作数之后。

普通中缀表达式逆波兰表达式
a+bab+
c+(a-b)cab-+
a+(b-c)*dabc-d*+
a*(b-c)+dabc-*d+

分析:

1. 创建一个栈对象存储操作数
2. 循环遍历逆波兰表达式,得到每个字符
3. 判断字符是不是运算符,如果不是,则将该操作数压栈
4. 如果是运算符,则从栈中弹出两个元素
5. 运用该运算符计算出结果,将新结果压栈
6. 遍历结束后,拿到最终结果
/**
    * @param notaion 逆波兰表达式的数组表示方式
    * @return 逆波兰表达式的计算结果
    */
    public static int caculate(String[] notaion) {
        //1.创建一个栈对象oprands存储操作数
        Stack<Integer> oprands = new Stack<>();
        //2.从左往右遍历逆波兰表达式,得到每一个字符串
        for (int i = 0; i < notaion.length; i++) {
            String curr = notaion[i];
            //3.判断该字符串是不是运算符,如果不是,把该该操作数压入oprands栈中
            Integer o1;
            Integer o2;
            Integer result;
            switch (curr) {
                case "+":
                    //4.如果是运算符,则从oprands栈中弹出两个操作数o1,o2
                    o1 = oprands.pop();
                    o2 = oprands.pop();
                    //5.使用该运算符计算o1和o2,得到结果result
                    result = o2 + o1;
                    //6.把该结果压入oprands栈中
                    oprands.push(result);
                    break;
                case "-":
                    o1=oprands.pop();
                    o2=oprands.pop();
                    result=o2-o1;
                    oprands.push(result);
                    break;
                case "*":
                    o1=oprands.pop();
                    o2=oprands.pop();
                    result=o1*o2;
                    oprands.push(result);
                    break;
                case "/":
                    o1=oprands.pop();
                    o2=oprands.pop();
                    result=o2/o1;
                    oprands.push(result);
                    break;
                default:
                    oprands.push(Integer.parseInt(curr));
                    break;
            }
        }
        Integer result = oprands.pop();
        return result;
    }

2. 队列

2.1 概念

队列是一种基于先进先出(FIFO)的数据结构,是一种只能在一端进行插入,在另一端进行删除操作的特殊线性表,它
按照先进先出的原则存储数据,先进入的数据,在读取数据时先读被读出来。

image-20200630112804280

2.2 代码实现

//队列
public class Queue<T> implements Iterable<T> {
    private Node head;
    private Node last;
    private Integer N;
    private class Node{
        public T item;
        public Node next;
        public Node(T item,Node next){
            this.item=item;
            this.next=next;
        }
    }
    public Queue(){
        this.head=new Node(null,null);
        this.last=null;
        this.N=0;
    }
    //判断队列是否为空,是返回true,否返回false
    public boolean isEmpty(){
        return N==0;
    }
    //获取队列中元素的个数
    public int size(){
        return N;
    }
    //从队列中拿出一个元素
    public T dequeue(){
        if (isEmpty()){
            return null;
        }
        Node oldFirst = head.next;
        head.next=oldFirst.next;
        N--;
        if (isEmpty()){
            last=null;
        }
        return oldFirst.item;

    }
    //往队列中插入一个元素
    public void enqueue(T t){
        if (last==null){
            //最后一个元素为空
            last = new Node(t,null);
            head.next=last;
        }else {
            Node oldFirst = this.last;
            last=new Node(t,null);
            oldFirst.next=last;

        }
        N++;
    }
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值