DS:栈&队列基本操作

栈

• 像桶一样，后进先出LIFO(Last In First Out)
• 可以实现顺序变更；
• 作用:回溯

定义(使用顺序表，最好使用双向链表)

typedef struct Stack{
    int array[100];
    int top;//栈顶；有多少元素；
} Stack;

初始化

void stackInit(Stack*stack)
{
   stack->top = 0;
}

压栈(尾插)

void StackPush(Stack*stack,int value)
{
   stack->array[stack->top] = value;
   stack->top++;
}

出栈(尾删)

void StackPop(Stack*stack){
   stack->top--;
}

返回栈顶元素

int StackTop(const Stack*stack){
   return stack->array[stack->top-1];
}

判断是否为空

int StackEmpty(const Stack*stack){
     return stack->top==0?1:0;
}

获取栈长

int StackSize(const Stack*stack){
 return stack->top;
}

---

队列

• 保证公平性；
• 先进先出；

定义(使用单链表)

typedef struct Node{
    int value;
    struct Node*next;
}Node;
typedef struct Queue{
   Node*front;//记录队列头；
   Node*end;//记录队列尾；
   int size;
}Queue;

初始化

void QueueInit(Queue*queue){
   queue->front = NULL;
   queue->end = NULL;
   queue->size = 0;
}

销毁

void QueueDestory(Queue*queue){
    Node*node,*next;
    for(node = queue->front;node!=NULL;node = next){
        next = node->next;
        free(node);
    }
    queue->front = queue->end=NULL;
    queue->size = 0;
}

队插入-链表尾插

void QueuePush(Queue*queue,int val){
   Node*node = (Node*)malloc(sizeof(Node));
   node->value = val;
   node->next =NULL;
   queue->size++;
   if(queue->end!=NULL)
   { 
      queue->end->next = node;
      queue->end = node; 
   }
   else
   {
       queue->front = queue->end = node;
   }
}

队删除-链表头删

void QueuePop(Queue*queue){
    assert(queue->size>0);
    queue->size--;
    Node*get = queue->front;
    queue->front = get->next;
    free(get);
    if(queue->front==NULL){
       queue->end =NULL;
    }//处理只有一个节点的情况；
}

返回队尾元素

int QueueEnd(const Queue*queue){
    return queue->end->value;
}

判空

int QueueEmpty(const Queue*queue){
    return queue->size!=0?0:1;
}