数据结构---栈

目录

栈和队列的概念

java中栈的方法

顺序栈的模拟实现

链栈的模拟实现

判断出栈顺序

 后缀中缀表达式


栈和队列的概念

栈:具有特殊限制的线性表,压栈和出栈操作只会在栈顶发生。                       

队列:有特殊限制的线性表,只可以在表的前端进行删除操作,表的后端进行插入操作。

栈:先进后出(搭积木:最上方插入和删除)

队列:先进先出 表头删除,表尾插入(排队买饭)

栈:具有特殊限制的线性表,删除和插入操作只会在一端发生

表尾称为栈顶,表头称为栈底。

插入一个元素到表尾,称为压栈,删除一个元素称为出栈。

一对一的逻辑结构,存储结构:链式和顺序式

java中栈的方法

构造方法 

 Stack继承了父类Vector,实例化子类对象时调用了子类的构造方法,子类的构造方法默认调用父类没有参数的构造方法,在父类Vector无参数的构造方法中通过this关键字调用Vector中一个参数为int类型的构造方法 

 通过this关键字的调用,最终实现的是Vector类(int,int)类型的构造方法

 总结:当创建Stack对象时,JVM底层创建时,栈数组的初始空间默认为10

创建Vector对象时,如果没有传入大小,JVM底层处理空间为10

如果传入了大小,数组空间为传入大小

 push()---元素压栈

    public static void main(String[] args) {
        Stack<Integer> stack = new Stack();
        stack.push(1);//元素压栈
        System.out.println(stack);
        System.out.println(stack.peek());//弹出元素,但是不删除(只获取栈顶元素)
        System.out.println(stack);
        stack.pop();//元素出栈
        System.out.println(stack);
    }

 总结:如果初始化时,没有规定数组的扩容大小或者规定的扩容大小<=0,那么默认2倍扩容

如果规定的扩容大小>0,那么数组每次扩容长度为规定长度

顺序栈的模拟实现

class Mystack {
    private int[] elem;
    private int sz;//数组大小
    private int usedsz;//数组占用大小

    public Mystack(int sz) {
        InitElem(sz);
        this.sz = sz;
        usedsz = 0;
    }

    public Mystack() {
        this(10);
    }

    public void InitElem(int sz) {
        if (sz <= 0)
            throw new RuntimeException();
        else {
            this.elem = new int[sz];
        }
    }
    public void Push(int x) {
        ensureCapacity();
        elem[usedsz++] = x;
    }

    public void ensureCapacity() {
        if (usedsz == sz) {//数组满了
            sz += sz;
        }
        elem = Arrays.copyOf(elem, sz);
    }

    public void print() {
        for (int i = 0; i < usedsz; i++) {
            System.out.print(elem[i] + " ");
        }
        System.out.println();
    }
    public boolean isEmpty(){
        if(usedsz==0)
            return true;
        return false;
    }
    public int peek(){//获取栈顶元素
        if(isEmpty()){//栈空
            throw new RuntimeException();
        }else{
            return elem[usedsz-1];
        }
    }
    public void pop(){//删除元素
        if(isEmpty()){//栈空
            throw new RuntimeException();
        }else{
            elem[--usedsz]=0;
        }
    }

    @Override
    public String toString() {
        return "Mystack{" +
                "elem=" + Arrays.toString(elem) +
                '}';
    }
}

    public class MyArrayStack {
        public static void main(String[] args) {
            Mystack stack = new Mystack();
            stack.Push(1);
            System.out.println(stack);
            System.out.println(stack.isEmpty());
            stack.pop();
            System.out.println(stack.isEmpty());
            stack.print();
            System.out.println(stack);
            System.out.println(stack.peek());
            stack.print();
            System.out.println(stack);
        }
    }

链栈的模拟实现

如果使用单链表---头插法和尾插法

头插法:压栈和出栈的时间复杂度 o(1)

