栈(java)

栈

1、数组实现栈

public class StackTest {
	int top;
	int arr[];
	int maxSize;
	
	public StackTest(int maxSize) {
		super();
		this.top = -1;
		this.maxSize = maxSize;
		this.arr = new int[maxSize];
	}
	
	//栈满
	public boolean isFull() {
		return top == maxSize -1;
	}
	
	//栈空
	public boolean isEmpty() {
		return top == -1;
	}
	
	//入栈
	public void add(int index) {
		if (isFull()) {
			System.out.println("栈满了");
			return;
		}
		this.top++;
		this.arr[top] = index;
	}
	
	//出栈
	public int del() {
		if (isEmpty()) {
			throw new RuntimeException("栈是空的");
		}
		int value = arr[top];
		this.top--;
		return value;
	}
	
	//遍历
	public void show() {
		if (isEmpty()) {
			System.out.println("栈是空的");
			return;
		}
		for (int i = this.top;i>=0;i--) {
			System.out.println(this.arr[i]);
		}
	}
	
	public static void main(String[] args) {
		StackTest stackTest = new StackTest(4);
		//stackTest.show();
		//stackTest.del();
		stackTest.add(4);
		stackTest.add(7);
		stackTest.add(5);
		stackTest.add(2);
		stackTest.show();
		System.out.println("一条数据出栈后");
		stackTest.del();
		stackTest.show();
		System.out.println("两条条数据出栈后");
		stackTest.del();
		stackTest.show();
	}
}
 

2、链表实现栈

public class LinkedStack {
    public static void main(String[] args) {
        LinkedStackNode linkedStackNode1 = new LinkedStackNode(1);
        LinkedStackNode linkedStackNode2 = new LinkedStackNode(2);
        LinkedStackNode linkedStackNode3 = new LinkedStackNode(3);
        LinkedStackNode linkedStackNode4 = new LinkedStackNode(6);
        LinkedStackNodeDome l = new LinkedStackNodeDome();
        l.add(linkedStackNode1);
        l.add(linkedStackNode2);
        l.add(linkedStackNode3);
        l.add(linkedStackNode4);
        l.show();
        System.out.println("Top-->" + l.getTop());
        System.out.println("length-->" + l.getLength());
    }
}

class LinkedStackNode{   //头结点
    public int value;  //数据
    public LinkedStackNode next;

    public LinkedStackNode(int value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "LinkedStackNode{" +
                "value-->" + value +
                '}';
    }
}

class LinkedStackNodeDome{    //节点
    private int length;  //长度
    private LinkedStackNode head = new LinkedStackNode(0);  //头结点

    //栈是先进后出---所以采用头插法
    public void add(LinkedStackNode heroNode){
        heroNode.next = head.next;   //新插入的数据代替头结点指向第一个节点
        head.next = heroNode;   //头结点指向新插入的数据
        length++;
    }

    //取数据---因为采用了头插法---后插入的数据在前面
    public int get(){
        head.next = head.next.next;
        return head.value;
    }

    //遍历链表栈
    public void show(){
        LinkedStackNode temp = head;
        while (temp.next !=null){
            temp = temp.next;
            System.out.println(temp);
        }
    }

    //显示链表长度
    public int getLength(){
        return length;
    }

    //打印首栈
    public int getTop(){
        return head.next.value;
    }
}

3、用队列实现栈

//用数组实现队列---后面有队列实现栈
public class QueueTest {
	
	private int maxSize;
	private int rear;
	private int front;
	private int[] arr; 
	
	public QueueTest(int maxSize) {
		super();
		this.maxSize = maxSize;
		rear = -1;
		front = -1;
		arr = new int[maxSize];
	}
	
	//判断是否为空
	public boolean isEmpty() {
		return front == rear;  //成立返回1---否则返回0
	}
	
	//判断是否装满
	public boolean isFull() {
		return rear == maxSize-1; //成立返回1---否则返回0
	}
	
	//添加数据
	public void add(int num) {
		if (isFull()) {  //为0则不符合条件----队列未满----反之不为0则满了
			//System.out.println("队列已满");
			throw new RuntimeException("队列已满");
		}
		
			rear++;  //初始为-1---下标后移
			arr[rear] = num;
	}
	
