顺序栈 链栈等C语言实现

最近复习C和数据结构，顺序栈是最简单的栈实现。它是用数组来存放数据，用一个int变量来记录当前栈顶元素的下标，用-1来表示空栈，结构简单。

写一个完整的测试程序，编译器虽然是C++的，但程序是按照C语言规范来写的。

程序实现：依次向栈中压入0~19二十个数字，然后依次出栈并输出。

头文件：SeqStack.h

//SeqStack.h

#define TRUE 1

#define FALSE 0

#define STACK_SIZE 20

typedef int ElementType;

typedef struct

{

ElementType data[STACK_SIZE];

int top;

}SeqStack;

void InitStack(SeqStack *s) {

s->top = -1;

}

int IsEmpty(SeqStack *s) {

if(s->top == -1) return TRUE;

return FALSE;

}

int IsFull(SeqStack *s) {

https://www.360docs.net/doc/9216357530.html,/syntaxhighlighting/OutliningIndicators/InBlock.gif"

/> if(s->top == STACK_SIZE-1) return TRUE;

return FALSE;

}

int Push(SeqStack *s, ElementType element) {

if(IsFull(s)) return FALSE;

s->top ++;

s->data[s->top] = element;

return TRUE;

int Pop(SeqStack *s, ElementType *element) {

if(IsEmpty(s)) return FALSE;

*element = s->data[s->top];

s->top --;

return TRUE;

}

int GetTop(SeqStack *s,ElementType *element) {

if(IsEmpty(s)) return FALSE;

*element = s->data[s->top];

return TRUE;

iningIndicators/ExpandedBlockEnd.gif" />}

主文件：SeqStackTest.cpp

//SeqStackTest.cpp

#include

#include "SeqStack.h"

void main() {

//initialization

SeqStack s;

InitStack(&s);

//input

for(int i=0; i<20; i++) {

Push(&s,i);

}

//output

while(!IsEmpty(&s)) {

int rslt;

Pop(&s,&rslt);

printf("%d ",rslt);

}

g align="top" alt=""

src="https://www.360docs.net/doc/9216357530.html,/syntaxhighlighting/OutliningIndicators/ExpandedBlockEnd.gif" />}

链栈C语言实现

顺序栈的实现依靠数组，而数组需要事先声明长度，一次性地静态地分配内存空间。这样就给我们带来很多不便。因为我们事先并不能精确地估计栈所需的大小，估计大了浪费空间，估计小了后果就严重了，导致程序无法正常运行。所以我们通常使用链栈这种数据结构。

链栈用链表作为存储结构，栈初始化时仅需给栈顶指针分配内存空间，而后每当有数据入栈时再为该数据分配空间，这样实现了内存空间的动态分配。理论上栈的大小可以是无限大的（小心撑爆你的内存o(∩_∩)o）。不存在顺序栈的诸多问题。

程序实现：依次把0~99压栈，再依次出栈并打印。

程序清单：LinkStack.h LinkStackTest.c

LinkStack.h

/**//* LinkStack.h */

#include

#define TRUE 1

#define FALSE 0

#define NULL 0

typedef int ElementType;

typedef struct node ...{

ElementType data;

struct node *next;

}StackNode, *LinkStack;

void InitStack(LinkStack top) ...{

top->next = NULL;

}

int IsEmpty(LinkStack top) ...{

if(top->next == NULL) return TRUE;

return FALSE;

}

int Push(LinkStack top, ElementType element) ...{ StackNode *temp;

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

if(temp == NULL) return FALSE;

temp->data = element;

temp->next = top->next;

top->next = temp;

return TRUE;

}

int Pop(LinkStack top, ElementType *element) ...{ if(IsEmpty(top)) return FALSE;

StackNode *temp = top->next;

*element = temp->data;

top->next = temp->next;

free(temp);

return TRUE;

}

void GetTop(LinkStack top, ElementType *element) ...{ *element = top->next->data;

}

LinkStackTest.c

/**//* LinkStackTest.c */

#include

#include "LinkStack.h"

void main() ...{

LinkStack s;

s = (LinkStack)malloc(sizeof(StackNode));

InitStack(s);

for(int i=0; i<100; i++)

Push(s,i);

int rslt;

while (!IsEmpty(s)) ...{

Pop(s,&rslt);

printf("%d ",rslt);

}

}

两个链表的交叉合并

#include

#include

typedef struct Node

{

int data;

Node *next;

} node,*linklist;

/*

该函数用来创建链表

*/

linklist creat(linklist head)

{

node *r,*s;

int a;

r = (linklist)malloc(sizeof(node));

head = r;

scanf("%d",&a);

while(a != 0)

{

s =(node*)malloc(sizeof(node));

s->data=a;

r->next=s;

r=s;

printf("please input a data:");

scanf("%d",&a);

}

r->next=NULL;

return head;

}

/*用于实现链表A,B的组合*/

linklist mergel(linklist A,linklist B)

{

node *p,*q,*s,*t;

linklist C;

p=A->next;

q=B->next;

C=A;

while(p&&q)

{

s=p->next;

p->next=q;

if(s)

{

t=q->next;

q->next=s;

}

p=s;

q=t;

}

return C;

}

int main()

{

linklist p,A,B,C;

printf("Creat linklist A:");

A = creat(A);

printf("Creat linklist B:");

B = creat(B);

C = mergel(A,B);

p = C->next;

while(p)

{

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

p = p->next;

}

printf("Over\n");

getchar();

getchar();

return 0;

}