这期内容当中小编将会给大家带来有关Java中栈的线性结构是什么，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。
栈是限制插入和删除只能在一个位置上进行的表，此位置就是表的末端，叫作栈顶。
栈的基本操作分为push(入栈) 和 pop(出栈),前者相当于插入元素到表的末端（栈顶），后者相当于删除栈顶的元素。
public class LinearStack {
/**
* 栈的初始默认大小为10
*/
private int size = 5;
/**
* 指向栈顶的数组下标
*/
int top = -1;
/**
* 定义栈stack
*/
private int[] stack;
public LinearStack() {
stack = new int[size];
}
/**
* 判断栈满
*/
public boolean isFull() {
boolean result = false;
if(top == size - 1) {
result = true;
}
return result;
}
/**
* 入栈操作push
*/
public void push(int value) {
/**
* 如果栈满，拓展栈的容量
*/
if(isFull())
stack = expansionStack();
top++;
stack[top] = value;
}
/**
* 出栈操作
*/
public int pop() {
if(top == -1)
throw new RuntimeException("栈空！出栈失败");
int result = stack[top] ;
top--;
return result;
}
/**
* 扩充容量
*/
public int[] expansionStack() {
size = size + 10;
int[] stackTemp = new int[size];
for (int i = 0; i < stack.length; i++) {
stackTemp[i] = stack[i];
}
return stackTemp;
}
/**
* 获取栈顶的元素
*/
public int getTop() {
return stack[top];
}
/**
* 显示栈中的全部元素
*/
public String toString() {
String str = "[";
for (int i = 0; i <= top; i++) {
if(i == top)
str = str + stack[i] + "]";
else
str = str + stack[i] + ",";
}
return str;
}
}public class LinearStackTest {
public static void main(String[] args) {
LinearStack linearStack = new LinearStack();
/**
* 元素入栈
*/
linearStack.push(1);
linearStack.push(2);
linearStack.push(3);
linearStack.push(4);
linearStack.push(5);
/**
* 栈满，显示栈中所有元素
*/
System.out.println("0：arrayStack " + linearStack.toString());
/**
* 再次入栈
*/
linearStack.push(6);
/**
* 再次显示占中的所有元素
*/
System.out.println("1：arrayStack: " + linearStack.toString());
/**
* 获取栈顶元素
*/
System.out.println("获取栈顶元素：stack[top] = " + linearStack.getTop()+" top = " + linearStack.top);
/**
* 出栈
*/
System.out.println("出栈：stack[top] = " + linearStack.pop()+" top = " + linearStack.top);
/**
* 再次显示栈中的元素
*/
System.out.println("2：arrayStack: " + linearStack.toString());
}
}public class LinearStackChar {
private int size = 5;
/**
* 指向栈顶的数组下标
*/
int top = -1;
/**
* 定义栈stack
*/
private char[] stack;
public LinearStackChar() {
stack = new char[size];
}
/**
* 判断栈满
*/
public boolean isFull() {
boolean result = false;
if(top == size - 1) {
result = true;
}
return result;
}
/**
* 入栈操作push
*/
public void push(char value) {
/**
* 如果栈满，拓展栈的容量
*/
if(isFull())
stack = expansionStack();
top++;
stack[top] = value;
}
/**
* 出栈操作
*/
public char pop() {
if(top == -1)
throw new RuntimeException("栈空！出栈失败");
char result = stack[top] ;
top--;
return result;
}
/**
* 扩充容量
*/
public char[] expansionStack() {
size = size + 10;
char[] stackTemp = new char[size];
for (int i = 0; i < stack.length; i++) {
stackTemp[i] = stack[i];
}
return stackTemp;
}
/**
* 获取栈顶的元素
*/
public char getTop() {
return stack[top];
}
/**
* 显示栈中的全部元素
*/
public String toString() {
String str = "[";
for (int i = 0; i <= top; i++) {
if(i == top)
str = str + stack[i] + "]";
else
str = str + stack[i] + ",";
}
return str;
}
}public class LinearStackCharTest {
public static void main(String[] args) {
/**
* 判断一个字符串abcba是不是回文序列？
* 思路：将字符串切割成为单个字符，存放在字符栈中；
* 然后出栈，判断出栈后字符数组组成的字符串是否和原字符串相等；
* 相等--回文序列
* 不相等--不是回文序列
*/
String str = "abcba";
LinearStackChar linearStackChar = new LinearStackChar();
//讲字符串切割，存放在栈中
for (int i = 0; i < str.length(); i++) {
linearStackChar.push(str.charAt(i));
}
//存放完成，显示栈中的元素
System.out.println("stack = " + linearStackChar.toString());
//出栈
String result = "";
int length = linearStackChar.top;
System.out.println("top = " + length);
for (int i = 0; i <= length; i++) {
result = result + String.valueOf(linearStackChar.pop());
}
//出栈组成的字符串
System.out.println("result = " + result);
//判断是否相等
System.out.println("result = abcba? " + (result.equals("abcba") ? true : false));
}
}上述就是小编为大家分享的Java中栈的线性结构是什么了，如果刚好有类似的疑惑，不妨参照上述分析进行理解。如果想知道更多相关知识，欢迎关注亿速云行业资讯频道。
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