	//取数据
	public int get() {
		if (isEmpty()) {   //为0则不符合条件----队列为空----反之不为0则不为空有数据
			throw new RuntimeException("队列无数据");
		}
		front++;   //初始为-1---下标后移
		return arr[front];
	}
	
	//显示数据
	public void showQueue() {
		if (isEmpty()) {   //为0则不符合条件----队列为空----反之不为0则不为空有数据
			System.out.println("队列无数据");
		}
		for (int i = front+1;i<=rear;i++) {
			System.out.printf("[%d] = %d\n",i+1,arr[i]);
		}
	}
	
	//显示头部
	public int headQueue() {
		// 判断
		if (isEmpty()) {
			System.out.println("没有数据~~");
		}
		return arr[front + 1];
	}

	//显示长度
	public int length(){
		return rear-front;
	}
}

//使用上面的队列---->实现栈
class QueueStack {

	QueueTest queue;

	//初始化队列
	public QueueStack(){
		queue = new QueueTest(40);
	}

	//将x压入栈顶---队列实现
	public void push(int x) {
		queue.add(x);  //这里为队列添加元素---是往后添加
		//处理为压入顶部添加
		for (int i = 0;i<queue.length()-1;i++){   //queue.size()-1排除你添加的元素
			queue.add(queue.get());
			//删除队列顶部的元素并重新入队添加---重复操作就形成了新添加的数据到了顶部---达到压入栈的效果
		}
	}
	//移除并返回栈顶元素
	public int pop() {
		return queue.get();  //删除顶部元素并返回
	}

	//返回栈顶元素。
	public int top() {
		return queue.headQueue();  //peek会检索顶部元素但不会删除
	}

	//如果栈是空的，返回 true ；否则，返回 false 。
	public boolean empty() {
		return queue.isEmpty();
	}
}

4、双栈实现基本计算器

public class StackCalculator {
    public static void main(String[] args) {
        StackCalculatorTest stackCalculatorTest = new StackCalculatorTest();
        System.out.println(stackCalculatorTest.calculation("7*2*2-5+1-5+3-4"));
    }
}

class StackCalculatorTest {
    private Stack<Integer> stack1;  //数据栈
    private Stack<Character> stack2;  //符号栈

    public StackCalculatorTest() {
        stack1 = new Stack<>();
        stack2 = new Stack<>();
    }

    public int priority(char c) {     //优先级判断
        if (c == '+' || c == '-') {  // + -为1
            return 1;
        }
        if (c == '*' || c == '/') {  // * / 为2
            return 2;
        }
        return 0;
    }

    public int switch_(char c1, int num2, int num1) {  //因为栈是先进后出---所以在栈里先出的是符号后面的数
        int temp = 0;
        switch (c1) {
            case '*':
                temp = num1 * num2;
                break;
            case '-':
                temp = num1 - num2;
                break;
            case '+':
                temp = num1 + num2;
                break;
            case '/':
                temp = num1 / num2;
                break;
        }
        return temp;
    }

    public int calculation(String s) {
        char[] chars = s.toCharArray();
        for (char c : chars) {
            if (c == '+' || c == '-' || c == '*' || c == '/') {
                if (stack2.size() != 0) {    //当符号栈不为空是才进行 优先级判断
                    if (priority(c) <= priority(stack2.peek())) {  //每次都和顶栈元素比
                        int num1 = stack1.pop();  //弹出两个数栈元素
                        int num2 = stack1.pop();
                        char c1 = stack2.pop();   //弹出一个符号栈元素
                        stack1.push(switch_(c1, num1, num2));  //运算的结果在进入数栈
                    }
                }
                stack2.push(c);  //符号入栈
            }
                if (c >= '0' && c <= '9') {
                    Integer num = Integer.parseInt(String.valueOf(c));  //将字符转化为数字
                    stack1.push(num);
                }
            }
        while (!stack2.isEmpty()){   //如果符号栈不为空则循环计算

                int num1 = stack1.pop();  //弹出两个元素
                int num2 = stack1.pop();
                char c1 = stack2.pop();   //弹出一个元素
                stack1.push(switch_(c1,num1,num2));  //运算的结果
        }
            return stack1.peek();  //返回数栈的顶栈数据
        }
    }