Java复习常用的数据结构和常用面试题之栈和队列

提示:看之前请先学习链表知识点

Java复习常用的数据结构和常用面试题之数组和链表

文章目录

  • Java复习常用的数据结构和常用面试题之数组和链表
  • 堆栈和队列
    • 栈(Stack)
      • 栈的常用方法
      • 用链表实现栈
    • 队列(Queue)
        • 基本概念
        • jdk自带队列的基本操作
        • 用单链表自己实现队列(LinkQueue)
    • 实战题目
      • 思路解法
        • [844. 比较含退格的字符串](https://leetcode-cn.com/problems/backspace-string-compare/)
        • [20. 有效的括号](https://leetcode-cn.com/problems/valid-parentheses/)
        • 150.逆波兰表达式求值问题
        • [232. 用栈实现队列](https://leetcode-cn.com/problems/implement-queue-using-stacks/)
        • [225. 用队列实现栈](https://leetcode-cn.com/problems/implement-stack-using-queues/)
  • 总结


堆栈和队列

  1. Stack - First In First Out (FIFO)
    • Array or Linked List
  2. Queue - First In Last Out (FILO)
    • Array or Linked List

栈(Stack)

先进后出的结构特点
Java复习常用的数据结构和常用面试题之栈和队列_第1张图片

栈的常用方法

boolean empty( )——如果堆栈是空的,则返回true,当堆栈包含元素时,返回false。
Object peek( )———–返回位于栈顶的元素,但是并不在堆栈中删除它。
Object pop( )————返回位于栈顶的元素,并在进程中删除它。
Object push (Object element )———将element压入堆栈,同时也返回element。
int search(Object element)———在堆栈中搜索element,如果发现了,则返回它相对于栈顶
的偏移量。否则,返回-1。

用链表实现栈

package com.gdpu.Stack;

import LinkedList.ListNode;

import java.util.Iterator;

/**
 * 用链表实现栈
 * 头部节点不放数据
 * head的指向的第一个节点就是栈顶
 */
public class Stack<T> implements Iterable{
     

    //记录首结点
    private ListNode head;
    //栈中元素的个数
    private int N;

    public Stack() {
     
        this.head = new ListNode(null,null);
        this.N=0;
    }

    //判断当前栈中元素个数是否为0
    public boolean isEmpty(){
     
        return N==0;
    }

    //获取栈中元素的个数
    public int size(){
     
        return N;
    }

    //把t元素压栈
    public void push(T t){
     
        //找到首结点指向的第一个结点
        ListNode oldFirst = head.next;
        //创建新结点
        ListNode newNode = new ListNode(t, null);
        //让首结点指向新结点
        head.next = newNode;
        //让新结点指向原来的第一个结点
        newNode.next=oldFirst;
        //元素个数+1;
        N++;
    }
    
    //弹出栈顶元素
    //返回位于栈顶的元素,并在进程中删除它
    public T pop(){
     
        //找到首结点指向的第一个结点
        ListNode oldFirst = head.next;
        if (oldFirst==null){
     
            return null;
        }
        //让首结点指向原来第一个结点的下一个结点
        head.next=oldFirst.next;
        //元素个数-1;
        N--;
        return (T) oldFirst.val;
    }
    
    //返回位于栈顶的元素,但是并不在堆栈中删除它。
    public T peek(){
     
        //找到首结点指向的第一个结点
        ListNode oldFirst = head.next;
        if (oldFirst==null){
     
            return null;
        }
        return (T) oldFirst.val;
    }


    @Override
    public Iterator<T> iterator() {
     
        return new SIterator();
    }

    private class SIterator implements Iterator{
     
        private ListNode n;

        public SIterator(){
     
            this.n=head;
        }

        @Override
        public boolean hasNext() {
     
            return n.next!=null;
        }

        @Override
        public Object next() {
     
            n = n.next;
            return n.val;
        }
    }
}

队列(Queue)

基本概念

队列(Queue):简称队。是一种操作受限的线性表,只允许在表的一端进行插入,而在表的另一端进行删除。向队列中插入元素称为入队或进队;删除元素称为出队或离队。其操作特性为先进先出(First In First Out,FIFO),并且只允许在队尾进,队头出。

队头(Front):允许删除的一端,又称队首

队尾(Rear):允许插入的一端

空队列:不包含任何元素的空表

Java复习常用的数据结构和常用面试题之栈和队列_第2张图片

jdk自带队列的基本操作

Queue<Integer> queue1 = new LinkedList<Integer>(); 
方法 作用
add() 入队(若失败则抛出IllegalStateException异常)
offer() 将指定元素插入队列,成功返回true,否则返回false
element() 获取队头的值,但不出队(若队列为空则抛出异常NoSuchElementException)
peek() 获取队头的值,但不出队(若队列为空则返回null
poll() 获取并移除队头(若队列空则返回null)
remove 获取并移除队头(若队列空则抛出NoSuchElementException异常)

用单链表自己实现队列(LinkQueue)

package Queue;

import LinkedList.ListNode;

import java.util.Iterator;

/**
 * 用链表实现的队列
 * @param 
 */
public class LinkQueue<T> implements Iterable<T> {
     
    // 队头
    private ListNode front;
    // 队尾
    private ListNode rear;
    // 元素个数
    private int size;

    /**
     * 创建队列
     */
    public LinkQueue() {
     
        rear = front = null;
        size=0;
    }

    /**
     * 入队列
     *
     * @param data
     */
    public void offer(T data) {
     
        ListNode<T> node = new ListNode<T>(data);
        //如果是空队列
        if (isEmpty()) {
     
            front = rear = node;
        } else {
     
            //在尾部插入
            rear.next = node;
            rear = node;
        }
        size++;
    }


    /**
     * 出队列
     * @return 返回数据
     */
    public T poll() {
     
        if (isEmpty()) {
     
            throw new RuntimeException("队列为空");
        }
        ListNode<T> delete = front;
        //更改头部节点
        front = delete.next;
        delete.next=null; // help GC
        //数量减1
        size--;

        if (size == 0) {
     
            // 删除掉最后一个元素时,front值已经为null,但rear还是指向该节点,需要将rear置为null
            // 最后一个结点front和rear两个引用都没指向它,帮助GC处理该节点对象
            rear = front;
        }

        return (T) delete.val;
    }

    /**
     * 只取队列头的数据
     */
    public T peek(){
     
        if (isEmpty()) {
     
            throw new RuntimeException("队列为空");
        }
        return (T) front.val;
    }

    /**
     * 判断队列是否为空
     */
    public boolean isEmpty() {
     
        return front == null && rear == null;
    }

    /**
     * 获取队列的元素个数
     */
    public int size() {
     
        return this.size;
    }

    //自己添加遍历模块
    @Override
    public Iterator<T> iterator() {
     
        return new QIterator();
    }

    private class QIterator implements Iterator{
     
        private ListNode n = new ListNode();

        public QIterator(){
     
            n.next=front;
        }

        @Override
        public boolean hasNext() {
     
            return n.next!=null;
        }

        @Override
        public Object next() {
     
            n = n.next;
            return n.val;
        }
    }
}

实战题目

  1. 844. 比较含退格的字符串
  2. 232. 用栈实现队列
  3. 225. 用队列实现栈
  4. 20. 有效的括号
  5. 150.逆波兰表达式求值问题

思路解法

844. 比较含退格的字符串

  • 暴力遍历,按规则翻译出最终的字符串
package com.gdpu.day1;

public class NO_844_backspaceCompare {
     

    public boolean backspaceCompare(String S, String T) {
     
        return transfer(S).equals(transfer(T));
    }
    /**
     * 暴力遍历
     * 翻译出按规则的最后的字符串
     */
    public String transfer(String str){
     
        StringBuffer ret = new StringBuffer();
        for (int i =0;i<str.length();i++){
     
            char ch = str.charAt(i);
            if (ch!='#'){
     
                ret.append(ch);
            }else {
     
                if (ret.length()>0){
     
                    ret.deleteCharAt(ret.length()-1);
                }
            }
        }
        return ret.toString();
    }
}

  • 双指针分别逆序遍历S和T
/**
     * 两个指针分别逆向遍历两个字符串
     */
    public boolean doublePointCompare(String S, String T) {
     
        int i = S.length() - 1;
        int j = T.length() - 1;
        int skipS = 0, skipT = 0;
        while (i > 0 || j > 0) {
     
            while (i >= 0) {
     
                if (S.charAt(i) == '#') {
     
                    skipS++;
                } else if (skipS > 0) {
     
                    skipS--;
                    i--;
                } else {
     
                    //找到一个无法消除的了,跳出
                    break;
                }
            }
            while (j >= 0) {
     
                if (T.charAt(j) == '#') {
     
                    skipT++;
                } else if (skipT > 0) {
     
                    skipS--;
                    j--;
                } else {
     
                    //找到一个无法消除的了,跳出
                    break;
                }
            }
            //如果两步的索引都是大于等于0
            if (i >= 0 && j >= 0) {
     
                //如果此时双方无法消除的不相等
                if (S.charAt(i) != T.charAt(j)) {
     
                    return false;
                }
            } else {
     
                //排除了都是大于等于0,如果有一个是大于等于0
                if (i >= 0 || j >= 0) {
     
                    return false;
                }
            }
            i--;
            j--;
        }
        return true;
    }

20. 有效的括号

  • 用辅助栈的机制解
class Solution {
     
    public boolean isValid(String s) {
     
        int n = s.length();
        //如果是奇数,必然是不能匹配完全
        if (n % 2 == 1) {
     
            return false;
        }
        //定义一个映射map
        Map<Character, Character> pairs = new HashMap<Character, Character>() {
     {
     
            put(')', '(');
            put(']', '[');
            put('}', '{');
        }};
        Stack<Character> stack = new Stack<Character>();
        for (int i = 0;i<n;i++){
     
            char ch = s.charAt(i);
            //如果是右括号
            if (pairs.containsKey(ch)){
     
                //此时如果栈是空的或者栈顶元素不匹配则返回false
                if (stack.isEmpty() || stack.peek() != pairs.get(ch)) {
     
                    return false;
                }
                //匹配成功弹出栈顶元素
                stack.pop();
            }
            //如果没有对应的值,入栈
            else {
     
                stack.push(ch);
            }
        }
        return stack.isEmpty();

    }
}

150.逆波兰表达式求值问题

class Solution {
     
       public int evalRPN(String[] tokens) {
     
        Stack<Integer> stack = new Stack<Integer>();
        for (int i = 0;i<tokens.length;i++){
     
            //如果是数字,入栈
            if (isNumber(tokens[i])){
     
                stack.push(Integer.parseInt(tokens[i]));
            }else {
     
                int num1 = stack.pop();
                int num2 = stack.pop();
                switch (tokens[i]){
     
                    case "+": stack.push(num2+num1);break;
                    case "-": stack.push(num2-num1);break;
                    case "*": stack.push(num2*num1);break;
                    case "/": stack.push(num2/num1);break;
                    default:
                }
            }
        }
        return stack.peek();
    }

    public boolean isNumber(String token) {
     
        return !(token.equals("*"))&&!(token.equals("+"))&&!(token.equals("-"))&&!(token.equals("/"));
    }
}

232. 用栈实现队列

class MyQueue {
     
    //输入栈
    private Stack<Integer> inStack;
    //输出栈
    private Stack<Integer> outStack;  

    /** Initialize your data structure here. */
    public MyQueue() {
     
    
    this.inStack=new Stack<Integer>();
    this.outStack=new Stack<Integer>();

    }
    
    //入栈
    public void push(int x) {
     
        inStack.push(x);
    }

    //出栈
    public int pop() {
     
        //如果输出栈为空,则将输入栈全部弹出并压入输出栈栈中,然后outStack.pop()
        if(outStack.isEmpty()){
     
            while(!inStack.isEmpty()){
     
                outStack.push(inStack.pop());
            }
        }
        return outStack.pop();
    }

    //取得队头数据
    public int peek() {
     
        if(outStack.isEmpty()){
     
            while(!inStack.isEmpty()){
     
                outStack.push(inStack.pop());
            }
        }
        return outStack.peek();
    }

    public boolean empty() {
     
        return inStack.isEmpty() && outStack.isEmpty();
    }
}

225. 用队列实现栈

-用两个队列

class MyStack {
     
   Queue<Integer> queue1;
   Queue<Integer> queue2;

   /** Initialize your data structure here. */
   public MyStack() {
     
       queue1 = new LinkedList<Integer>();
       queue2 = new LinkedList<Integer>();
   }
   //入栈
   public void push(int x) {
     
       //当前新增元素后进队列
       queue1.offer(x);
       //老队列后进
       while (!queue2.isEmpty()){
     
           queue1.offer(queue2.poll());
       }

       //搞完后更新老队列
       //其实此时的queue1已经是空队列了
       Queue<Integer> tmp = queue1;
       queue1 = queue2;
       queue2 = tmp;
   }

   //出栈
   public int pop() {
     
       return queue2.poll();
   }

   public int top() {
     
       return queue2.peek();
   }

   public boolean empty() {
     
       return queue2.isEmpty();
   }

}

-用1个队列

class MyStack {
     
    Queue<Integer> queue;

    /** Initialize your data structure here. */
    public MyStack() {
     
        queue = new LinkedList<Integer>();
    }
    
    /** Push element x onto stack. */
    public void push(int x) {
     
        int n = queue.size();
        queue.offer(x);
        for (int i = 0; i < n; i++) {
     
            queue.offer(queue.poll());
        }
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
     
        return queue.poll();
    }
    
    /** Get the top element. */
    public int top() {
     
        return queue.peek();
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
     
        return queue.isEmpty();
    }
}

总结

通过以上几道题,反复去求解多种解法,栈和队列就基本掌握了

你可能感兴趣的:(Java数据结构,数据结构,java,栈,队列,stack)