队列和栈详解

队列和栈

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;

}

栈与队列的应用