链式栈java代码链栈实现 _public

用JAVA编一个班级成绩管理系统（我是一个初学者希望可以有注释）/**
* GenericLinkedStack.java
*/
package fix;
import java.util.EmptyStackException;
/**
*泛型的链式栈数据结构
*/
public class GenericLinkedStackE {
// 栈顶元素
private Item top = null;
// 返回栈顶元素，并弹出
public E pop() throws EmptyStackException {
if (isEmpty()) {
throw new EmptyStackException();
}
E e = top.value;
top = top.next;
return e;
}
/**
* 栈顶压入一个元素
* @param e 被压入的元素
*/
public void push(E e) {
Item curr = new Item(e);
curr.next = top;
top = curr;
}
/**
* 返回栈顶元素，但不出栈
* @return 栈顶元素
*/
public E peek() {
if (isEmpty()) {
throw new EmptyStackException();
}
return top.value;
}
/**
* 判断栈是否为空
* @return 判断结果
*/
public boolean isEmpty() {
return top == null;
}
/**
* 栈中元素
* @author jilen
*
*/
class Item {
//元素
private E value;
//下一个
private Item next;
public Item(E e) {
this.value = https://www.04ip.com/post/e;
}
public E getValue() {
return value;
}
public void setValue(E value) {
this.value = https://www.04ip.com/post/value;
}
public Item getNext() {
return next;
}
public void setNext(Item next) {
this.next = next;
}
}
}
/**
* InfixToPostfixConverter.java
*/
package fix;
import java.util.Hashtable;
/**
* @author jilen
*
*/
public class InfixToPostfixConverter {
// 操作符及其优先级组成的键值对
private static final HashtableCharacter, Integer operators;
private StringBuffer infix;
private StringBuffer postfix;
GenericLinkedStackCharacter stack = new GenericLinkedStackCharacter();
// 初始化操作符列表， static语句块会在加载类时自动执行
static {
operators = new HashtableCharacter, Integer();
operators.put('^', 4);
operators.put('*', 3);
operators.put('/', 3);
operators.put('%', 3);
operators.put(' ', 2);
operators.put('-', 2);
operators.put('(', -1);
operators.put(')', 5);
}
/**
*
*/
public InfixToPostfixConverter(StringBuffer infix, StringBuffer postfix) {
this.infix = infix;
this.postfix = postfix;
}
/**
* 转换函数
*/
public void convertToPostfix() {
// 对输入字符串中字符遍历
for (int i = 0, n = infix.length(); in; i) {
char c = infix.charAt(i);
// 是数字之间添加到转换后字符串
if (isNumber(c)) {
postfix.append(c);
} else if (isOperator(c)) {
switch (c) {
// '(' 直接入栈
case '(':
stack.push(c);
break;
// ')' 弹出元素直到碰到'('
case ')':
while (!stack.isEmpty()stack.peek() != '(') {
postfix.append(stack.pop());
}
stack.pop();
break;
// 其他操作符
default:
// 当前操作符比栈顶操作符优先级高，直接入栈
if (stack.isEmpty() || precedence(c, stack.peek())) {
stack.push(c);
}
// 当前操作符比栈顶操作符优先级低，出栈直到为空或栈顶优先级低于当前操作符
else if (!precedence(c, stack.peek())) {
while (!stack.isEmpty()!precedence(c, stack.peek())) {
postfix.append(stack.pop());
}
stack.push(c);
}
break;
}
}
}
// 若栈中还有操作符，所以元素出栈
while (!stack.isEmpty()) {
postfix.append(stack.pop());
}
}
/**
* 判断是否为操作符
* @param c
* @return
*/
public static boolean isOperator(char c) {
return operators.containsKey(c);
}
/**
* 优先级大小关系operator1operator2 则返回true，否则false
* @param operator1
* @param operator2
【链式栈java代码链栈实现】* @return 判断结果
*/
public static boolean precedence(char operator1, char operator2) {
return operators.get(operator1)operators.get(operator2);
}
/**
* 是否数字
* @param c 要判断的字符
* @return 判断结果
*/
public static boolean isNumber(char c) {
return c = '0'c = '9';
}
}
/**
*Main.java测试类
*/
package fix;
/**
* @author Administrator
*
*/
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
StringBuffer infix = new StringBuffer("(1 2)*3/4");
StringBuffer postfix = new StringBuffer();
InfixToPostfixConverter converter = new InfixToPostfixConverter(infix,
postfix);
converter.convertToPostfix();
System.out.println(postfix.toString());
}
}
中缀转后缀的程序，有GenericLinkedStack.java,InfixToPostfix.java,Main.java三个源文件需要放在fix包下
java语言中用LinkList实现堆栈栈和队列是两种特殊的线性表，它们的逻辑结构和线性表相同，只是其运算规则较线性表有更多的限制，故又称它们为运算受限的线性表。
LinkedList数据结构是一种双向的链式结构，每一个对象除了数据本身外，还有两个引用，分别指向前一个元素和后一个元素，和数组的顺序存储结构（如：ArrayList）相比，插入和删除比较方便，但速度会慢一些。
栈的定义
栈（Stack）是限制仅在表的一端进行插入和删除运算的线性表。
(1)通常称插入、删除的这一端为栈顶（Top），另一端称为栈底（Bottom）。
(2)当表中没有元素时称为空栈。
(3)栈为后进先出（Last In First Out）的线性表，简称为LIFO表。
栈的修改是按后进先出的原则进行。每次删除（退栈）的总是当前栈中"最新"的元素，即最后插入（进栈）的元素，而最先插入的是被放在栈的底部，要到最后才能删除。
实现代码：
package com.weisou.dataStruct;
import java.util.LinkedList;
@SuppressWarnings("unchecked")
public class MyStack {
LinkedList linkList = new LinkedListObject();
public void push(Object object) {
linkList.addFirst(object);
}
public boolean isEmpty() {
return linkList.isEmpty();
}
public void clear() {
linkList.clear();
}
// 移除并返回此列表的第一个元素
public Object pop() {
if (!linkList.isEmpty())
return linkList.removeFirst();
return "栈内无元素";
}
public int getSize() {
return linkList.size();
}
public static void main(String[] args) {
MyStack myStack = new MyStack();
myStack.push(2);
myStack.push(3);
myStack.push(4);
System.out.println(myStack.pop());
System.out.println(myStack.pop());
}
}
队列定义
队列（Queue）是只允许在一端进行插入，而在另一端进行删除的运算受限的线性表
（1）允许删除的一端称为队头（Front）。
（2）允许插入的一端称为队尾（Rear）。
（3）当队列中没有元素时称为空队列。
（4）队列亦称作先进先出（First In First Out）的线性表，简称为FIFO表。
实现代码：
package com.weisou.dataStruct;
import java.util.LinkedList;
/**
*
* @author gf
* @date 2009-11-13
*/
public class MyQueue {
LinkedList linkedList = new LinkedList();
//队尾插
public void put(Object o){
linkedList.addLast(o);
//队头取取完并删除
public Object get(){
if(!linkedList.isEmpty())
return linkedList.removeFirst();
else
return "";
}
public boolean isEmpty(){
return linkedList.isEmpty();
}
public int size(){
return linkedList.size();
}
public void clear(){
linkedList.clear();
}
/**
* @param args
*/
public static void main(String[] args) {
MyQueue myQueue= new MyQueue();
myQueue.put(1);
myQueue.put(2);
myQueue.put(3);
System.out.println(myQueue.get());
}
}
实现链式栈的基本操作：入栈、出栈、取栈顶元素、判定栈空、栈满。#include stdio.h
#include malloc.h
struct stack
{
int number;
struct stack *next;
};
struct stack *top;//指向栈顶
struct stack *p;//临时指针
//创建链栈
void create(int first_value)
{
p = (struct stack*)malloc(sizeof(struct stack));//申请内存空间
p-number = first_value;//给栈底赋值
p-next = NULL;//栈底的指针为空
top = p;//栈顶指向栈底
}
//进栈
void input(int value)
{
p = (struct stack*)malloc(sizeof(struct stack));//申请内存空间
p-number = value;//赋值
p-next = top;//指向原来的栈顶
top = p;//栈顶往上移动一位
}
//出栈
void output()
{
p = top;//p = 栈顶
top = top-next;//栈顶往下移动一位
free(p);//释放p
}
//清空栈
void clear()
{
while(top-next != NULL)//如果不是栈底
output();//出栈
free(top);//释放栈顶
}
//取栈顶元素
int topElement()
{
return top-number;
}
int main()
{
int i;
create(0);
for(i=1;i=10;i)
input(i);
//clear();
printf("\n栈的内容：\n");
for(p=top;;p=p-next)
{
printf("%d\n",p-number);
if(p-next == NULL)
break;
}
printf("栈顶元素=%d\n",topElement());
}
关于链式栈java代码和链栈实现的介绍到此就结束了，不知道你从中找到你需要的信息了吗？如果你还想了解更多这方面的信息，记得收藏关注本站。

链式栈java代码链栈实现

推荐阅读

桓山县在哪里桓州在哪里

endingnote什么意思如何在word中的endnotes中添加杂志格式，endnote参考文献style

大数据|十年远征（一个云操作系统的光荣与梦想）

木耳的营养价值和功效作用是什么木耳的营养价值和功效作用

打印机打印的时候为什么会有一段空白打印机网口有什么用

虾买回来怎么样才不会死买回来的虾放水里会死吗

硫酸钾复合肥

动态规划|hiho一下第109周 Tower Defense Game 树DP+贪心

小米扫地机器人怎么用

mysql数据库分页原理 mysql分页博客园

Cache|Cache Line 的理解

柿子饼的禁忌

丹姿水密码防晒霜怎么样

越南和伊朗哪个国家军事更强？

明日采集甲什么属性好明日之后采集甲属性

惠山高度

蜗牛阅读竞品分析,蜗牛睡眠竞品分析

鬼影相机APP怎么玩？详细使用流程介绍

阿里斯顿热水器6p1故障代码解决方法详解

核酸检测一次准确率有多高

链式栈java代码 链栈实现

推荐阅读

链式栈java代码链栈实现