栈

栈的英文为(stack) 栈是一个先入后出(FILO-First In Last Out)的有序列表。

栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。

允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。

根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，

而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除

 数组模拟栈

package com.wang;

import java.util.Scanner;

public class Stack {

	public static void main(String[] args) {
		ArrStack arrStack = new ArrStack(4);
		String key="";
		boolean loop=true;
		System.out.println("push入栈");
		System.out.println("pop出栈");
		System.out.println("list查看");
		System.out.println("exit退出");
		Scanner sc=new Scanner(System.in);
		while(loop) {
			key=sc.next();
			switch (key) {
			case "push":
				int value=sc.nextInt();
				arrStack.push(value);
				break;
			case "pop":
				int value1=arrStack.pop();
				System.out.println(value1);
				break;
			case "list":
				arrStack.list();
				break;
			case "exit":
				loop=false;
				break;
			}
		}
	}

}

class ArrStack {
	private int maxsize;
	//存放数据
	private int[] arr;
	//栈顶初始化-1
	private int top=-1;
	
	
	public ArrStack(int maxsize) {
		super();
		this.maxsize = maxsize;
		arr = new int[maxsize];
	}
	
	//栈满
	public boolean isFull() {
		return top==maxsize-1;
	}
	
	//栈空
	public boolean isEmpty() {
		return top==-1;
	}
	
	//入栈
	public void push(int value) {
		if (isFull()) {
			System.out.println("满");
			return;
		}
		top++;
		arr[top]=value;
	}
	
	//出栈
	public int pop() {
		if (isEmpty()) {
			throw new RuntimeException("空");
		}
		int value=arr[top];
		top--;
		return value;
	}
	
	//遍历
	public void list() {
		if (isEmpty()) {
			return;
		}
		for(int i=top;i>=0;i--) {
			System.out.printf("arr[%d]=%d\n",i,arr[i]);
		}
	}
}

链表模拟栈

package com.wang;

import java.util.Scanner;

public class ListStack {

	public static void main(String[] args) {
		Lstack lstack = new Lstack(4);
		boolean loop=true;
		String key="";
		System.out.println("push入栈");
		System.out.println("pop出栈");
		System.out.println("list查看");
		System.out.println("exit退出");
		Scanner sc=new Scanner(System.in);
		while(loop) {
			key = sc.next();
			switch (key) {
			case "push":
				String value = sc.next();
				lstack.push(value);
				break;
			case "pop":
				lstack.pop();
				break;
			case "list":
				lstack.list();
				break;
			case "exit":
				loop=false;
				break;
			}
		}
	}

}


class Lstack{
	private int maxsize;
	// 单链表模拟栈，数据存放在单链表中
	private ListS stack;
	private int top = -1;
	
	public Lstack(int maxsize) {
		super();
		this.maxsize = maxsize;
		stack = new ListS();
		stack.create(maxsize);
	}
	
	public boolean isFull() {
		return top == maxsize - 1;
	}

	public boolean isEmpty() {
		return top == -1;
	}
	
	//入栈
	public void push(String value) {
		if (isFull()) {
			System.out.println("满");
			return;
		}
		top++;
		stack.add(top, value);
	}
	
	//出栈
	public void pop() {
		if (isEmpty()) {
			System.out.println("空");
			return;
		}
		System.out.println(stack.out(top));
		top--;
	}
	
	// 遍历
	public void list() {
		if (isEmpty()) {
			System.out.println("栈空，无法遍历！");
		}
		stack.list(top);
	}

	// 正常遍历,检测链表使用
	public void list2() {
		stack.list2();
	}
}


class ListS{
	//头结点
	private Node head=new Node(-1);
	
	
	//创建链表
	public void create(int maxsize) {
		if (maxsize<1) {
			return;
		}
		Node temp = head;
		//根据所给长度对链表初始化
		for (int i = 0; i < maxsize; i++) {
			Node node = new Node(i);
			temp.setNext(node);
			temp=node;
		}
	}
	
	//增
	public void add(int top,String value) {
		Node temp = head;
		//移动到栈顶位置
		for (int i = 0; i < top; i++) {
			temp = temp.getNext();
		}
		//将数据添加到链表的最后
		temp.getNext().setValue(value);
	}
	
	//取
	public String out(int top) {
		Node temp = head;
		//移动到栈顶位置
		for (int i = 0; i <=top; i++) {
			temp = temp.getNext();
		}
		//取出
		String value = temp.getValue();
		return value;
	}
	
	//逆序打印
	public void list(int top) {
		Node temp = head;
		while (top>=0) {
			for (int i = 0; i <=top; i++) {
				temp = temp.getNext();
			}
			System.out.println(temp.getValue());
			//栈顶下移
			top--;
			//还原头节点
			temp=head;
		}
	}
	
	//正序打印
	public void list2() {
		Node temp = head.getNext();
		while (true) {
			if (temp == null) {
				break;
			}
			System.out.println(temp);
			temp = temp.getNext();
		}
	}
}



class Node{
	private int no;
	private String value;
	private Node next;
	
	public Node(int no) {
		super();
		this.no = no;
	}
	
	public int getNo() {
		return no;
	}
	public void setNo(int no) {
		this.no = no;
	}
	public String getValue() {
		return value;
	}
	public void setValue(String value) {
		this.value = value;
	}
	public Node getNext() {
		return next;
	}
	public void setNext(Node next) {
		this.next = next;
	}
	@Override
	public String toString() {
		return "Node [no=" + no + ", value=" + value + ", next=" + next + "]";
	}
	
}