用链表实现栈（Java语言）_java语言链表实现栈

数据结构与算法（Java实现）

用链表实现栈（Java语言）

（1）代码

package stack;

public class LinkedListStackDemo {
/*    public static void main(String[] args){
        LLStack llStack=new LLStack();
        llStack.push(1);
        llStack.push(2);
        llStack.push(3);
        System.out.println("栈里面值的个数为："+llStack.getLength());
        llStack.pop();
        System.out.println("pop一个之后，栈里面的个数 为 ："+llStack.getLength());
        System.out.println("pop一个之后，栈顶的值为："+llStack.top());
    }*/
    public static void main(String[] args){
        ListStack llStack=new ListStack(4);
        llStack.push(1);
        llStack.push(2);
        llStack.push(3);
        //System.out.println(llStack.peak());
        System.out.println(llStack.pop());
    }
}

class ListStack {

    Node header;//栈顶元素
    int elementCount;//栈内元素个数
    int size;//栈的大小

    /**
     * 构造函数，构造一个空的栈
     */
    public ListStack(){
        header=null;
        elementCount=0;
        size=0;
    }

    /**
     * 通过构造器自定义栈的大小
     * @param size
     */
    public ListStack(int size) {
        header=null;
        elementCount=0;
        this.size=size;
    }

    public void setHeader(Node header) {
        //this.header=header;
        this.header=header;
    }

    public boolean isFull() {
        if (elementCount==size) {
            return true;
        }
        return false;
    }

    public boolean isEmpty() {
        if (elementCount==0) {
            return true;
        }
        return false;
    }

    /**
     * 入栈
     * @param value
     */
    public void push(Object value) {
        if (this.isFull()) {
            throw new RuntimeException("Stack is Full");
        }
        //注意这里面试将原来的header作为参数传入，然后以新new出来的Node作为header
        header=new Node(value, header);
        elementCount++;
    }

    /**
     * 出栈
     * @return
     */
    public Object pop() {
        if (this.isEmpty()) {
            throw new RuntimeException("Stack is empty");
        }
/*        Object object=header.getElement();
        header=header.next;
        elementCount--;
        return object;*/
        Object object=header.getElement();
        header=header.next;
        elementCount--;
        return object;
    }

    /**
     * 返回栈顶元素
     */
    public Object peak(){

        if (this.isEmpty()) {
            throw new RuntimeException("Stack is empty");
        }
        //System.out.println(header.next);
        return header.getElement();
    }
}

class Node {

    Object element;
    Node next;
    public Node(Object element){
        this(element,null);
    }
    /**
     * 创建一个新的节点
     * 让他的next指向，参数中的节点
     * @param element
     * @param n
     */
    public Node(Object element,Node n){
        this.element=element;
        next=n;
    }

    public Object getElement() {
        return element;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

（2）运行结果