栈的理解和代码实现(java)

从数据结构的角度来看，其实栈也是线性表。特殊性在于栈和队列的基本操作是线性表操作的子集，栈是操作受限制的线性表。

栈的定义

栈是限定仅在表尾进行插入或者删除操作的线性表。对于一个栈来说，表尾端有着特殊的含义，称为栈顶，表头端称为栈底，不含元素的空表称之为空栈，栈又称为后进先出的线性表，简称 LIFO（Last In First Out）结构。也就是说后存放的先取，先存放的后取，这就类似于我们要在取放在箱子底部的东西（放进去比较早的物体），我们首先要移开压在它上面的物体（放进去比较晚的物体）。

和线性表类似，栈已有两种存储表示方法，分别称之为顺序栈和链栈。

顺序栈的实现：

顺序栈是指利用顺序存储结构实现的栈，即利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素，同时附设top指示栈顶元素在顺序栈中的位置。

实现栈功能的泛型类：

package 顺序栈;

import java.lang.reflect.Array;
import java.util.Arrays;

public abstract class OrderStack<T> {

	private int maxSize;
	protected T arr[];
	private int top;
	
	public OrderStack(Class<T> componentType) {
		this.maxSize = 1024;
		this.arr = (T[]) Array.newInstance(componentType, this.maxSize);
		this.top = 0;
	}
	
	public OrderStack(Class<T> componentType, int maxSize) {
		this.maxSize = maxSize;
	}

	public int getSize() {
		return top;
	}
	
	public int getMaxSize() {
		return maxSize;
	}
	
	public void expandMaxSize(int maxSize) {
		Arrays.copyOf(arr, this.maxSize + maxSize);
		this.maxSize += maxSize;
	}
	
	public void push(T data) {
		if(this.top > this.maxSize) {
			throw new IllegalArgumentException("new element will be out of limits.");
		}
		arr[this.top] = data;
		this.top++;
	}
	
	public T pop() {
		if(this.top == 0) {
			throw new IllegalArgumentException("this stack is already empty");
		}
		this.top--;
		return arr[this.top];
	}
	
	public T peek() {
		if(this.top == 0) {
			throw new IllegalArgumentException("this stack is already empty");
		}
		return arr[this.top - 1];
	}	
	
	public boolean isEmpty() {
		return this.top == 0 ? true : false;
	}
	
	public boolean isFull() {
		return this.top == this.maxSize ? true : false;
	}

}

Integer实现类：

package 顺序栈;

public class IntegerStack extends OrderStack<Integer> {

	public IntegerStack() {
		super(Integer.class);
		// TODO Auto-generated constructor stub
	}
	
	public IntegerStack(int maxSize) {
		super(Integer.class, maxSize);
	}
	
	public void print() {
		System.out.println("top");
		System.out.println("------");
		for (int i = this.getSize() - 1; i >= 0; i--) {
			System.out.println(arr[i]);
		}
		System.out.println("------");
		System.out.println("bottom");
	}

}

测试类：

package 顺序栈;

public class IntegerStackDemo {

	public static void main(String[] args) {
		IntegerStack test = new IntegerStack();
		System.out.println("size is: " + test.getSize());
		System.out.println("is empty: " + test.isEmpty());
		test.print();
		
		System.out.println("===============");

		test.push(2);
		test.push(5);
		test.push(7);
		test.push(8);

		System.out.println("size is: " + test.getSize());
		System.out.println("is empty: " + test.isEmpty());		
		test.print();
		
		System.out.println("================");		
		
		System.out.println("first element is: " + test.peek());
		test.pop();
		System.out.println("first element is: " + test.peek());
		System.out.println("size is: " + test.getSize());
		test.print();
		
		System.out.println("================");
	}
}

链栈的实现

链栈是采用链式存储结构实现的栈，通常链栈采用单链表来实现，由于栈的主要操作是在栈顶进行插入和删除，所以以链表的头部作为栈顶最为方便，且没必要向单链表那样为了操作方便而加一个头结点

链栈类代码：

package 链栈;

public class LinkStack {

	private Element top;
	private Element base;
	
	class Element {
		public Object data;
		public Element next;
		
		public Element() {
			this.data = null;
			this.next = null;
		}
		
		public Element(Object data, Element next) {
			this.data = data;
			this.next = next;
		}
	}
	
	public void initStack() {
		top = new Element();
		base = new Element();
		top.next = base;		
	}
	
	public void push(Object e) {
		Element ele = new Element(e, null);
		ele.next = top.next;
		top.next = ele;
	}
	
	
	public void pop() {
		if(top.next == base) {
			System.out.println("栈中没有元素");
		}
		else {
			Element e = top.next;
			System.out.println("出栈操作：" + e.data);
			top.next = top.next.next;
			e = null;
		}
	}
	
	
	public Object getTop() {
		if(top.next == base) System.out.println("栈中没有元素");
		return top.next.data;
	}
	
	public boolean isEmpty() {
		return top.next == base ? true : false;
	}
	
	public void printStack() {
		System.out.println("打印栈");
		Element ele = top;
		while(ele.next != base) {
			System.out.println(ele.next.data);
			ele = ele.next;
		}
	}
	
	
}

链栈测试类代码：

package 链栈;

public class LinkStackDemo {

	public static void main(String[] args) {
        LinkStack lStack = new LinkStack();
        lStack.initStack();
        lStack.pop();
        lStack.push(1);
        lStack.push(2);
        lStack.push(3);
        lStack.push(4);
        lStack.printStack();
         
        lStack.pop();
        lStack.pop();
        lStack.printStack();
         
        lStack.pop();
        lStack.pop();
        lStack.printStack();
        lStack.pop();
	}
}

栈与递归(栈的应用)

所谓递归就是在一个函数、过程或者数据结构定义的内部又出现定义本身的应用，那么我们称它们是递归的或者是递归定义的。

递归的基本思想就是将一个较大的问题分解为若干个规模较小解法相同或相似的问题去解决，每一个较小的问题又可以分解成规模更小的子问题去解决。可以说，递归问题的解决就是多个有依赖关系问题的解决。

函数的广义递归和狭义递归

从函数调用的层次看，函数的调用关系就是一个广义递归的过程：

public class Test {

	void function_a() {
		function_b();
	}
	
	void function_b() {
		function_c();
	}
	
	void function_c() {
		return;
	}
}

函数a调用函数b，函数b中调用函数c，函数c返回，函数b返回，函数a返回，这种递归调用的并不是自身，所以成为广义递归。

相反的，这就是产生了狭义的“递归函数“，即函数内又调用函数自身。

递归过程与递归工作栈

一个递归函数，在函数的执行过程中，需要多次进行自我调用，在高级语言编制的程序中，调用函数和被调用函数之间的链接及信息交换需要通过栈来进行实现。

当程序执行到某个函数时，将这个函数进行入栈操作，在入栈之前，通常需要完成三件事。

　　1、将所有的实参、返回地址等信息传递给被调函数保存。

　　2、为被调函数的局部变量分配存储区。

　　3、将控制转移到北调函数入口。

当一个函数完成之后会进行出栈操作，出栈之前同样要完成三件事。

　　1、保存被调函数的计算结果。

　　2、释放被调函数的数据区。

　　3、依照被调函数保存的返回地址将控制转移到调用函数。

上述操作必须通过栈来实现，即将整个程序的运行空间安排在一个栈中。每当运行一个函数时，就在栈顶分配空间，函数退出后，释放这块空间。所以当前运行的函数一定在栈顶。

注：出自严蔚敏等人的数据结构c语言第二版