第六周项目2-建立链栈算法库

最新推荐文章于 2016-09-29 11:14:52 发布
GL906376500
最新推荐文章于 2016-09-29 11:14:52 发布
阅读量502
点赞数
本文链接：https://blog.csdn.net/GL906376500/article/details/49075643
版权
01./*       
02.Copyright (c)2015,烟台大学计算机与控制工程学院       
03.All rights reserved.       
04.文件名称：第6周项目2--建立链栈算法库.cpp       
05.作    者：刘强       
06.完成日期：2015年10月8日       
07.版 本 号：v1.0       
08.       
09.问题描述：定义链栈存储结构，实现其基本运算，并完成测试。  
10.输入描述：若干数据。 
11.程序输出：各个步骤的文字叙述及其数据的输出。 
12.*/  
/*      
Copyright (c)2015,烟台大学计算机与控制工程学院      
All rights reserved.      
文件名称：第6周项目2--建立链栈算法库.cpp      
作    者：刘强      
完成日期：2015年10月8日      
版 本 号：v1.0      
      
问题描述：定义链栈存储结构，实现其基本运算，并完成测试。 
输入描述：若干数据。
程序输出：各个步骤的文字叙述及其数据的输出。
*/（1）头文件head.h

[cpp] view plaincopyprint?
01.#include<stdio.h>   
02.#include<malloc.h>   
03.typedef char ElemType;  
04.typedef struct linknode  
05.{  
06.    ElemType data;              //数据域   
07.    struct linknode *next;      //指针域   
08.} LiStack;                      //链栈类型定义   
09.  
10.  
11.void InitStack(LiStack *&s);  //初始化栈   
12.void DestroyStack(LiStack *&s);  //销毁栈   
13.int StackLength(LiStack *s);  //返回栈长度   
14.bool StackEmpty(LiStack *s);  //判断栈是否为空   
15.void Push(LiStack *&s,ElemType e);  //入栈   
16.bool Pop(LiStack *&s,ElemType &e);  //出栈   
17.bool GetTop(LiStack *s,ElemType &e);  //取栈顶元素   
18.void DispStack(LiStack *s);  //输出栈中元素  
#include<stdio.h>
#include<malloc.h>
typedef char ElemType;
typedef struct linknode
{
    ElemType data;              //数据域
    struct linknode *next;      //指针域
} LiStack;                      //链栈类型定义


void InitStack(LiStack *&s);  //初始化栈
void DestroyStack(LiStack *&s);  //销毁栈
int StackLength(LiStack *s);  //返回栈长度
bool StackEmpty(LiStack *s);  //判断栈是否为空
void Push(LiStack *&s,ElemType e);  //入栈
bool Pop(LiStack *&s,ElemType &e);  //出栈
bool GetTop(LiStack *s,ElemType &e);  //取栈顶元素
void DispStack(LiStack *s);  //输出栈中元素

（2）源文件：


[cpp] view plaincopyprint?
01.#include"head.h"   
02.void InitStack(LiStack *&s)  
03.{  
04.    s=(LiStack *)malloc(sizeof(LiStack));  
05.    s->next=NULL;  
06.}  
07.  
08.  
09.void DestroyStack(LiStack *&s)  
10.{  
11.    free(s);  
12.}  
13.int StackLength(LiStack *s)  
14.{  
15.    int i=0;  
16.    s=s->next;  
17.    while(s!=NULL)  
18.    {  
19.        i++;  
20.        s=s->next;  
21.    }  
22.    return i;  
23.}  
24.bool StackEmpty(LiStack *s)  
25.{  
26.    if(s->next==NULL)  
27.    {  
28.        return true;  
29.    }  
30.    else return false;  
31.}  
32.void Push(LiStack *&s,ElemType e)  
33.{  
34.    LiStack *l;  
35.    l=(LiStack *)malloc(sizeof(LiStack));  
36.    l->data=e;  
37.    l->next=s->next;  
38.    s->next=l;  
39.}  
40.bool Pop(LiStack *&s,ElemType &e)  
41.{  
42.    LiStack *l;  
43.    l=s;  
44.    if(l->next==NULL)  
45.    {  
46.        return false;  
47.    }  
48.    l=s->next;  
49.    e=l->data;  
50.    s->next=l->next;  
51.    free(l);  
52.    return true;  
53.}  
54.bool GetTop(LiStack *s,ElemType &e)  
55.{  
56.    if(s->next==NULL)  
57.    {  
58.        return false;  
59.    }  
60.    e=s->next->data;  
61.    return true;  
62.}  
63.void DispStack(LiStack *s)  
64.{  
65.    LiStack *l;  
66.    l=s;  
67.    l=l->next;  
68.    while(l!=NULL)  
69.    {  
70.        printf("%c",l->data);  
71.        l=l->next;  
72.    }  
73.    printf("\n");  
74.  
75.  
76.}  
#include"head.h"
void InitStack(LiStack *&s)
{
    s=(LiStack *)malloc(sizeof(LiStack));
    s->next=NULL;
}


