链栈的实现

链栈由以下2个操作:入栈操作和出栈操作,创建2个函数,具体实现在下面:

[cce_cpp]
#include <stdio.h>
#include <malloc.h>
typedef struct Node
{
char data;
struct Node *next;
}LstNode;

typedef LstNode *LStack;

LStack Push(LStack top,char x)
{
LstNode *temp;
temp=(LstNode*)malloc(sizeof(LstNode));
if(temp==NULL)
{
   printf("申请空间失败");
}
temp->data=x;
temp->next=top->next;
top->next=temp;
return (top);
}

char Pop(LStack top)
{
char x;
LstNode *temp;
if(top->next==NULL)
{
   printf("栈空无法出栈");
}
temp=top->next;
x=temp->data;
top->next=temp->next;
free(temp);
return (x);
}

main()
{
LStack LT;
char c;
LT=(LStack)malloc(sizeof(LstNode));
LT->next=NULL;
printf("请输入入栈字符:\n");
while((c=getchar())!='\n')
{
   LT=Push(LT,c);
}
printf("输出出栈字符:\n");
do
{
   c=Pop(LT);
   putchar(c);
}while(LT->next!=NULL);
printf("\n");
}
[/cce_cpp]
实现如下


链栈的实现
链栈的实现

顺序栈的实现

顺序栈由以下2个操作:入栈操作和出栈操作,创建2个函数,具体实现在下面:

[cce_cpp]
#include<stdio.h>
#include <malloc.h>
#define TRUE 1
#define FALSE 0
#define Stack_Size 50

typedef struct
{
char elem[Stack_Size];
int top;
}SeqStack;

int Push(SeqStack *S,char x)
{
if(S->top==Stack_Size-1)
   printf("栈已满无法进栈");
   S->top++;
   S->elem[S->top]=x;
   return (TRUE);
}
int Pop(SeqStack *S,char *x)
{
if(S->top==-1)
{
   printf("栈空无法出栈");
   return (FALSE);
}
else
{
   *x=S->elem[S->top];
   S->top--;
   return (TRUE);
}
}
void main()
{
SeqStack *ST;
char c1,*c2;
ST=(SeqStack*)malloc(sizeof(SeqStack));
c2=(char*)malloc(sizeof(SeqStack));
ST->top=-1;
printf("请输入字符:\n");
while((c1=getchar())!='\n')
{
   Push(ST,c1);
}
printf("输出出栈字符为:\n");
do
{
   Pop(ST,c2);
   putchar(*c2);
}
while(ST->top!=-1);

printf("\n");
}
[/cce_cpp]
实现如下


顺序栈的实现
顺序栈的实现

链队列的实现

链队列由以下2个操作:入队算法和出队算法,创建2个函数,具体实现在下面:

[cce_cpp]
#include <stdio.h>
#include <malloc.h>
#define NULL 0
#define true 1
#define false 0
typedef struct Node
{
char data;
struct Node *next;
}LinkQueueNode;
typedef struct
{
LinkQueueNode *front;
    LinkQueueNode *rear;
}LinkQueue;
int EnQueue(LinkQueue *q,char x)
{
LinkQueueNode *p;
p=(LinkQueueNode *)malloc(sizeof(LinkQueueNode));
if(p)
{
   p->data=x;
   p->next=NULL;
   q->rear->next=p;
   q->rear=p;
   return (true);
}
else
   return (false);

}
int Del_Q(LinkQueue *q,char *x)
{
LinkQueueNode *p;
p=(LinkQueueNode *)malloc(sizeof(LinkQueueNode));
if(q->front==q->rear)
   return (false);
p=q->front->next;
q->front->next=p->next;
if(q->rear==p)
   q->rear=q->front;
*x=p->data;
free(p);
return (true);
}
main()
{
LinkQueue *Q;
Q=(LinkQueue *)malloc(sizeof(LinkQueue));
Q->front=(LinkQueueNode *)malloc(sizeof(LinkQueueNode));
Q->rear=Q->front;
char x;
printf("输入入队的字符顺序:\n");
while((x=getchar())!='\n')
   EnQueue(Q,x);
printf("出队顺序:\n");
while(Del_Q(Q,&x))
{
   putchar(x);
}
printf("\n");
}
[/cce_cpp]
实现效果如下


