链表栈和队列#

栈#

1
#include "nodes.h"
2
// 链表栈
3
/*
4
带头指针，头指针的值表示栈的深度
5
*/
6
// 链表栈
7
/*
8
带头指针，头指针的值表示栈的深度
9
*/
10
SNode* createStack()
11
{
12
    return createSNode(0);
13
}
14

15
// 入栈
16
void stack_push(SNode* shead, SNode* value)
17
{
18
    addSNodeToTheNext(shead, value);
19
    shead->value++;
20
}
21

22
// 出栈
23
SNode* stack_pop(SNode* shead)
24
{
25
    if(shead->value == 0)
26
    {
27
        return NULL;
28
    }
29

30
    shead->value--;
31
    return deleteSNode(shead, shead->next);
32
}
33

34
// 获得栈的深度
35
int stack_getLen(SNode* shead)
36
{
37
    return shead->value;
38
}

队列#

1
#include "nodes.h"
2
// 链式队列，f是头指针，r是尾指针
3
typedef struct
4
{
5
    struct SNode* f;
6
    struct SNode* r;
7
}Queue;
8

9
// 获得队列长度
10
int queue_getLen(Queue* q)
11
{
12
    SNode* f = q->f;
13
    return f->value;
14
}
15

16
/*
17
头指针的值表示队列的长度
18
*/
19
Queue* createQueue()
20
{
21
    Queue* q = (Queue* )malloc(sizeof(Queue));
22
    q->f = createSNode(0);
23
    q->r = q->f;
24
    return q;
25
}
26

27
// 入队列
28
void queue_push(Queue* q, SNode* newNode)
29
{
30
    SNode* f = q->f;
31
    f->value++; // 队列长度加1
32

33
    // 在尾指针后面添加一个结点，并让尾指针往后移
34
    addSNodeToTheNext(q->r, newNode);
35
    q->r = newNode;
36
}
37

38
// 出队列
39
SNode* queue_pop(Queue* q)
40
{
41
    if(queue_getLen(q) == 0) // 出队列前队列长度为0
42
    {
43
        return NULL;
44
    }
45

46
    SNode* f = q->f;
47
    f->value--;
48

49
    SNode* result = deleteSNode(f, f->next);
50

51
    if(queue_getLen(q)==0) // 出队列后队列长度为0
52
    {
53
        q->r = q->f;
54
    }
55

56
    return result;
57
}

原文链接：CSDN