数据结构学习笔记（三） 堆栈

堆栈：
    具有一定操作约束的线性表，只在一端（栈顶）做出栈和入栈（先进后出）

栈的顺序存储实现：

package stack;

public class StackArray {
    private static int[] a ;
    //这个是栈顶元素的下标，若为负数，则代表为空栈
    private static int top1 = -1;
    private static int top2 = 20;
//    top1--》                  《--top2
    public static void main(String[] args) {
        init();
        //将20这个元素放入1堆栈
        System.out.println("将10这个元素放入1堆栈:"+push(10,1));
        System.out.println("将20这个元素放入2堆栈:"+push(20,2));
        show();
        System.out.println("将10这个元素从1堆栈出栈:"+pop(1));
        System.out.println("将20这个元素从2堆栈出栈:"+pop(2));
        show();
        
    }
    /**
     * 初始化
     */
    public static void init(){
        a = new int[20];
    }
    
    /**
     * 入栈
     * @param tag :判断是哪一个堆栈
     * @param item
     * @return
     */
    public static String push(int item,int tag){
        //判断栈是否满了 top1 top2是否紧挨着
        if(top2-top1 == 1){
            return "栈已经满了";
        }else{
            if(tag == 1){
                a[++top1] = item;
                return "入栈成功";
            }else{
                a[--top2] = item ;
                return "入栈成功";
            }
        }
    }
    
    /**
     * 出栈
     * @return
     */
    public static String pop(int tag){
        if(tag == 1){
            if(top1 < 0){
                return "空栈";
            }else{
                top1--;
                return "出栈成功";
            }
        }else{
            if(top2 > a.length){
                return "空栈";
            }else{
                top2++;
                return "出栈成功";
            }
        }
    }
    public static void show(){
        System.out.print("1堆栈的元素：");
        for (int i = 0; i <= top1; i++) {
            System.out.print(a[i] +"  ");
        }
        System.out.println();
        System.out.print("2堆栈的元素：");
        for (int i = top2; i < a.length; i++) {
            System.out.print(a[i] +"  ");
        }
        System.out.println();
    }
}

栈的链式存储解决(栈顶在链栈的栈顶)：

package stack;

public class StackChained {
    private static Node first;
    public static void main(String[] args) {
        init();
        System.out.println(push(10));
        System.out.println(push(20));
        show();
        System.out.println(pop());
        show();
    }
    /**
     * 初始化，让first的next为空，代表没有元素
     */
    public static void init(){
        first = new Node(0);
        first.next = null;
    }
    /**
     * 入栈
     */
    public static String push(int item){
        Node node = new Node(item);
        node.next = first.next;
        first.next = node;
        return "入栈成功";
    }
    
    /**
     * 出栈
     */
    public static String pop(){
        if(first.next == null){
            return "栈为空";
        }else{
            //出栈元素
            Node node = first.next;
            first.next = node.next;
            return "出栈成功,出栈元素为："+node.data;
        }
    }
    
    public static void show(){
        Node node = first;
        System.out.print("栈中的元素有：");
        while(node.next != null){
            System.out.print(node.next.data+"  ");
            node = node.next;
        }
        System.out.println();
    }
}
package stack;

public class Node {
    public int data ;
    public  Node next ;
    public Node(int data) {
        this.data = data;
    }
    
}

 表达式求值问题
    中缀表达式:运算符号位于两个运算数之间。如：a+b*c-d/e
    后缀表达式：运算符号位于两个运算数之后。如：abc*+de/-
    
中缀表达式转换为后缀表达式：
    1）运算数：直接输出。
    2）左括号：直接进行压栈。
    3）右括号：将栈顶元素弹出并输出，直到左括号。
    4）运算符：
        若优先级大于栈顶元素，则进行压栈
        若优先级小于栈顶元素，则将栈顶元素输出，栈顶元素下移，在进行比较，若还是小于，
        则继续输出，直到大于栈顶元素的运算符，进行压栈。
    5）若运算数处理完毕，则将栈中元素直接输出。
    
后缀表达式求职策略：
    从左往右扫描，逐个处理运算数和运算符号-->需要有种存储方法，能顺序存储运算数，在需要时倒序输出

转载于:https://www.cnblogs.com/trashman/p/6899896.html