void DestroyStack(LiStack *&s)
{
    free(s);
}
int StackLength(LiStack *s)
{
    int i=0;
    s=s->next;
    while(s!=NULL)
    {
        i++;
        s=s->next;
    }
    return i;
}
bool StackEmpty(LiStack *s)
{
    if(s->next==NULL)
    {
        return true;
    }
    else return false;
}
void Push(LiStack *&s,ElemType e)
{
    LiStack *l;
    l=(LiStack *)malloc(sizeof(LiStack));
    l->data=e;
    l->next=s->next;
    s->next=l;
}
bool Pop(LiStack *&s,ElemType &e)
{
    LiStack *l;
    l=s;
    if(l->next==NULL)
    {
        return false;
    }
    l=s->next;
    e=l->data;
    s->next=l->next;
    free(l);
    return true;
}
bool GetTop(LiStack *s,ElemType &e)
{
    if(s->next==NULL)
    {
        return false;
    }
    e=s->next->data;
    return true;
}
void DispStack(LiStack *s)
{
    LiStack *l;
    l=s;
    l=l->next;
    while(l!=NULL)
    {
        printf("%c",l->data);
        l=l->next;
    }
    printf("\n");


}

（3）main函数：


[cpp] view plaincopyprint?
01.#include"head.h"   
02.int main()  
03.{  
04.    ElemType e;  
05.    LiStack *s;  
06.    printf("(1)初始化链栈s\n");  
07.    InitStack(s);  
08.    printf("(2)链栈为%s\n",(StackEmpty(s)?"空":"非空"));  
09.    printf("(3)依次进链栈元素a,b,c,d,e\n");  
10.    Push(s,'a');  
11.    Push(s,'b');  
12.    Push(s,'c');  
13.    Push(s,'d');  
14.    Push(s,'e');  
15.    printf("(4)链栈为%s\n",(StackEmpty(s)?"空":"非空"));  
16.    printf("(5)链栈长度:%d\n",StackLength(s));  
17.    printf("(6)从链栈顶到链栈底元素:");  
18.    DispStack(s);  
19.    printf("(7)出链栈序列:");  
20.    while (!StackEmpty(s))  
21.    {  
22.        Pop(s,e);  
23.        printf("%c ",e);  
24.    }  
25.    printf("\n");  
26.    printf("(8)链栈为%s\n",(StackEmpty(s)?"空":"非空"));  
27.    printf("(9)释放链栈\n");  
28.    DestroyStack(s);  
29.    return 0;  
30.}  
#include"head.h"
int main()
{
    ElemType e;
    LiStack *s;
    printf("(1)初始化链栈s\n");
    InitStack(s);
    printf("(2)链栈为%s\n",(StackEmpty(s)?"空":"非空"));
    printf("(3)依次进链栈元素a,b,c,d,e\n");
    Push(s,'a');
    Push(s,'b');
    Push(s,'c');
    Push(s,'d');
    Push(s,'e');
    printf("(4)链栈为%s\n",(StackEmpty(s)?"空":"非空"));
    printf("(5)链栈长度:%d\n",StackLength(s));
    printf("(6)从链栈顶到链栈底元素:");
    DispStack(s);
    printf("(7)出链栈序列:");
    while (!StackEmpty(s))
    {
        Pop(s,e);
        printf("%c ",e);
    }
    printf("\n");
    printf("(8)链栈为%s\n",(StackEmpty(s)?"空":"非空"));
    printf("(9)释放链栈\n");
    DestroyStack(s);
    return 0;
}
运行结果：