Java数据结构-栈_栈数据结构 java

更多数据结构可以参考 Java数据结构

栈

实际需求

1. 计算器的底层是如何运算得到结果的？对于计算器而言，接收到的就是一个字符串。
2. 子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。
3. 处理递归调用：和子程序的调用类似，只是除了存储下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。
4. 表达式的转换[中缀表达式转后缀表达式]和求值，如计算器。
5. 二叉树的遍历。
6. 图形的深度优先(depth——first)搜索法。

栈的介绍

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

出栈和入栈示意图

使用数组模拟栈

思路分析

1. 使用数组模拟栈
2. 定义一个top表示栈顶，初始化为-1
3. 入栈的操作，当有数据入栈时，top++;stack[top]=data;
4. 出栈的操作，从栈顶取出一个数据并返回。int value = stack[top];top- -;return value;

代码实现

package com.datastructures.stack;

import java.util.Scanner;

public class ArrayStackDemo {
   

	public static void main(String[] args) {
   
		//测试ArrayStack是否正确
		//先创建一个ArrayStack的对象，即一个栈
		ArrayStack stack = new ArrayStack(4);
		String key = "";
		boolean loop = true; //控制是否退出菜单
		Scanner scanner = new Scanner(System.in);
		
		while(loop) {
   
			System.out.println("show：表示显示栈");
			System.out.println("exit：表示退出程序");
			System.out.println("push：表示添加数据到栈（入栈）");
			System.out.println("show：表示从栈中取出数据（出栈）");
			System.out.println("请输出你的选择：");
			key = scanner.next();
			switch (key) {
   
			case "show":
				stack.list();
				break;
			case "push":
				System.out.println("请输入一个数：");
				int value = scanner.nextInt();
				stack.push(value);
				break;
			case "pop":
				try {
   
					int res = stack.pop();
					System.out.printf("出栈的数据是%d\n",res);
				} catch (Exception e) {
   
					System.out.println(e.getMessage());
				}
				break;
			case "exit":
				scanner.close();
				loop = false;
				break;
			default:
				break;
			}
		}
		System.out.println("程序退出");
	}

}

//定义一个类ArrayStack 表示栈
class ArrayStack{
   
	private int maxSize; //栈的大小
	private int[] stack; //数组，数组模拟栈，数据就放在该数组
	private int top = -1; //top表示栈顶，初始化为-1
	
	//构造器
	public ArrayStack(int maxSize) {
   
		this.maxSize = maxSize;
		stack = new int[this.maxSize]; //根据传进来的栈大小，创建数组
	}
	
	//栈满
	public boolean isFull() {
   
		return top == maxSize - 1;
	}
	//栈空
	public boolean isEmpty() {
   
		return top == -1;
	}
	//入栈-push
	public void push(int value) {
   
		//先判断是否栈满
		if(isFull()) {
   
			System.out.println("栈满");
			return;
		}
		top++;
		stack[top] = value;
	}
	//出栈-pop，将栈顶的数据返回
	public int pop() {
   
		//先判断栈是否为空
		if(isEmpty()) {
   
			//抛出异常
			throw new RuntimeException("栈空");
		}
		int value = stack[top];
		top--;
		return value;
	}
	//遍历栈 遍历时需要从栈顶开始显示
	public void list() {
   
		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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

使用数组模拟栈，在删除时，虽然表面上看起来删除成功，其实在数组中，被删除的数据仍然存在；可以使用单链表来模拟栈。

使用单链表模拟栈

思路分析

考虑栈是先进后出，让head.next始终指向每次新插入的节点

代码实现

package com.datastructures.stack;

public class LinkedlistStackDemo {
   
    public static void main(String[] args) {
   

        StackNode stackNode1 = new StackNode(1);
        StackNode stackNode2 = new StackNode(2);
        StackNode stackNode3 = new StackNode(3);
        StackNode stackNode4 = new StackNode(4);
        StackNode stackNode5 = new StackNode(5
1
2
3
4
5
6
7
8
9
10
11