链表和队列

1. 单链表
   （1） 带头结点：head始终不等于NULL, head->next等于NULL的时候链表为空；
   （2） 不带头结点：head等于NULL时，链表为空；

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

1. 双链表
   （1） 单/双链表为空时，head->next==NULL;

typedef struct DoubleLinkNode
{
    int data;
    struct DoubleLinkNode *prior;
    struct DoubleLinkNode *next;
};

1. 循环单链表
   （1） 带头结点：为空：head==head->next；
   （2） 不带头结点：为空：head==NULL；
2. 循环双链表
   （1） 带头结点：为空：head->next==NULL&&head->prior==NULL:
   （2） 不带头结点：为空：head==NULL；
3. 静态链表：使用数组来实现；
4. 顺序栈
   （1） 定义

typedef struct SequenceStack
{
    int data[SIZE_MAX];
    int top;
};

（2） 栈空判断

int isEmpty(SequenceStack st)
{
    if (st.top == -1)
    {
        return 1;
    }
    return 0;
}

（3） 进栈

int push(SequenceStack &st, int x)
{
    if (st.top == SIZE_MAX-1)
    {
        return 0;
    }
    ++(st.top);
    st.data[st.top] = x;
    return 1;
}

（4） 出栈

int pop(SequenceStack &st, int &x)
{
    if (st.top == -1)
    {
        return 0;
    }
    x = st.data[st.top];
    --(st.top);
    return 1;
    {
    }
}

1. 链栈
   （1） 定义

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

（2） 栈空

int isEmpty(LinkStack *lst)
{
    if (lst->next == null)
    {
        return 1;
    }
    return 0;
}

（3） 进栈

void push(LinkStack *lst, int x)
{
    LinkStack *p;
    p = (LinkStack*)malloc(sizeof(LinkStack));
    p->next = NULL;
    //头插法
    p->data = x;
    p->next = lst->next;
    lst->next = p;
}

（4） 出栈

int pop(LinkStack *lst, int &x)
{
    LinkStack *p;
    if (lst->next == NULL)
    {
        return 0;
    }

    p = lst->next;
    x = p->data;
    lst->next = p->next;
    free(p);
    return 1;
}

1. 顺序队
   （1） 定义

typedef struct SequenceQueue
{
    int data[SIZE_MAX];
    int front;
    int rear;
};

（2） 循环队列
队空：queue.rear == queue.front
队满：(queue.rear+1)%max_size == queue.front
（3） 队空

int isEmpty(SequeenceQueue &queue)
{
    if (queue.front == queue.rear)
    {
        return 1;
    }
    return 0;
}

（4） 入队

int enQueue(SequenceQueue &queue, int x)
{
    if ((queue+1)%max_size==queue.front)
    {
        return 0;
    }
    queue.rear = (queue.rear + 1) % max_size;
    queue.data[queue.rear] = x;
    return 1;
}

（5） 出队

int deQueue(SequenceQueue &queue, int &x)
{
    if (queue.front == queue.rear)
    {
        return 0;
    }
    queue.front = (queue.front + 1) % max_size;
    x = queue.data[queue.front];
    return 1;
    {
    }
}

1. 链队
   （1） 定义

typedef struct QueueNode
{
    int data;
    struct QueueNode *next;
};
typedef struct LinkQueue
{
    struct LinkQueue *front;
    struct LinkQueue *next;
};

（2）队空

int isEmpty(LinkQueue *lqueue)
{
    if (lqueue.rear == NULL || lqueue.front == NULL)
    {
        return 1;
    }
    return 0;
}

（3） 入队

void enQueue(LinkQueue *lqueue, int x)
{
    QueueNode *p;
    p = (QueueNode*)malloc(sizeof(QueueNode));
    p->data = x;
    p->next = NULL;
    //队列为空，新结点为队首结点，也是队尾结点
    if (lqueue->rear == NULL)
    {
        lqueue->front = lqueue->rear = p;
    }
    else
    {
        lqueue->rear->next = p;
        lqueue->rear = p;
    }
}

（4） 出队

int deQueue(LinkQueue *lqueue, int &x)
{
    QueueNode *p;
    if (lqueue->rear==NULL)
    {
        return 0;
    }
    else
    {
        p = lqueue->front;
    }
    if (lqueue->front == lqueue->rear)
    {
        lqueue->front = lqueue->rear = NULL;
    }
    else
    {
        lqueue->front = lqueue->front->next;
    }
    x = p->data;
    free(p);
    return 1;
    {
    }
}