顺序对列，环形队列，反向链式栈

1.顺序队列

#include<stdio.h>
#include <stdlib.h>

#define N 100
#define datatype int

typedef struct queue
{
    datatype data[N];
    int rear;//吃东西
    int front;//拉屎
} myQ ,*PmyQ;

void init(PmyQ p);
int isfull(PmyQ p);
int isempty(PmyQ p);

void show(PmyQ p);

void enQ(PmyQ p, datatype newdata);
void deQ(PmyQ p);
datatype getlast(PmyQ p);


void init(PmyQ p)//初始化
{
    memset(p->data, 0, sizeof(datatype)*N);
    p->front = p->rear = 0;
}
int  isfull(PmyQ p)
{
    if (p->rear==N)
    {
        return 1;
    } 
    else
    {
        return 0;
    }
}
int isempty(PmyQ p)
{
    if (p->front==p->rear)
    {
        return 1;
    } 
    else
    {
        return 0;
    }
}
void show(PmyQ p)
{
    printf("\n");
    if (isempty(p)==1)
    {
        return;
    } 
    else
    {
        for (int i = p->front; i < p->rear;i++)
        {
            printf("%4d", p->data[i]);
        }
    }


}
datatype getlast(PmyQ p)
{
    if (isempty(p)==1)
    {
        return;
    } 
    else
    {

        return p->data[p->front];
    }

}

void enQ(PmyQ p, datatype newdata)//入队
{
    if (isfull(p)==1)
    {
        return;
    } 
    else
    {
        p->data[p->rear] = newdata;//吃入
        p->rear++;
    }

}
void deQ(PmyQ p)
{
    if (isempty(p)==1)
    {
        return;
    } 
    else
    {

        //队列的损耗，移动费事费力
        for (int i = 0; i < p->rear - p->front - 1;i++)
        {
            p->data[i] = p->data[i + 1];
        }
        //数据从后往前移动
        p->rear -= 1;

    }

}

void main()
{
    myQ myq;
    init(&myq);

    for (int i = 0; i < 10;i++)
    {
        enQ(&myq, i);
        show(&myq);
    }
    while ( !isempty(&myq))
    {
        printf("\n拉出来的%d", getlast(&myq));
        deQ(&myq);
        show(&myq);
    }

    system("pause");
}

 

2.环形队列

#include<stdio.h>
#include <stdlib.h>
#include <memory.h>
#define datatype int
#define N 10

//环形队列，删除一个元素以后便无需移动
//N ,顺序队列使用N，环形队列N-1

 typedef struct queue
{
    datatype data[N];
    int front;
    int rear;

} myQ,*pQ;

void init(pQ p)
{
    memset(p->data, 0, sizeof(datatype)*N);
    p->front = p->rear = 0;//初始化
}

int  isempty(pQ p)
{
    if (p->front==p->rear)
    {
        return 1;
    } 
    else
    {
        return 0;
    }

}
//0 1 2  3  4 5 6 7 8 9
int isfull(pQ p)
{
    if ((p->rear+1)%N==p->front)
    {
        return 1;
    } 
    else
    {
        return 0;
    }
}

void clear(pQ p)
{
    memset(p->data, 0, sizeof(datatype)*N);
    p->front = p->rear = 0;//初始化
}

void printfall(pQ p)
{
    printf("\n");
    for (int i = p->front; i%N < p->rear;i++)
    {
        printf("%4d", p->data[i]);//遍历每一个元素
    }

}
void enq(pQ p,int newdata)
{
    if (isfull(p)==1)
    {
        return;
    } 
    else
    {
        p->data[p->rear] = newdata;
        p->rear = (p->rear + 1) % N;//循环

    }
}

datatype  deq(pQ p)
{

    if (isempty(p)==1)
    {
        abort();
        return;
    } 
    else
    {
        datatype tempdata = p->data[p->front];
        p->front =( p->front + 1 )%N;
        return tempdata;
    }
}

void main()
{
    myQ my;
    init(&my);
    for (int i = 0; i < 9;i++)
    {
        enq(&my, i);
        printfall(&my);
    }
    while ( !isempty(&my))
    {

        printf("\n弹出的%d", deq(&my));
        printfall(&my);
    }
    system("pause");
}

 

3.反向链式队列

#include <stdio.h>
#include <stdlib.h>

struct node
{
    int data;
    struct node *pNext;

};

void init(struct node **ppNext);
struct node * enq(struct node *p, int newdata);
struct node * deq(struct node *p, int *pout);
void show(struct node *p);

void init(struct node **ppNext)
{
    *ppNext = NULL;

}
struct node * enq(struct node *p, int newdata)
{
    struct node *pnew = malloc(sizeof(struct node));
    pnew->data = newdata;
    pnew->pNext = NULL;

    if (p==NULL)
    {
        p = pnew;
        return p;
    } 
    else
    {
        pnew->pNext = p;//头部插入
        p = pnew;
        return p;
    }

}
struct node * deq(struct node *p, int *pout)
{
    if (p==NULL)
    {
        abort();
        return NULL;
    } 
    else  if (p->pNext==NULL)
    {
    
        *pout = p->data;
        free(p);
        p = NULL;;
        return p;
    } 
    else
    {
        struct node *ptemp = p;
        while (ptemp->pNext->pNext!=NULL)
        {
            ptemp = ptemp->pNext;
        }
        *pout = ptemp->pNext->data;
        ptemp->pNext = NULL;
        free(ptemp->pNext);
return p;

    }
}
void show(struct node *p)
{
    if (p==NULL)
    {
        return;
    } 
    else
    {
        printf("%4d", p->data);
        show(p->pNext);
    }
}



int main()
{
    struct node *phead  ;
    init(&phead);
    for (int i = 0; i < 10;i++)
    {
        phead =enq(phead, i);
        printf("\n");
        show(phead);
    }
    while (phead!=NULL)
    {
        int num;
        phead =deq(phead, &num);
        printf("\nout is %4d", num);
        printf("\n");
        show(phead);
    }
    system("pause");
}

 

转载于:https://www.cnblogs.com/sjxbg/p/5798444.html