java链式栈代码,栈的链式存储结构代码
用java实现数据结构“栈
Java栈的实现
创新互联拥有网站维护技术和项目管理团队，建立的售前、实施和售后服务体系，为客户提供定制化的网站设计、成都网站制作、网站维护、电信机房托管解决方案。为客户网站安全和日常运维提供整体管家式外包优质服务。我们的网站维护服务覆盖集团企业、上市公司、外企网站、商城网站建设、政府网站等各类型客户群体，为全球成百上千家企业提供全方位网站维护、服务器维护解决方案。
public class MyStack { //定义一个堆栈类
int[] array; //用int数组来保存数据，根据需要可以换类型
int s_size; //定义堆栈的宽度
public MyStack(int i){ //定义一个带参数构造器
array=new int[i]; //动态定义数组的长度
s_size=0; //堆栈的默认宽度为0
}
public MyStack(){ //默认构造器
this(50); //默认构造器可容纳50个元素
}
public void push(int i){ //压栈
array[this.s_size]=i;
this.s_size++;
}
public int pop(){ //从堆栈中取元素，从栈顶开始取
if(this.s_size!=0){
int t=array[s_size-1]; //用中间变量保存栈顶的元素
array[s_size-1]=0; //取完元素该位置设为0
s_size--; //栈的大小减1
return t; //返回栈顶元素
}else{
System.out.println("This stack is empty"); //当栈为空时显示提示信息，返回0
return 0;
}
}
public boolean isEmpty(){ //判断栈是否为空
return this.s_size==0;
}
public int top(){ //从栈顶取值，功能和 pop() 方法一样
if(!this.isEmpty()){
int t=array[this.s_size-1];
array[this.s_size-1]=0;
this.s_size--;
return t;
}else{
System.out.println("This stack is empty!");
return 0;
}
}
public void printAll(){ //打印出堆栈中的所有元素的值，不是取出，元素依然在堆栈里
if(!this.isEmpty()){
for(int i=this.s_size - 1;i=0;i--){
System.out.println(array[i]);
}
}
}
//下面是测试代码
public static void main(String[] args){
MyStack stack=new MyStack();
stack.push(4);
stack.push(5);
stack.push(6);
stack.push(7);
//System.out.println(stack.isEmpty());
stack.printAll();
System.out.println("===========");
System.out.println(stack.top());
System.out.println(stack.top());
System.out.println(stack.top());
System.out.println(stack.top());
System.out.println(stack.top());
}
}
用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 = e;
}
public E getValue() {
return value;
}
public void setValue(E value) {
this.value = 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(); i n; 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);
}
/**
* 优先级大小关系operator1 operator2 则返回true，否则false
* @param operator1
* @param operator2
* @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());
}
}
java用链表实现栈
public Object setEle(Object element)
{
Object oldElement = this.element;
this.element = element;
return oldElement;
}
是啥意思，给值还return？？把这函数删了
public Linked()
{
nextNode = null;
element = null;
}
改成
public Linked(Object element)
{
this.element = element;
nextNode = null;
}
用java语言编写算法 输出链栈中的所有元素
#includestdio.h
#includestdlib.h
struct node{
int data;
struct node* pre;
};
void print(struct node *p) //打印链栈
{while(p)
{printf("%d ",p-data);
p=p-pre;
}
}
int main()
{int i;
struct node *p,*q;
for(i=1;i11;i++) //1~10依次入栈
{p=(struct node*)malloc(sizeof(struct node));
if(i==1)p-pre=NULL;
else p-pre=q;
p-data=i;
q=p;
}
print(p);
return 0;
}
网站栏目：java链式栈代码,栈的链式存储结构代码
分享URL：http://6mz.cn/article/hceccp.html