手把手带你在Java中用【数组】和【链表】实现栈_java栈用数组和链表怎么写

一、栈的介绍

• 栈的英文为(stack)
• 栈是一个先入后出(FILO-First In Last Out)的有序列表。
• 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。
• 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除
  
  

二、应用场景

• 逆序输出
• 数制转换

三、代码实现

• 数组实现栈

public class ArrayStackDemo {
    public static void main(String[] args) {
        ArrayStack arrayStack = new ArrayStack(5);
        //显示栈内容
        arrayStack.show();
        //添加
        arrayStack.push(1);
        arrayStack.push(2);
        arrayStack.push(3);
        arrayStack.push(4);
        arrayStack.push(5);
        arrayStack.push(6);

        //显示栈内容
        System.out.println("添加值后的栈信息");
        arrayStack.show();

        //取出栈内容
        int stackPop = arrayStack.pop();
        System.out.println("取出的值为："+stackPop);
        int stackPop2 = arrayStack.pop();
        System.out.println("取出的值为："+stackPop2);
        //显示栈内容
        System.out.println("取出值后的栈信息");
        arrayStack.show();

    }


}

// 定义一个栈,用数组实现
class ArrayStack{
    //栈大小
    private int maxSize;
    //定义一个数组用于模拟栈
    private int[] stack;
    //定义栈顶为top，默认为-1
    private int top = -1;

    //创建栈需要定义栈大小
    public ArrayStack(int maxSize){
        this.maxSize = maxSize;
        this.stack = new int[this.maxSize];
    }

    // 判断栈空
    public boolean isEmpty(){
        return this.top == -1;
    }

    //判断栈满
    public boolean isFull(){
        return top == maxSize - 1;
    }

    //入栈
    public void push(int value){
        //判断是否栈满
        if(isFull()){
            System.out.println("栈已满！");
            return;
        }
        //将栈顶指针前进一位
        top++;
        //向栈中添加输入
        stack[top] = value;
    }

    //出栈
    public int pop(){
        //判断当前栈是否为空
        if(isEmpty()){
            System.out.println("当前栈空");
            throw new RuntimeException("当前栈无数据，不可出栈");
        }
        //将当前栈顶指向的数据存起来
        int value = stack[top];
        //栈顶后移一位
        top--;
        //将取得的数据返回
        return value;
    }

    //显示栈
    public void show(){
        //判断当前栈是否为空
        if(isEmpty()){
            System.out.println("当前栈空");
           return;
        }
        for (int i = top;i >= 0;i--){
            System.out.printf("stack[%d]=%d\n",i,stack[i]);
        }
    }
}

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

• 链表实现栈 - 有头节点

public class LinkedListStackDemo {
    public static void main(String[] args) {
        LinkedListStack linkedListStack = new LinkedListStack(5);
        //显示栈内容
        linkedListStack.show();
        //添加
        linkedListStack.push(1);
        linkedListStack.push(2);
        linkedListStack.push(3);
        linkedListStack.push(4);
        linkedListStack.push(5);
        linkedListStack.push(6);

        //显示栈内容
        System.out.println("添加值后的栈信息");
        linkedListStack.show();

        //取出栈内容
        int stackPop = linkedListStack.pop();
        System.out.println("取出的值为："+stackPop);
        int stackPop2 = linkedListStack.pop();
        System.out.println("取出的值为："+stackPop2);
        //显示栈内容
        System.out.println("取出值后的栈信息");
        linkedListStack.show();
    }
}

//用单向链表实现栈
class LinkedListStack {
    //栈大小
    private int maxSize;
    //定义一个节点用于当作头节点
    private Node first = new Node(-1);
    //定义栈顶为top，默认指向first
    private Node top = first;

    //创建栈需要定义栈大小
    public LinkedListStack(int maxSize){
        this.maxSize = maxSize;
    }

    //判断当前栈中有效节点，从头节点的下一个开始到top栈顶为有效节点
    public int size(){
        //判断有没有有效节点
        if(first.next == null){
            return 0;
        }
        int size = 0;
        //创建临时指针用于计算节点数量
        Node temp = first.next;
        while (true){
            size++;
            //当前指针指向栈顶时退出
            if(temp == top){
                break;
            }
            temp = temp.next;
        }
        return size;
    }

    // 判断栈空
    public boolean isEmpty(){
        return size() == 0;
    }

    //判断栈满
    public boolean isFull(){
        return size() == maxSize;
    }

    //入栈
    public void push(int value){
        //判断是否栈满
        if(isFull()){
            System.out.println("栈已满！");
            return;
        }
        //创建对象
        Node node = new Node(value);
        //将新对象添加到栈中
        top.next = node;
        //将栈顶指针前进至新对象
        top = node;
    }

    //出栈
    public int pop(){
        //判断当前栈是否为空
        if(isEmpty()){
            System.out.println("当前栈空");
            throw new RuntimeException("当前栈无数据，不可出栈");
        }
        //将当前栈顶指向的数据存起来
        int value = top.number;
        //栈顶前移一位
        //创建临时指针
        Node temp = first;
        while (true){
            //找栈顶
            //temp.next指向top,说明temp是要出栈的前一个节点，将该节点当作栈顶
            if(temp.next == top){
                top = temp;
                break;
            }
            //后移指针
            temp = temp.next;
        }
        //将取得的数据返回
        return value;
    }

    //显示栈，从栈顶开始显示
    public void show(){
        //判断当前栈是否为空
        if(isEmpty()){
            System.out.println("当前栈空");
            return;
        }
        //创建临时指针
        Node temp;
        //循环栈当前实际大小次
        for (int i = size(); i >= 0; i--) {
            //每次临时指针都从头开始
            temp = first;
            //打印最后一个元素
            for (int j = 0; j < i; j++) {
                temp = temp.next;
                if(j == i-1){
                    System.out.printf("stack[%d]=%d\n", j, temp.number);
                }
            }
        }
    }

}

class Node {
    int number;
    Node next;

    public Node(int number) {
        this.number = number;
    }

    @Override
    public String toString() {
        return "Node{number=" + this.number + "}";
    }
}
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151