链队列的实现
链队列的实现

顺序队列的实现

顺序队列由以下2个操作:入队算法和出队算法,创建2个函数,具体实现在下面:

<pre>[cce_cpp]
#include &lt;stdio.h&gt;
#include &lt;malloc.h&gt;
#define TRUE 1
#define FALSE 0
#define m 50
 
typedef struct
{
char elem[m];
int front;
int rear;
}SeqQueue;
 
void InitQueue(SeqQueue *q)
{
q-&gt;front=0;
q-&gt;rear=0;
}
 
int EnQueue(SeqQueue *q,int x)
{
if(q-&gt;rear==m)
{
   printf("队列已满");
   return (FALSE);
}
else
{
   q-&gt;elem[q-&gt;rear]=x;
        q-&gt;rear++;
   return (TRUE);
}
}
 
int DeQueue(SeqQueue *q,int x)
{
if(q-&gt;rear==q-&gt;front)
{
   printf("队空");
   return (FALSE);
}
else
{
   x=q-&gt;elem[q-&gt;front];
        q-&gt;front++;
   return x;
}
 
}
 
main()
{
SeqQueue *Q;
Q=(SeqQueue*)malloc(sizeof(SeqQueue));
int x;
InitQueue(Q);
printf("输入入队的数字:\n");
scanf("%d",&amp;x);
while(x!=0)
{
   EnQueue(Q,x);
   scanf("%d",&amp;x);
}
    printf("出队队列的数字:\n");
while(x=DeQueue(Q,x))
{
   printf("%2d",x);
}
printf("\n");
}[/cce_cpp]
实现的如下


顺序队列的实现
顺序队列的实现

顺序表的实现

顺序表主要是以下几个操作:初始化操作,插入操作,删除操作

[cce_cpp]
#include<stdio.h>
#include<conio.h>
#include<string.h>
#include<stdlib.h>
#include<malloc.h>
#define OK 1
#define ERROR 0
#define Max 50
typedef struct
{
int num;
char name[20];
int score;
}Ele_Type;
typedef struct
{ Ele_Type elem[50];
int length;
}seqlist;

int ListIn(seqlist *L,int i,Ele_Type x)
/*在顺序表L中第i个元素之前插入元素x */
{ int k;
     if((i<1)||(i>Max+1))
{ printf("i值不合法\n");
         return ERROR;
}
     if(L->length>=Max)
{ printf("表已满无法插入\n");
          return ERROR;
}
for(k=L->length-1;k>=i-1;k--)
{   L->elem[k+1]=L->elem[k];
}
L->elem[i-1].num=x.num;
strcpy(L->elem[i-1].name,x.name);
L->elem[i-1].score=x.score;
L->length++;
return OK;
}

int ListDel(seqlist *L, int i)
/*在顺序表L中删除第i个元素*/
{int k;
if((i<1)||(i>Max))
{
printf("i值不合法\n");
     return ERROR;
}
    for (k=i;k<=L->length-1;k++)
{ L->elem[k-1]=L->elem[k];
}
L->length--;
return OK;
}

void main()
{
int i;
seqlist *L;
Ele_Type stu[50]={
   {2001,"Gao Jie",92},
   {2002,"Dong Yuming",88},
   {2003,"Zhao Bin",55},
   {2004,"Gao Haiming",75}};
Ele_Type x={2008,"Wang Xiao",61};
L=(seqlist*)malloc(sizeof(seqlist));
L->length=4;
for(i=0;i<L->length;i++)
{ L->elem[i]=stu[i];
}
ListIn(L,3,x);
printf("Inserted seqlist is:\n");
for(i=0;i<L->length;i++)
{
   printf("%6d %s %5d\n",L->elem[i].num,L->elem[i].name,
   L->elem[i].score);
}
ListDel(L,2);
printf("Deleted seqlist is:\n");
for(i=0;i<L->length;i++)
{ printf("%6d %s %5d\n",L->elem[i].num,L->elem[i].name,L->elem[i].score);
}
free(L);
}
[/cce_cpp]
实现的如下图
顺序表的实现
顺序表的实现