链式栈



1.编写头文件

#define
datatype
int

struct
statcknode

{

int
num;                
//编号

datatype
data;          
//数据

struct
statcknode *pNext;//指针域

};

typedef
struct
statcknode
StackNode;

//初始化

StackNode *
init(StackNode
*pHead);

//进栈

StackNode *
push(StackNode
*pHead,int
num,datatype
data);

//出栈

StackNode *
pop(StackNode
* pHead,StackNode
*poutdata);

//清空

StackNode *
freeall(StackNode
*pHead);

//打印

StackNode *
printfAll(StackNode
*pHead);

2.编写链表的实现代码

#include
"stacklinknode.h"

#include
"stdio.h"        
//NULL在stdio.h中

#include
"stdlib.h"       
//malloc在stdlib.h中

//初始化

StackNode *
init(StackNode
*pHead)

{

return
NULL;

}

//进栈

StackNode *
push(StackNode
*pHead,
int
num,
datatype
data)

{

StackNode *pNewNode
= (StackNode *)malloc(sizeof(StackNode));

pNewNode->num
= num;

pNewNode->data
= data;

pNewNode->pNext
= NULL;

//如果是空的链式栈

if (pHead
== NULL)

{

pHead =
pNewNode;

}

else

{

//备份一个头指针

StackNode *p
= pHead;

while (p->pNext
!= NULL)

{

//一直向前

p =
p->pNext;

}

//插入

p->pNext
= pNewNode;

}

//返回头结点

return
pHead;

}

//出栈

StackNode *
pop(StackNode
* pHead,
StackNode *poutdata)

{

if (pHead
== NULL)

{

//已经没有元素

return
NULL;

}

//表示只有一个元素的时候

else
if (pHead->pNext
== NULL)

{

poutdata->num
= pHead->num;

poutdata->data
= pHead->data;  
//取出数据

free(pHead);//释放内存

pHead =
NULL;

return
pHead;

}

else

{

StackNode *p
= pHead;

//表示栈顶的倒数第二个节点

while (p->pNext->pNext
!= NULL)

{

//循环到倒数第二个节点

p =
p->pNext;

}

poutdata->num
= p->pNext->num;

//取出数据

poutdata->data
= p->pNext->data;

p->pNext
= NULL;

return
pHead;

}

}

//清空

StackNode *
freeall(StackNode
*pHead)

{

if (pHead
== NULL)

{

return
NULL;

}

else

{

StackNode *p1
= NULL, *p2
= NULL;

//头结点

p1 =
pHead;

while (p1->pNext
!= NULL)

{

//保存下一个节点

p2 =
p1->pNext;

//跳过p2

p1->pNext
= p2->pNext;

//释放节点

free(p2);

}

free(pHead);

return
NULL;

}

}

//打印

StackNode *
printfAll(StackNode
*pHead)

{

if (pHead
== NULL)

{

return
NULL;

}

else

{

printf("%d,%d,%p,%p\n",
pHead->num,
pHead->data,
pHead,
pHead->pNext);

//通过递归的方式进行打印

printfAll(pHead->pNext);

}

}

3.实现代码main.c

#pragma warning(disable:4996)

//#define_CRT_SECURE_NO_WARNINGS

#include
<stdio.h>

#include
<stdlib.h>

#include
"stacklinknode.h"

void
main1()

