189 8069 5689
#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;
}
栈和队列是两种特殊的线性表，它们的逻辑结构和线性表相同，只是其运算规则较线性表有更多的限制，故又称它们为运算受限的线性表。
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.util包中的Stack类创建一个栈对象
public Object push(Object data);输入数据，实现压栈
public Object pop();输出数据，实现弹栈
public boolean empty()判空
public Object peek();查看栈顶元素
可以去查查API嘛
我也是学java的，大家一起进步。
Java队列的链式存储结构及实现：
类似于使用链式结构保存线性表，也可以采用链式结构来保存队列的元素，采用链式存储结构的队列也被称为链队列。
对于链队列而言，由于程序需要从rear端添加元素，然后从front端删除元素，因此考虑对链队列增加front、rear两个引用变量，使他们分别指向链队列的头、尾两个节点。
1、插入队列
对于链队列而言，插入操作的实现非常简单，只要创建一个新节点，让原rear节点的next指向新节点，在让rear指向新节点即可。
2、移除队列
对于链队列而言，删除操作的实现也是非常的简单，只要将原front节点指向原front节点的next节点，当然不要忘记释放原front节点的引用。
JAVA集合中的队列：
从JDK
1.5开始，java的集合框架提供了一个Queue接口，该接口代表了一个队列。实现该接口或者实现继承了该接口的类可以当做队列来使用。Queue里包含了 6
个方法，用于代表队列
所包含的3个标志性方法，如下所示：
(1)插入：在rear端插入元素。
(2)移除：在front端删除元素。
(3)访问：在front端访问元素。
JDK提供的工具类非常强大，它分别代表线性表、队列、栈三种数据结构提供了两种实现：顺序结构和链式结构。虽然LinkedList工具类的功能非常强大，既可以作为线性表来使用、又可以作为队列来使用，还可作为栈来使用，但对大部分程序而言，使用Arraylist和ArrayDeque时性能可能比LinkedList更好。
/**
* 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包下