Java栈结构的实现（数组+链表）--数据结构的学习

package algorithm.stack;

import java.util.Scanner;
import java.util.Stack;

public class StackDemo {

	public static void main(String[] args) {
		arrayStackTest();
		linkedStackTest();
	}

	/**
	 * 数组栈测试
	 */
	private static void arrayStackTest() {
		System.out.println("数组栈----------------");

		AarrayStack stack = new AarrayStack(5);
		Scanner scanner = new Scanner(System.in);
		while (true) {
			System.out.println("push : 压栈");
			System.out.println("pop  : 出栈");
			System.out.println("show : 显示");
			System.out.println("exit : 退出");
			String info = scanner.next();
			switch (info) {
			case "push":
				System.out.println("input a vlaue..");
				int value = scanner.nextInt();
				stack.push(value);
				break;
			case "pop":
				try {
					int val = stack.pop();
					System.out.println("value = " + val);
				} catch (Exception e) {
					System.out.println(e.getMessage());
				}
				break;
			case "show":
				stack.show();
				break;
			case "exit":
				System.out.println("bye-bye");
				scanner.close();
				return;
			default:
				System.out.println("input error");
				break;
			}

		}
	}

	/**
	 * 链表栈测试
	 */
	private static void linkedStackTest() {
		System.out.println("链表栈----------------");
		SinglelinkedStack stack = new SinglelinkedStack(5);
		Scanner scanner = new Scanner(System.in);
		while (true) {
			System.out.println("push : 压栈");
			System.out.println("pop  : 出栈");
			System.out.println("show : 显示");
			System.out.println("exit : 退出");
			String info = scanner.next();
			switch (info) {
			case "push":
				System.out.println("input a vlaue..");
				int value = scanner.nextInt();
				String name = "push";
				StackNode node = new StackNode(value, name);
				stack.push(node);
				break;
			case "pop":
				try {
					StackNode node1 = stack.pop();
					System.out.println("value = " + node1);
				} catch (Exception e) {
					System.out.println(e.getMessage());
				}
				break;
			case "show":
				stack.show();
				break;
			case "exit":
				System.out.println("bye-bye");
				scanner.close();
				return;
			default:
				System.out.println("input error");
				break;
			}

		}

	}
}
/**
 * 链表栈结构
 * @author lenovo
 */
class SinglelinkedStack {

	StackNode top;
	Integer maxSize;
	SingleLinkedList<StackNode> list;
	int count;//用来计数，判断栈满或空

	// 构造器 :初始化参数
	public SinglelinkedStack(int maxSize) {
		this.maxSize = maxSize;
		count=0;
		list = new SingleLinkedList<StackNode>();
		top = list.getHead();
	}

	// 栈空
	public boolean isEmpty() {
		return count == 0;
	}

	// 栈满
	public boolean isFull() {
		return count == maxSize;
	}

	// 进栈
	public void push(StackNode value) {
		if (isFull()) {
			System.out.println("栈满");
			return;
		}
		count++;
		top = list.add(value);
	}

	// 出栈
	public StackNode pop() {
		if (isEmpty()) {
			throw new RuntimeException("栈空");
		}
		count--;
		StackNode value = list.del();
		return value;
	}

