Annuaire d'articles
avant-propos
Cet article explique principalement le contenu des piles et des files d'attente, donne leur implémentation de structure de séquence et leur implémentation de structure de chaîne,
et donne l'implémentation en langage C de sa fonction d'opération
1. Présentation des piles et des files d'attente
La méthode de traitement des données de la pile et de la file d'attente est encore très simple :
1.栈始终保持元素后进先出(LIFO)的原则
2.队列始终保持元素先进先出(FIFO)的原则
En même temps, il y a un autre point d’attention :
Faire sauter la pile ou retirer la pile et la file d'attente supprimera l'élément correspondant ; tandis que l'opération d'accès ne supprimera pas l'élément correspondant.
Deux, la pile
1. Pile de structures séquentielles
#include<stdio.h>
#define maxn 100
typedef struct zhan
{
int top1;
int top2;
int number1;
int number2;
int a[maxn];
};
void isempty(zhan * list,int judge)
{
if(judge)
{
if(list->number1<=0)
{
printf("栈1为空\n");
}
else
{
printf("栈1不空\n");
}
}
else
{
if(list->number2<=0)
{
printf("栈2为空\n");
}
else
{
printf("栈2不空\n");
}
}
}
void chushihua(zhan *list)
{
list->top1=-1;
list->top2=maxn;
list->number1=0;
list->number2=0;
}
void push(zhan *list,int judge,int n)
{
if(list->top1+1==list->top2) printf("满栈,失败\n");
if(judge)
{
list->number1=list->number1+1;
list->top1=list->top1+1;
list->a[list->top1]=n;
}
else
{
list->number2=list->number2+1;
list->top2=list->top2-1;
list->a[list->top2]=n;
}
}
int gettop(zhan *list,int judge)
{
if(judge)
{
if(list->number1==0)
{
printf("栈1为空\n");
}
else
{
return list->a[list->top1];
}
}
else
{
if(list->number2==0)
{
printf("栈2为空\n");
}
else
{
return list->a[list->top2];
}
}
}
void pritop(zhan *list,int judge)
{
if(judge)
{
if(list->number1==0)
{
printf("栈1为空\n");
}
else
{
printf("%d\n",list->a[list->top1]);
}
}
else
{
if(list->number2==0)
{
printf("栈2为空\n");
}
else
{
printf("%d\n",list->a[list->top2]);
}
}
}
void popup(zhan *list,int judge)
{
if(judge)
{
if(list->number1==0)
{
printf("栈1为空\n");
}
else
{
list->a[list->top1]=0;
list->top1=list->top1-1;
list->number1=list->number1+1;
}
}
else
{
if(list->number2==0)
{
printf("栈2为空\n");
}
else
{
list->a[list->top2]=0;
list->top2=list->top2+1;
list->number2=list->number2+1;
}
}
}
int main()
{
zhan x;
chushihua(&x);
isempty(&x,0);
isempty(&x,1);
for(int i=1;i<10;i++)
{
push(&x,0,2*i);
}
for(int i=1;i<10;i++)
{
push(&x,1,3*i);
}
isempty(&x,0);
isempty(&x,1);
for(int i=1;i<10;i++)
{
pritop(&x,0);
pritop(&x,1);
printf("%d %d\n",gettop(&x,0)+1,gettop(&x,1)+1);
popup(&x,0);
popup(&x,1);
}
isempty(&x,0);
isempty(&x,1);
}
2. Pile de structure de liste chaînée
#include<stdio.h>
#include<stdlib.h>
typedef struct node
{
int data;
struct node* next;
};
typedef struct zhan
{
node body;
int number;
};
int isempty(zhan *list)
{
if(list->number==0)
return 1;
else
return 0;
}
zhan *chushihua()
{
zhan *a;
a=(zhan *)malloc(sizeof(zhan));
a->number=0;
a->body.next=NULL;
return a;
}
void push(zhan *list,int n)
{
if(list->number==0)
{
node *s;
s=(node*)malloc(sizeof(node));
list->body.next=s;
s->data=n;
s->next=NULL;
list->number=list->number+1;
}
else if(list->number<0)
{
printf("栈初始化错误\n");
}
else
{
node *s;
s=(node*)malloc(sizeof(node));
s->next=list->body.next;
list->body.next=s;
s->data=n;
list->number=list->number+1;
}
}
int gettop(zhan *list)
{
if(list->number==0)
{
printf("栈为空,获取失败\n");
return 223333;
}
else
{
int temp;
temp=list->body.next->data;
return temp;
}
}
void pritop(zhan *list)
{
if(list->number==0)
{
printf("栈为空,获取失败\n");
}
else
{
int temp;
temp=list->body.next->data;
printf("%d\n",temp);
}
}
void popup(zhan *list)
{
if(list->number==0)
{
printf("栈为空，弹出失败\n");
}
else if(list->number==1)
{
free(list->body.next);
list->number=list->number-1;
}
else
{
node *per;
list->body.next=list->body.next->next;
per=list->body.next;
free(per);
list->number=list->number-1;
}
}
void destroy(zhan *list)
{
free(list);
printf("销毁成功\n");
}
int main()
{
zhan *a;
a=chushihua();
int b[4]={
5154351,4848,8444,55};
for(int i=0;i<4;i++)
{
push(a,b[i]);
}
if(!isempty(a))
{
printf("栈不空\n");
}
else
{
printf("栈为空\n");
}
for(int i=0;i<4;i++)
{
pritop(a);
printf("%d\n",gettop(a)+1);
popup(a);
}
popup(a);
if(!isempty(a))
{
printf("栈不空\n");
}
else
{
printf("栈为空\n");
}
destroy(a);
return 0;
}
3. File d'attente
Puisque la règle de la file d'attente est le premier entré, premier sorti, le point de l'image est que les éléments sont ajoutés à partir de la fin de la file d'attente, puis sortent de la tête de la file d'attente. Il est très difficile pour une structure de stockage séquentielle telle qu'un tableau d'ajouter simplement la queue et de supprimer la tête en mémoire, nous devons donc écrire une file d'attente circulaire pour gérer la structure de stockage séquentielle.
1. File d'attente de structure de séquence
#include<stdio.h>
#define maxn 10
typedef struct duilie
{
int top;
int tail;
int a[maxn];
int number;
int judge;
};
void chushihua(duilie *list)
{
list->top=0;
list->tail=-1;
list->number=0;
list->judge=0;
}
void isempty(duilie *list)
{
if((list->top%maxn)==(list->tail%maxn)||list->tail==-1)
{
printf("队列为空\n");
}
else
{
printf("队列不为空\n");
}
}
void push(duilie *list,int n)
{
if(list->judge==1&&(list->tail+1)%maxn==(list->top%maxn))
{
printf("队列为满，无法插入\n");
}
else
{
list->tail=list->tail+1;
list->a[list->tail%maxn]=n;
list->number=list->number+1;
if((list->tail+1)%maxn==(list->top%maxn))
{
list->judge=1;
}
}
}
void pritop(duilie *list)
{
if((list->top%maxn)==(list->tail%maxn))
{
printf("队列空\n");
}
else
{
printf("%d\n",list->a[list->top%maxn]);
}
}
int gettop(duilie *list)
{
if((list->top%maxn)==(list->tail%maxn))
{
printf("队列空\n");
return 2233333;
}
else
{
return list->a[list->top%maxn];
}
}
void popup(duilie *list)
{
if((list->top%maxn)==(list->tail%maxn))
{
printf("队列空\n");
}
else
{
list->top=list->top+1;
list->number=list->number-1;
}
}
int main()
{
duilie x;
isempty(&x);
chushihua(&x);
printf("%d %d\n",x.tail,x.top);
for(int i=0;i<11;i++)
{
push(&x,2*i);
}
for(int i=0;i<8;i++)
{
pritop(&x);
popup(&x);
printf("%d %d\n",x.tail,x.top);
}
for(int i=0;i<10;i++)
{
push(&x,3*i);
printf("%d %d\n",x.tail,x.top);
}
for(int i=0;i<10;i++)
{
pritop(&x);
popup(&x);
printf("%d %d\n",x.tail,x.top);
}
return 0;
}
2. File d'attente de structure de chaîne
#include<stdio.h>
#include<stdlib.h>
typedef struct body
{
int value;
struct body *next;
};
body *init()
{
body *first=(body*)malloc(sizeof(body));
first->next=NULL;
first->value=0;
printf("创建成功\n");
return first;
}
void isemp(body *first)
{
if(first->next==NULL||first==NULL)
{
printf("循环队列为空\n");
}
else printf("循环队列不为空\n");
}
int length(body *first)
{
if(first->next==NULL)
{
return 0;
}
else
{
return first->value;
}
}
int gettop(body *first)
{
if(first->next==NULL)
{
printf("循环队列为空表，取值无效\n");
return 223333;
}
else
{
int temp;
body *per;
per=first->next;
return per->value;
}
}
void printtop(body *first)
{
if(first->next==NULL)
{
printf("循环队列为空表，取值无效\n");
}
else
{
int temp;
body *per;
per=first->next;
printf("%d\n",per->value);
}
}
void push(body* first,int value1)
{
body *per;
per=first;
for(int k=1;k<first->value;k++)
{
per=per->next;
}
body *temp;
temp=(body*)malloc(sizeof(body));
temp->value=value1;
temp->next=first->next;
first->next=temp;
per->next=temp;
printf("入队成功\n");
first->value=first->value+1;
}
void popuptop(body *first)
{
body* per;
per=first;
if(per->next==NULL)
{
printf("出队失败\n");
}
else
{
per=first;
for(int k=1;k<first->value;k++)
{
per=per->next;
}
body *s;
s=first->next;
per->next=first->next->next;
first=per->next;
free(s);
first->value=first->value-1;
printf("出队成功\n");
}
}
void destroy(body *first)
{
body* per;
first->value=0;
per=first->next;
for(int i=1;i<=first->value;i++)
{
body* temp;
temp=per;
per=per->next;
free(temp);
}
first->next=NULL;
printf("销毁完成\n");
}
Résumer
Veuillez être patient et corriger toute erreur dans l'article
. L'article utilise beaucoup de contenu lié aux listes chaînées. Vous pouvez lire l'article :
"Introduction aux algorithmes" Apprentissage (12)----Liste chaînée (langage C)