尾插法:使用尾结点可以将压栈的时间复杂度控制在o(1),但是出栈时间复杂度O(n)(找到前驱节点)

可以使用双向链表

class  LinkNode {
    int val;
    LinkNode next;
    LinkNode prev;

    public LinkNode(int val, LinkNode prev, LinkNode next) {
        this.val = val;
        this.next = next;
        this.prev = prev;
    }
}
class Stack{
    private LinkNode head=null;
    private LinkNode tail=null;
    public  void push(int x){
        if(head==null){
            LinkNode newnode =new LinkNode(x,null,null);
            head=newnode;tail=newnode;
        }else{
            LinkNode newnode =new LinkNode(x,tail,null);
            tail.next=newnode;
            tail=newnode;
        }
    }
    public  void pop(){
        if(head==null)
            throw new RuntimeException("栈空");
        else if(head.next==null){//有一个元素
            tail=head=null;
        }
        else{
               tail.prev.next=null;
        }
    }
    public  int peek(){
        if(head==null)
            throw new RuntimeException("栈空");
       else
           return tail.val;
    }
    public void print(){
        LinkNode p=head;
        while(p!=null){
            System.out.print(p.val+" ");
            p=p.next;
        }
        System.out.println();
    }
}
public class MyLinkedStack {
    public static void main(String[] args) {
        Stack stack=new Stack();
        stack.push(1);
        stack.push(4);
        stack.push(1);
        stack.print();
      //  System.out.println(stack.peek());
        //stack.print();
        stack.pop();
        stack.print();
    }
}

判断出栈顺序

比如有六个元素6,5,4,3,2,1的顺序进栈,问下列哪一个不是合法的出栈序列?( )。
A  543612  B 453126  C 346521   D  234156

牛客--- JZ31 栈的压入、弹出序列

import java.util.*;

public class Solution {
    public static boolean IsPopOrder(int [] pushA,int [] popA) {
        Stack<Integer> stack = new Stack<>();
        int j = 0;
        for (int i = 0; i < pushA.length; i++) {
            stack.push(pushA[i]);
            while (!stack.isEmpty()&&j<pushA.length&&stack.peek() == popA[j]) {//找到了第一个弹出元素
                stack.pop();
                j++;
            }
        }
        if(stack.isEmpty())
            return true;
        return false;
    }
}

 后缀中缀表达式

leetcode---150. 逆波兰表达式求值

借用栈将后缀表达式转化为中缀表达式

class Solution {
    public int evalRPN(String[] tokens) {
    Stack<Integer> stack=new Stack();
    for (int i = 0; i < tokens.length; i++) {
if(ischaracter(tokens[i])==false){
    stack.push(Integer.parseInt(tokens[i]));
}else{
     int num2=stack.pop();
    int num1=stack.pop();
    switch(tokens[i]){
        case "+":stack.push(num1+num2);break;
        case "-":stack.push(num1-num2);break;
        case "*":stack.push(num1*num2);break;
        case "/":stack.push(num1/num2);break;
    }
}
 }
     return  stack.pop();
}
public  boolean ischaracter(String s){
    if(s.equals("+")||s.equals("-")||s.equals("*")||s.equals("/"))
        return true;
    return false;
}
    }

leetcode---20. 有效的括号

class Solution {
        public boolean isValid(String s) {
        Stack <Character> stack=new Stack<>();
        for (int i = 0; i <s.length() ; i++) {
            char ch=s.charAt(i);//获取字符
            if(ch=='('||ch=='{'||ch=='[')
                stack.push(ch);//左括号入栈
            else{
                if(stack.isEmpty())
                    return false;
             char a= stack.peek();
             if(ch==')'&&a=='('||ch=='}'&&a=='{'||ch==']'&&a=='[')
                 stack.pop();
             else
                 return false;
            }
        }
        if(stack.isEmpty())
            return true;
            return false;
    }
}

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

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值