数据结构与算法设计_链栈

/************************************************************JAVA******************************************************/

JAVA封装链栈操作类

测试数据

/***************************JAVA****************************/

public class LinkStack_value {
    public static void main(String[] args) {
        LinkStack_value lstack=new LinkStack_value();
        Node S1=null,S2=null;
        //初始化栈
        S1=lstack.initStackNode(S1);
        S2=lstack.initStackNode(S2);
        //判断栈空
        System.out.println(lstack.isStackEmpty(S1));
        //进栈
        for(int i=0;i<10;i++){
	    lstack.pushStack(S1, 2006+i);
        }
        lstack.pushStack(S1, Integer.MAX_VALUE);
        lstack.printStack(S1);
        //出栈
        lstack.popStack(S1);
        lstack.popStack(S1);
        lstack.popStack(S1);
        lstack.printStack(S1);
        //取栈顶元素
        System.out.println(lstack.get(S1));
        //求链栈长度
        System.out.println(lstack.stackLenth(S1));    
    }
    
    /**
     * 初始化栈
     * @param S 栈
     * @return
     */
    private Node initStackNode(Node top){
        if(top!=null) System.out.println("栈已存在");
	top=new Node(-1); //栈顶
	top.next=null;
	return top;
    }
    /**
     * 判断栈空
     * @param stack
     * @return
     */
    private boolean isStackEmpty(Node top){
    	if(top.next==null) return true;
	return false;
    }
    /**
     * 进栈
     * @param top
     * @param e 元素
     * @return
     */
    private boolean pushStack(Node top,int e){
	Node p=new Node(e);
	int tmp;  //巨坑
	p.next=top.next;
	top.next=p;
	tmp=top.data;
	top.data=p.data;
	p.data=tmp;
	return true;
    }
    /**
     * 出栈(删)
     * @param top 
     * @return
     */
    private boolean popStack(Node top){
    	if(isStackEmpty(top)) return false;
    	top.data=top.next.data;  //巨坑
    	top.next=top.next.next;
	return true;
    }
    /**
     * 取栈顶元素(不删)
     * @param top
     * @return
     */
    private int get(Node top){
    	if(isStackEmpty(top)) return -1;
	return top.data;
    }
    /**
     * 求链栈长度
     * @param top
     * @return
     */
    private int stackLenth(Node top){
	int count=0;
	Node p=top;
	while(p.next!=null){
            p=p.next;
	    count++;
	}
	return count;
    } 
    /**
     * 遍历栈
     * @param top
     */
    private void printStack(Node top){
    	Node p=top;
    	while(p!=null){
   	    System.out.print(p.data+" ");
	    p=p.next;
	}
	System.out.println();
    }
    /**
     * 节点类
     * @author GetWay
     */
    private class Node{
	private Node next;
	private int data;
	public Node(int data) {
	    this.data = data;
	}
    } 
}

 

/*************************************C**********************LinkedStack.h************************************************/

定义好头文件

/*******************C*******LinkedStack.h*********************/


struct node
{
    char data; //1个字节 
    struct node *next; //4个字节 
};

typedef struct node LStackNode; //取别名
typedef struct node *LinkStack;

//带有头结点的链栈,初始化 
void InitStack(LinkStack *top)
{
    if((*top=(LinkStack)malloc(sizeof(LStackNode)))==NULL) 
    {
	exit(-1); 
    }
    else
    {
	(*top)->next=NULL;
    } 
} 

//判断链栈是否为空
int StackEmpty(LinkStack top)
{
    if(top->next==NULL)
    {
	
	return 1;
    }
    else
    {
	return 0;
    } 
} 

//进栈，将节点插入头节点之前 
int PushStack(LinkStack top,char e) 
{
    LStackNode *p; //新节点指针
     if((p=(LStackNode *)malloc(sizeof(LStackNode)))==NULL)
     {
 	exit(-1);	
     }
     p->data=e;
     p->next=top->next;
     top->next=p;
     return 1;
}

 
//出栈，将链栈中的第一个节点删除
int PopStack(LinkStack top,char *e)
{
    LStackNode *p; 
    p=top->next; 
    if(!p)
    {
	return -1; 
    } 
    top->next=p->next;
    *e=p->data;
    free(p);
    return 1;	
} 

//取栈顶元素(第一个节点)操作
int GetTop(LinkStack top,char *e)
{
    LStackNode *p; //链栈节点指针
    p=top->next;
    if(!p)
    {
	return -1; 
    } 
    *e=p->data;
    return 1;
} 

//求链表长度
int StackLength(LinkStack top)
{	
    LStackNode *p; 
    int count=0; 
    p=top;
    while(p->next!=NULL)
    {
	p=p->next;		
	count++;
    }
    return count;
} 
 
//销毁链栈
void DestroyStack(LinkStack top)
{
    LStackNode *p,*q;
    p=top;
    while(!p)
    {
	q=p;
	p=p->next;
	free(q);	
    }
} 

LinkedStack.c   主函数调用

/********************C************LinkedStack.c********************/
#include <stdio.h>
#include <stdlib.h> 
#include <string.h>
#include "LinkedStack.h"

int main(void)
{
    LStackNode *s; 
    LinkStack S;
    char ch[50],e,*p;
	
    //初始化链栈 S
    InitStack(&S);
	
    //进栈， 
    printf("请输入进栈的字符:\n");
    gets(ch);  //gets获取用户输入的字符，赋给ch,ch最大49个 
    p=&ch[0];
    while(*p)
    {
	PushStack(S,*p);
	p++;
    }
		
    //取栈顶 
    printf("当前的栈顶元素:");
    GetTop(S,&e);
    printf("%4c\n",e);
	
    //栈长度 
     printf("当前栈中的元素个数:%d\n",StackLength(S)); 
	
    //出栈 
    printf("元素的出栈序列:");
    while(!StackEmpty(S))
    {
	PopStack(S,&e);
	printf("%4c",e);
    } 
    printf("\n");
	
    system("pause");
    return 0; 
}