（C语言）数据结构 --- 队列、栈

1 /*
2 * FILE: test.c
3 * ============
4 */
5
6 #include "QUEUE_linkedlist.h"
7 #include "STACK_linkedlist.h"
8
9 #include <stdio.h>
10
11 int main(void)
12 {
13 int i;
14
15 for(i=0; i<10; i++)
16 QUEUEput(i);
17 printf("QUEUE: FIFO\n");
18 for(i=0; i<10; i++)
19 printf("%d ", QUEUEget(i));
20 printf("\n");
21
22 for(i=0; i<10; i++)
23 STACKpush(i);
24 printf("STACK: LIFO\n");
25 for(i=0; i<10; i++)
26 printf("%d ", STACKpop(i));
27 printf("\n");
28 return 0;
29 }队列 queue：入队 put、出对get 1 /*
2 * FILE: QUEUE_linkedlist.c
3 * ========================
4 * 队列 queue
5 * 入队 put：放在链表尾部，并更新指向链表尾部的指针tail
6 * 出队 get: 返回并删除链表头部节点，并更新指向链表头部的指针head
7 */
8
9 #include "QUEUE_linkedlist.h"
10
11 // static 限制全局变量的作用域
12 static struct node *head = NULL, *tail = NULL;
13
14 // static 限制函数作用域，只作用于本文件
15 static struct node *NEW(int data)
16 {
17 struct node *new = (struct node *)malloc(sizeof(struct node));
18 new->data = data;
19 new->next = NULL;
20 return new;
21 }
22
23 int QUEUEget()
24 {
25 int res = head->data;
26 struct node *p = head;
27 head = head->next;
28 free(p);
29 return res;
30 }
31
32 void QUEUEput(int data)
33 {
34 if(head == NULL)
35 {
36 head = tail = NEW(data);
37 return;
38 }
39 tail->next = NEW(data);
40 tail = tail->next;
41 }
42
43 void QUEUEempty()
44 {
45 struct node *p =head;
46 while(p != NULL)
47 {
48 struct node *temp = p;
49 p = p->next;
50 free(temp);
51 }
52 head = tail = NULL;
53 }

1 /*
2  * FILE: QUEUE_linkedlist.h
3  * ========================
4  */
5
6 #include <stdlib.h>
7
8 struct node{
9         int data;
10         struct node *next;
11 };
12
13 int QUEUEget();
14 void QUEUEput(int data);
15 void QUEUEempty();

栈 stack：入栈push、出栈pop 1 /*
2 * FILE: STACK_linkedlist.c
3 * ========================
4 * 栈 stack 后进先出
5 * 入栈 push：放在链表头部，并更新链表头指针head
6 * 出栈 pop：返回并删除链表头部节点，并更新链表头指针head
7 */
8
9 #include "STACK_linkedlist.h"
10
11 // static 静态全局变量，限制了全局变量的作用域
12 static struct STACKnode *head = NULL;
13
14 // static 静态函数，限制了函数的作用域
15 static struct STACKnode *NEW(int data, struct STACKnode *head)
16 {
17 struct STACKnode *new = (struct STACKnode *)malloc(sizeof(struct STACKnode));
18 new->data = data;
19 new->next = head;
20 return new;
21 }
22
23 void STACKpush(int data)
24 {
25 head = NEW(data, head);
26 }
27
28 int STACKpop()
29 {
30 int res = head->data;
31 struct STACKnode *p = head;
32 head = head->next;
33 free(p);
34 return res;
35 }
36
37 void STACKempty()
38 {
39 struct STACKnode *p = head;
40 while(p != NULL)
41 {
42 struct STACKnode *temp = p;
43 p = p->next;
44 free(temp);
45 }
46 head = NULL;
47 }

/*
* FILE: STACK_linkedlist.h
* ========================
*/

#include <stdlib.h>

struct STACKnode{
int data;
struct STACKnode *next;
};

void STACKpush(int data);
int STACKpop();
void STACKempty();