队列和栈详解

队列和栈

size:队列大小

head:头指针

tail:尾指针

队列性质：

1.先进先出（first in first out）

循环队列解决假溢出的问题

代码演示--顺序表实现

using namespace std;

typedef struct Vector {

       int* data;

       int size;

       int capatity;

}Vector;

typedef struct Queue {

       Vector* data;

       int size;

       int head;

       int tail;

       int count;

}Queue;

Vector* initVector(int n) {

       Vector* v = (Vector*)malloc(sizeof(Vector));

       v->size = 0;

       v->capatity = n;

       v->data = (int*)malloc(sizeof(int) * n);

       return v;

}

Queue *initQueue(int n) {

       Queue* q=(Queue*)malloc(sizeof(Queue));

       q->data = initVector(n);

       q->size = n;

       q->head = q->tail = q->count=0;

       return q;

}

int empty(Queue* q) {

       if (q == NULL) return 1;

       return q->count == 0;

}

int insertVector(Vector *v, int pos, int val) {

       if (pos < 0 || pos >= v->capatity) return 0;

       v->data[pos] = val;

       v->size += 1;

       return 1;

}

int push(Queue *q, int val) {

       if (q->size == q->count) return 0;

       insertVector(q->data, q->tail, val);

       q->tail += 1;

       if (q->tail == q->size) q->tail = 0;

       q->count += 1;

       return 1;

}

int vectorSeek(Vector* v, int pos) {

       if (pos < 0 || pos >= v->capatity) return -1;

       return v->data[pos];

}

int front(Queue *q) {

       return vectorSeek(q->data,q->head);

}

int pop(Queue *q) {

       if (empty(q)) return 0;

       q->head += 1;

       q->count -= 1;

       return 1;

}

void clearVector(Vector *v) {

       if (v == NULL) return;

       free(v->data);

       free(v);

       return;

}

void clearQueue(Queue *q) {

       if (q == NULL)return;

       clearVector(q->data);

       free(q);

       return;

}

void outputQueue(Queue* q) {

       printf("Queue:");

       for (int i = 0; i < q->count; i++) {

              printf("%4d ", vectorSeek(q->data, (q->head + i) % q->size));

       }

       printf("\n\n");

       return;

}

int main() {

       srand(time(0));

#define MAX_OP 10

       Queue* q = initQueue(5);

       for (int i = 0; i < MAX_OP; i++) {

              int op = rand() % 5;

              int val = rand() % 100;

              switch (op) {

              case 0:

              case 1:

                      printf("front of queue: %d\n", front(q));

                      pop(q);

                      break;

              case 2:

              case 3:

              case 4:

                      printf("push %d to queue\n", val);

                      push(q, val);

                      break;

              }

              outputQueue(q);

       }

       clearQueue(q);

       return 0;

}

代码演示--链表

typedef struct Node {

       int data;

       Node* next;

}Node;

typedef struct LinkList {

       Node head, *tail;

}LinkList;

LinkList* initLinkList() {

       LinkList* l = (LinkList *)malloc(sizeof(LinkList));

       l->head.next = NULL;

       l->tail = &(l->head);

       return l;

}

Node* getNewNode(int val) {

       Node* p = (Node*)malloc(sizeof(Node));

       p->data = val;

       p->next = NULL;

       return p;

}

void clearLinkList(LinkList* l) {

       Node* p = l->head.next, * q;

       while (p) {

              q = p->next;

              free(p);

              p = q;

       }

       free(l);

}

typedef struct Queue {

       LinkList *l;

       int size, count;

}Queue;

Queue* initQueue() {

       Queue* q = (Queue*)malloc(sizeof(Queue));

       q->l = initLinkList();

       q->count = 0;

       return q;

}

int emptyList(LinkList* l) {

       return l->head.next == NULL;

}

int frontList(LinkList* l) {

       if (emptyList(l)) return 0;

       return l->head.next->data;

}

int empty(Queue* q) {

       return q->count == 0;

}

int front(Queue *q) {

       if (empty(q)) return 0;

       return frontList(q->l);

}

int insertTail(LinkList* l,int val) {

       Node* node = getNewNode(val);

       l->tail->next = node;

       l->tail = node;

       return 1;

}

int push(Queue* q,int val) {

       insertTail(q->l, val);

       q->count += 1;

       return 1;

}

int eraseHead(LinkList* l) {

       if (emptyList(l)) return 0;

       Node* p = l->head.next;

       l->head.next = p->next;

       if (p == l->tail) l->tail = &(l->head);

       free(p);

       return 1;

}

int pop(Queue* q) {

       if (empty(q)) return 0;

       eraseHead(q->l);

       q->count -= 1;

       return 1;

}

void clearQueue(Queue* q) {

       if (q == NULL) return;

       clearLinkList(q->l);

       free(q);

       return;

}

void outputQueue(Queue* q) {

       printf("Queue:");

       Node* p = q->l->head.next;

       for (int i = 0; i < q->count; i++ ,p=p->next) {

              printf("%4d ",p->data);

       }

       printf("\n\n");

       return;

}

int main() {

       srand((unsigned int)time(0));

#define MAX_OP 10

       Queue* q = initQueue();

       for (int i = 0; i < MAX_OP; i++) {

              int op = rand() % 5;

              int val = rand() % 100;

              switch (op) {

              case 0:

              case 1:

                      printf("front of queue: %d\n", front(q));

                      pop(q);

                      break;

              case 2:

              case 3:

              case 4:

                      printf("push %d to queue\n", val);

                      push(q, val);

                      break;

              }

              outputQueue(q);

       }

       clearQueue(q);

       return 0;

}

栈

结构性质：先进后出（first in last out）

括号序列--栈的其中一种表现形式--也反映了函数的执行关系

由此可见，栈可以处理具有完全包含关系的问题

栈的代码演示

typedef struct Stack {

       int* data;

       int size, top;

}Stack;

Stack* initStack(int n) {

       Stack* s = (Stack*)malloc(sizeof(Stack));

       s->data = (int*)malloc(sizeof(int) * n);

       s->size = n;

       s->top = -1;

       return s;

}

void clearStack(Stack * s) {

       if (s == NULL) return;

       free(s->data);

       free(s);

       return;

}

int empty(Stack* s) {

       return s->top == -1;

}

int top(Stack* s) {

       if (empty(s)) return 0;

       return s->data[s->top];

}

int push(Stack* s,int val) {

       if (s->top + 1 == s->size) return 0;

       s->top += 1;

       s->data[s->top] = val;

       return 1;

}

int pop(Stack* s) {

       if (empty(s)) return 0;

       s->top -= 1;

       return 1;

}

void outputStack(Stack* s) {

       printf("Stack:");

       for (int i = s->top; i >= 0; i--) {

              printf("%4d", s->data[i]);

       }

       printf("\n\n");

       return;

}

int main() {

       srand((unsigned int)time(0));

       Stack* s = initStack(5);

#define MAX_OP 10

       for (int i = 0; i < MAX_OP; i++) {

              int op = rand() % 3, val = rand() % 100;

              switch (op) {

              case 0:

                      printf("pop stack,item= %d\n", top(s));

                      pop(s);

                      break;

              case 1:

              case 2:

                      printf("push stack, item =%d\n", val);

                      push(s, val);

                      break;

              }

              outputStack(s);

       }

       clearStack(s);

       return 0;

}

栈与队列的应用