手写C语言知识梳理: 栈，队列，链表

栈（stack）：FILO

栈的初始化

int top = 0;       //栈顶指针
int size = 10;    // 栈可存储的的最大元素数量
int stack[size] = {0};



注意：
也可以用链表而不是数组来组成栈，好处是没有size的上限，如果不知道需要多大的栈，就应该用链表

栈的使用

入栈：

stack[top] = m;
top++;



出栈:
top = top-1;

队列（queue）：FIFO

队列的初始化

int head = 0;
int rear = 0;
int size = 10;
int a[size] = {0};

队列的使用：

增加（尾部）：

a[rear] = 10;
rear++;



删除（头部）：
head++；

数组 / 结构体数组：

数组就是地址连续的链表

链表：

链表的节点定义

typedef struct
{
    int val;
    Node *next;
}Node;


Node head;  //链表的开始地址

遍历链表

Node* temp = head;
while ( temp->next )
{
    
}


注释：
1. head是指向链表头的指针
2. 可以这么用while来遍历，是因为链表最后一个元素指向NULL,也就是0

增删改查

// p 指向链表表头, val是要找到的元素，add是要添加的元素
Node* insertNode(Node* p, int val, int add)
{
    Node* temp = p;
    Node* c = (Node*)malloc( sizeof(Node) );
    c->val = add;

    //1. 找到插入位置
    while ( temp->next )
    {
        if( temp->val == val )
        {
            //增加一个元素
            c->next = temp->next;      //先后顺序很重要
            temp->next = c;


            //删掉下一个元素
            temp->next = temp->next->next；  

            //改变该元素的内容
            temp->val = add;

            //查
            这个if语句，已经根据元素value查到了,temp就是该元素的地址
        }


        temp = temp->next;
    } 

}

栈 - 链表：

typedef struct
{
    int data;
    Stack* next;
}Stack;



// 因为是动态分配的，所以不需要知道size，一次加一个就是了
// 初始化
Stack* stack = (Stack*)malloc( sizeof(Stack) );



注意：
0. 因为是链表，所以不需要设置额外的栈顶指针，stack本身就是
1. malloc 返回的是分配的内存的首地址，为void类型指针。
2. 我们把它typecast成Stack型指针，之后就可以用来存储Stack型变量了
3. 允许直接使用 sizeof(Stack), sizeof(int), sizeof(char);    

栈的操作：

入栈：

需要注意的是，入栈是 把新的链表节点，挂靠在现有 stack的前面【因为这样删除元素最方便】

Stack *stack = Stack *malloc( sizeof(Stack) );  // 原始
Stack *new = Stack *malloc( sizeof(Stack) );    // 新元素

new->next = stack;
stack = new;





出栈：
stack = stack->next;


优雅的出栈：（释放内存）
temp = stack;
stack = stack->next;
free(temp);

队列 - 链表：

typedef struct
{
    int data;
    Queue* next;
}Queue;


// 因为是动态分配的，所以不需要知道size，一次加一个就是了
// 初始化
Queue* queue= Queue* malloc( sizeof(Queue) );
Queue* rear = queue;


注意：
1. 添加元素就在链表后面添加，跟stack正好相反 【因为这样删除元素最方便】
2. 同stack一样，queue就是队列的头。但是需要一个额外的rear指针指向链表尾部，方便之后添加元素，这点也和stack不一样
3. 总的来说 链表实现队列，比链表实现stack，要麻烦一点
4. 因为都是基于链表，所以声明的结构体是一模一样的

队列的操作：

添加：

Queue* queue = Queue* malloc( sizeof(Queue) );  //原始
Queue* new= Queue* malloc( sizeof(Queue) );     //新增元素


rear->next = new;
rear = new;





删除：
queue = queue->next;



优雅地删除：
temp = queue;
queue = queue->next;
free(temp);