栈---Stack

Posted 2021-06-28 You295

栈---Stack

• 栈的概念
• 链表实现栈
• • 判断是否为空栈---.isEmpty()
  • 自己写一个打印语句---.print()
  • 入栈操作---.push()
  • 获取栈顶元素操作---.peek()
  • 获取栈顶元素并且删除操作---.pop()

栈的概念

栈是一种只允许在一端进行插入和删除的线性表。，它的操作受限制。
表中只允许进行删除和插入的一端称为栈顶，另外一端称为栈底。
栈中插入数据通常称为入栈或者进栈(push)，而栈的删除操作通常称为出栈或者退栈(pop)。
栈中无数据时称为空栈。
栈具有后进先出的特性，因此被称为后进先出表。

链表实现栈

1）定义节点

public class Node<E> {
	public E data;
	public Node<E> next;

	public Node() {

	}

	public Node(E data, Node<E> next) {

		this.data = data;
		this.next = next;
	}

	public E getData() {
		return data;
	}

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

	public Node<E> getNext() {
		return next;
	}

	public void setNext(Node<E> next) {
		this.next = next;
	}

	@Override
	public String toString() {
		return "Node [data=" + data + ", next=" + next + "]";
	}

}

2）定义栈

public class MyStack<E> {
	private Node<E> head; // 头结点
	private Node<E> top; // 栈顶
	private int size; // 栈的大小

	/**
	 * 获取栈的内容
	 */

	public int size() {
		return this.size;
	}

	/**
	 * 获得头结点
	 */
	public Node<E> head() {
		return this.head;
	}

判断是否为空栈—.isEmpty()

/**
	 * 判断是否为空栈
	 */

	public boolean isEmpty() {
		return this.size == 0;
	}

自己写一个打印语句—.print()

/**
	 * 打印语句
	 */
	public void print(Node<E> head) {
		System.out.println(head.data);
		if (head.next == null) {
			return;
		}
		print(head.next);
	}

入栈操作—.push()

/**
	 * 入栈操作--push
	 */

	public void push(E e) {
		final Node<E> newNode = new Node<>(e, null);

		if (isEmpty()) { // 当为空栈时
			head = newNode;
			top = head;
		} else { // 链表中的头插法
			final Node<E> first = head;
			newNode.next = first;
			head = newNode;
			top = newNode;
		}
		this.size++;
	}

测试：

@Test
	public void test() {
		MyStack<Integer> stack = new MyStack<Integer>();
		stack.push(1);
		stack.push(2);
		stack.push(3);
		stack.push(4);
		stack.push(5);
		stack.push(6);
		stack.push(7);
		
		stack.print(stack.head());

获取栈顶元素操作—.peek()

/**
	 * 获取栈顶元素操作 --peek
	 */

	public E peek() {
		if (isEmpty()) { // 为空栈时
			throw new ExecaptionDemo("空栈异常");
		} else {
			return top.data; // 返回栈顶元素的值
		}
	}

测试：

@Test
	public void test() {
		MyStack<Integer> stack = new MyStack<Integer>();
		stack.push(1);
		stack.push(2);
		stack.push(3);
		stack.push(4);
		stack.push(5);
		stack.push(6);
		stack.push(7);
		
		System.out.println(stack.peek());

获取栈顶元素并且删除操作—.pop()

/**
	 * 获取栈顶元素并且删除 --pop
	 */

	public E pop() {
		E e = peek(); // 首先获得栈顶元素
		//删除操作：
		Node<E> second = top.next;
		top = null;
		head = second;
		top = head;
		this.size--;
		return e;
	}

测试：

@Test
	public void test() {
		MyStack<Integer> stack = new MyStack<Integer>();
		stack.push(1);
		stack.push(2);
		stack.push(3);
		stack.push(4);
		stack.push(5);
		stack.push(6);
		stack.push(7);
		
		stack.print(stack.head());
		System.out.println(">>>>>>>>>>");
		stack.pop();
		stack.print(stack.head());