数据结构Java语言描述之栈的操作实现

1、栈的描述

栈是一种先进后出的存储数据的结构。

2、栈的实现方式

栈操作的实现方式分为两种：线性栈和链式栈

2.1、线性栈的描述

以int值1，2，3，4分别进行压栈操作如下图所示

图（一）将1先压入栈中，并记录栈数组的数据长度为1；

              图（一）

以此类推完成全部数据的入栈操作

2.2、链式栈的描述

2.2.1、头插法

头插法又称倒序插入法，将新节点只在头节点（header）之后进行插入操作。

2.2.2

同样，以int值1，2，3，4分别进行压栈操作，采用头插法来实现，如下图所示

             

          图（一）                                                               图（二）

                                          图（三）

3、代码的实现

3.1、数组栈的实现

package com.stack;

/**
 * 用数组实现栈的操作
 */
public class ArrayStack {
    //数组的容量
    private final int SIZE = 10;

    //当前栈的长度
    private int length;

    //数组栈，以此来存储数据
    private int[] stack = null;

    /**
     * 构造函数
     * 完成栈的初始化
     */
    public ArrayStack () {
        stack = new int [SIZE];
        length= SIZE;
    }

    /**
     * 将数据压入栈中
     * @param data 数值
     * @throws Exception
     */
    public void push(int data) throws Exception {
        if(length < 0) {
            throw new Exception("该栈为已满！");
        }

        /**
         * 根据栈的先入后出的特性
         * 以及数组随机访问时间为O(1)的性质
         * 将要压入的数据倒序的存储在数组中
         * 以此来避免数组对插入操作效率低下的问题
         */
        stack[--length] = data;
    }

    /**
     * 将数据从栈中取出来
     * @throws Exception
     */
    public int pop() throws Exception {
        if(length == SIZE) {
            throw new Exception("该栈为已空！");
        }

        /**
         * 将数据取出时正序的访问数组
         */
        int data = stack[length++];

        return data;
    }
}

3.2、链表的实现

3.2.1、节点的实现

package com.node;

/**
 * 单链表节点
 *
 */
public class Node {
    //数据
    public int data;

    //指向下一个节点的引用
    public Node next;

    public Node() {}

    /**
     * 初始化节点数据
     * @param data 数据
     */
    public Node(int data) {
        this.data = data;
    }
}

3.2.2、链式栈的实现

package com.stack;

import com.node.Node;

/**
 * 使用链式实现栈的操作
 */
public class LinkStack {
    //头节点
    private Node header = null;

    /**
     * 初始化头节点
     * 头节点中的数据用来存储链表的长度
     */
    public LinkStack () {
        header = new Node(0);
    }

    /**
     * 将节点压入栈中
     * 采用链表的头插法来实现的栈的先入后出的特性
     * @param node 要push到栈的新节点
     */
    public void push (Node node) {
        Node temp = header;

        if (temp.next == null) {
            temp.next = node;
            node.next = null;
            ++ temp.data;
        } else {
            temp = temp.next;
            header.next = node;
            node.next = temp;
            ++ header.data;
        }
    }

    /**
     *
     * @return 返回一个节点
     * @throws Exception
     */
    public Node pop () throws Exception{
        Node temp = header;

        if(temp.next != null) {
            temp = temp.next;
            header.next = temp.next;
            -- header.data;
            return temp;
        } else {
            throw new Exception("该栈为空！");
        }

    }
}

4、测试

4.1、数组栈的测试

package com.test;

import com.stack.ArrayStack;

/**
 * 数组栈的测试
 */
public class ArrayStackTest {

    public static void main(String[] args) throws Exception {
        ArrayStack arrayStack = new ArrayStack();

        arrayStack.push(1);
        arrayStack.push(2);
        arrayStack.push(3);
        arrayStack.push(4);
        arrayStack.push(5);


        System.out.println(arrayStack.pop());
        System.out.println(arrayStack.pop());
        System.out.println(arrayStack.pop());
        System.out.println(arrayStack.pop());
        System.out.println(arrayStack.pop());
    }

}

其结果：

4.2、链式栈的测试

package com.test;

import com.node.Node;
import com.stack.LinkStack;

/**
 * 链式栈的测试
 */
public class LinkStackTest {

    public static void main(String[] args) throws Exception {
        LinkStack linkStack = new LinkStack();

        linkStack.push(new Node(5));
        linkStack.push(new Node(6));
        linkStack.push(new Node(7));
        linkStack.push(new Node(8));

        Node node = linkStack.pop();
        System.out.println(node.data);

        Node node1 = linkStack.pop();
        System.out.println(node1.data);

        Node node2 = linkStack.pop();
        System.out.println(node2.data);

        Node node3 = linkStack.pop();
        System.out.println(node3.data);
    }
}

其结果：

5、结束