	// 遍历
	public void show() {
		if (isEmpty()) {
			System.out.println("栈空");
			return;
		}
		System.out.println("--------");
		list.show();//正序打印,不符合栈的特性，应是后进入栈的节点先显示
		System.out.println("--------");
		list.show1();//逆序打印，借助java的stack结构
		System.out.println("--------");
		//使用show2是递归实现，该链表带头结点，参数需要是第一个有效节点而不是头结点
		list.show2(list.getHead().getNext());
	}
}

	/**
	 * 供栈使用的单链表(带头)的创建 
	 * 1.创建时有头结点，栈空时指向head
	 * 2.用头插创建，后续只需正常遍历
	 * 尾插创建，后续需要逆序遍历（利用java提供的Stack）
	 * 
	 * @author lenovo
	 *
	 * @param <Node>
	 */
	class SingleLinkedList<Node> {

		private StackNode head;

		// 构造器 产生一个头结点，方便创建连续的节点
		public SingleLinkedList() {
			head = new StackNode(-1, null);
		}

		public StackNode getHead() {
			return head;// 返回头结点
		}

		// 获取有效节点个数
		public int length() {
			StackNode temp = head.getNext();
			int len = 0;
			while (temp != null) {
				len++;
				temp = temp.getNext();
			}
			return len;
		}

		// 添加节点
		public StackNode add(StackNode node) {
			StackNode temp = head;
			while (true) {
				if (temp.getNext() == null) {
					break;
				}
				temp = temp.getNext();
			}
			temp.setNext(node);
			return temp.getNext();// 返回当前新添加的节点
		}

		// 删除节点（最后一个） 出栈
		public StackNode del() {
			StackNode temp = head;
			while (true) {
				if (temp.getNext().getNext() == null) {
					break;
				}
				temp = temp.getNext();
			}
			StackNode value = temp.getNext();// 返回被删除的节点
			temp.setNext(null);// 实现删除
			return value;
		}

		// 创建链表
		public void createLinkedList(int num) {
			if (num <= 0) {
				System.out.println("参数错误");
				return;
			}
			StackNode temp = head;
			for (int i = 0; i < num; i++) {
				StackNode node = new StackNode(i, "" + ("" + i).hashCode());
			// 尾插,需要逆序遍历（栈使用）
				temp.setNext(node);
				temp = temp.getNext();
			// 头插(删除时注意)
			//node.setNext(temp.getNext());
			//temp.setNext(node);
			}
		}

		// 不显示头结点（顺序）
		public void show() {
			if (head.getNext() == null) {
				return;
			}
			StackNode temp = head.getNext();
			while (temp != null) {
				System.out.println(temp);
				temp = temp.getNext();
			}
		}
		//逆序打印
		public void show1() {
			//1.利用java的stack
			Stack<StackNode> s = new Stack<StackNode>();
			StackNode temp = head;
			while(temp.getNext() != null) {
				s.push(temp.getNext());
				temp = temp.getNext();
			}
			while(!s.empty()) {
				System.out.println(s.pop());
			}
		}
		//2.递归逆序打印
		/*
		 * 想要实现不打印头结点，需要在栈结构中传进来的参数不是带头结点的链表，即参数head是第一个有效节点
		 * */
		public void show2(StackNode head) {
		/*
		 * if (head == null) { System.out.println(""); return; }
		 */
			if (head.getNext() != null) {
				show2(head.getNext());
			}
			System.out.println(head);
		}
	}
/**
节点
*/
class StackNode {
	private int val;
	private String data;
	private StackNode next;

	public StackNode(int val, String data) {
		super();
		this.val = val;
		this.data = data;
	}

	public StackNode getNext() {
		return next;
	}

	public void setNext(StackNode next) {
		this.next = next;
	}

	public int getVal() {
		return val;
	}

	public void setVal(int val) {
		this.val = val;
	}

	public String getData() {
		return data;
	}

	public void setData(String data) {
		this.data = data;
	}

	@Override
	public String toString() {
		return "Node [val=" + val + ", data=" + data + "]";
	}
}
/**
* 数组结构的栈
*/
class AarrayStack {

	int top;// 取值的下标
	int maxSize;// 最大容量
	int[] arr;// 存储结构

	// 构造器
	public AarrayStack(int maxSize) {
		top = -1;
		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;
		}
		arr[++top] = value;
	}

	// 出栈
	public int pop() {
		if (isEmpty()) {
			throw new RuntimeException("栈空");
		}
		return arr[top--];
	}

	// 显示【遍历】
	public void show() {
		if (isEmpty()) {
			System.out.println("栈空");
			return;
		}
		// 逆序打印
		for (int i = top; i >= 0; i--) {
			System.out.printf("arr[%d] = %d\n", i, arr[i]);
		}
	}

}