{

int
num;

scanf("%d",
&num);

//打印数据

printf("num
= %d\n",num);

//创建一个链式栈的头节点

StackNode *pHead
= NULL;

printf("\n\n");

//通过这种方式实现打印打印十进制的二进制的表现形式

while (num)

{

printf("%d\n",
num % 2);

pHead =
push(pHead,
num % 2, 0);

num /= 2;

}

while (pHead
!= NULL)

{

StackNode *pOut
= (StackNode *)malloc(sizeof(StackNode));

pHead =
pop(pHead,pOut);

printf("%d",pOut->num);

}

system("pause");

}

void
main()

{

StackNode *pHead
= NULL;
//创建一个链式栈的头节点

pHead =
init(pHead);   
//设置栈为NULL

pHead =
push(pHead,
1, 1);

pHead =
push(pHead,
2, 11);

pHead =
push(pHead,
3, 111);

pHead =
push(pHead,
4, 1111);

pHead =
push(pHead,
5, 11111);

printfAll(pHead);

/* pHead =freeall(pHead);

printf("\n释放以后");

printfAll(pHead);*/

while (pHead
!= NULL)

{

//保存出栈的数据

printf("出栈\n");

StackNode *pOut
= (StackNode *)malloc(sizeof(StackNode));

pHead =
pop(pHead,
pOut);

printf("出栈之后\n");

printfAll(pHead);

printf("\n出栈之后的数据%d,%d",
pOut->num,
pOut->num);

}

system("pause");

}

链式栈,布布扣,bubuko.com

时间: 2024-10-11 20:14:27

链式栈的相关文章

C++__链式栈(练习)

链式栈 stack.h #ifndef STACK_H_ #define STACK_H_ typedef int data_type; enum STACK_OP { STACK_ERR = -1, STACK_OK, STACK_EMPTY }; class STACK { private: data_type data; STACK *next; public: STACK(); STACK(data_type data); ~STACK(); data_type getData() co

C++链式栈

LinkStack: //链式栈 #include<iostream> using namespace std; typedef int elemType; typedef struct StackNode { elemType data; StackNode *next; }*LinkList; struct LinkStack { LinkList top; int count; }; //初始化 void InitStack(LinkStack *S) { S->top = NUL

链式栈的实现

链表实现的栈,在想象栈的时候,最好把他竖着想象成一个立着的容器. 然后往里面一个一个的加节点: 1.先加入top节点 2.然后再在top节点上加入node1节点,node1节点指向top节点 3.再在node1节点上加入node2节点,node2节点指向node1节点 .......... 下面描述用java实现链式栈的代码: Stack.java          链式栈的接口 1 package com.yeyan.linkstack; 2 /** 3 * 链式栈的接口 4 * @autho

链式栈总结

基本数据结构之—链式栈 链式栈-其实简单的理解就是一个受到操作限制的单向链表,因为栈只有简单的一些操作,比如:入栈,出栈,获取栈顶,栈的清空等 先分析一下栈的基本数据吧 栈作为一种容器,那么需要存储数据的地方,为了方便,只存储数据的开始地址是一个不错的选择 为了快速的知道栈的长度,我们在维护一个长度的参数,和顺序栈的区别是我们不用考虑容量的问题 当然你也可以维护更多的参数来支持你想要的操作. 栈的链式存储,底部使用的是链表的知识.为了方便操作和提升性能,我们将链表的头结点当做栈顶. 为了有个统一

数据结构基础(13) --链式栈的设计与实现

采用链式存储的栈成为链式栈(或简称链栈), 链栈的优点是便于多个栈共享存储空间和提高其效率, 且不存在栈满上溢的情况(因为链栈是靠指针链接到一起,只要内存够大, 则链栈理论上可以存储的元素是没有上限的); 与顺序栈相比, 由于顺序栈是采用的数组实现, 因此一旦数组填满, 则必须重新申请内存, 并将所有元素"搬家", 而链栈则省略了这一"耗时耗力"的工作, 但却需要付出附加一个指针的代价; 链栈通常采用单链表实现, 并规定所有的操作都必须实在单链表的表头进行, 而且w

[数据结构]栈之链式栈的类模板实现

栈的抽象基类的实现:(不用抽象基类也是可以的,为了使用虚函数方便) #ifndef STACK #define STACK //栈的抽象基类 template<class T> class Stack { public: Stack(){} ~Stack(){} virtual void Push(const T& x)=0; virtual bool Pop(T& x)=0; virtual bool getTop(T& x)const=0; virtual bool

C++实现链式栈,运用模板,界面友好,操作方便,运行流畅

//.h文件 #ifndef STACK_H #define STACK_H #include<iostream> #include<iomanip> using namespace std; template<typename T> //链式栈结点 struct L_Node { T data; L_Node<T>* next; L_Node(); L_Node(const T&item,L_Node<T>* next=NULL); /

栈的实现:链式栈

栈的链式存储,即链式栈.它相比于顺序栈, 优点: 插入.删除灵活 (不必移动节点,只要改变节点中的指针指向即可). 逻辑上相邻的节点物理上不必相邻. 缺点: 比顺序存储结构的存储密度小 (每个节点都由值域和链域组成,使用指针来表现前后节点的逻辑关系). 查找节点时链式存储要比顺序存储慢. 这些优点.缺点体现了顺序存储和链式存储的相区别之处. 看图就很形象了: 下面来看一个链式栈的实现: 类定义和类实现 #include<iostream> using namespace std; typede

Java的顺序栈和链式栈

栈的定义 栈是限制在表的一段进行插入和删除的运算的线性表,通常能够将插入.删除的一端为栈顶,例外一端称为栈底,当表中没有任何元素的时候称为空栈. 通常删除(又称"退栈")叫做弹出pop操作,每次删除的都是栈顶最新的元素:每次插入(又称"进栈")称为压入push操作. 当栈满的时候,进行push 操作,会上溢,当空栈的时候进行退栈操作的时称为下溢. 上溢是一种出错的情况,下溢可能是正常的情况处理. 堆栈的运算是按照后进先出的原则,简称LIFO. 栈的基本运算定义: i