基本动态集合

1. 栈，使用后进后出（last-in, first-out, LIFO）的策略

2.队列，使用先进后出（first-in, first-out, FIFO）策略

以下笔者用c语言简单实现了一下

1. 栈： 栈的操作有

1.  Empty:检测栈是否为空
2. Push：推入一个元素
3. Pop：推出一个元素

//stack 的实现
#include <stdio.h>
#define LEN 3 //栈大小

int Empty(int s[]);
int Push(int s[], int x);
int Pop(int s[]);
int main()
{
    int s[LEN+1]={0}; //栈多的一项用来记录现在栈的动态长度
    while(1)
    {
        system("cls");
        printf("1.Empty 2.Push 3.Pop\n");
        int i;
        for(i = 0 ;i < s[LEN]; i++)
            printf("%d ", s[i]);
        printf("\n");
        //界面及栈内数据显示
        
        static int opt; //选择执行何项操作
        scanf("%d", &opt);

        if(opt == 1)
        {
            Empty(s);
        }
        if(opt == 2)
        {
            printf("输入放入数字\n");
            int x;
            scanf("%d", &x);
            Push(s,x);
        }
        if(opt == 3)
        {
            int x = Pop(s);
            if(x != -1)
            {
                printf("输出结果为%d", x);
            }
        }
        getchar();
        getchar();
    }
}

int Empty(int s[])
{
    if(s[0] != 0)
        printf("栈未空\n");
    else
        printf("栈为空\n");

}

int Push(int s[], int x)
{
    if(s[LEN] < LEN)
    {
        s[s[LEN]] = x;
        s[LEN]++;
    }
    else
    {
        printf("栈已满\n");
    }
}

int Pop(int s[])
{
    if(s[LEN] != 0)
    {
        s[LEN]--;
        return s[s[LEN]];
    }
    else
    {
        printf("栈已空");
        return -1;
    }
}

2. 队列：队列的操作有：

1. Enqueue：往队列中加入一个元素
2. Dequeue：剔除队列中一个元素

//Queue 队列实现

#include <stdio.h>
#define LEN 2
//检查上溢下溢思路，若head前进，所指为空，则下溢，若tail向前所指为满，则上溢

int Enqueue(int Q[], int x);
int Dequeue(int Q[]);

int main()
{
    int Q[LEN+2]={0}; //多出的两个位置用来储存队列中开头位置和尾部位置
    //数组  初始化为0，表示空
    while(1)
    {
        system("cls");
        printf("1.Enqueue 2.Dequeue\n");

        int i;
        if(Q[LEN+1] >= Q[LEN] && Q[Q[LEN+1]] == 0) //若Q[Q[LEN+1]] == 0,即尾部为0， 则对列为空,因而可以用此循环输出
        {
            for(i = Q[LEN]; i < Q[LEN+1]; i++)
                printf("%d ", Q[i]);
        }
        else  //若Q[Q[LEN+1]] != 0, 则说明队列满，则用此循环可以全部输出
        {
            for(i = Q[LEN]; i < LEN; i++)
            {
                printf("%d ", Q[i]);
            }
            for(i = 0; i < Q[LEN+1]; i++)
            {
                printf("%d", Q[i]);
            }
        }
        //队列中元素输出
        /*由于队列是利用循环数组内进行的，因而可能会需要打印出尾部一部分和头部一部分*/


        printf("\n");
        static int opt; //操作选择
        scanf("%d", &opt);

        if(opt == 1)
        {
            int x;
            printf("请输入数字\n");
            scanf("%d", &x);
            Enqueue(Q,x);
        }
        if(opt == 2)
        {
            int x = Dequeue(Q);
            if(x != 0)
            {
                printf("输出为%d\n",x);
            }
        }
        if(opt == 3)
        {

        }
        getchar();
        getchar();
    }
}
int Enqueue(int Q[],int x)
{
    if(Q[Q[LEN+1]] == 0) //若为0，队列未满，有空位
    {
        Q[Q[LEN+1]] = x;
        Q[LEN+1]++;
        if(Q[LEN+1] >= LEN)  //若到尾部位置，则将提前至第一位,实现循环数组
        {
            Q[LEN+1] = 0;
        }
        return 1;
    }
    else
    {
        printf("队列已满\n");
        return 0;
    }
}

int Dequeue(int Q[])
{
    if(Q[Q[LEN]] != 0) //若不为零说明队列未空
    {
        int x = Q[Q[LEN]];
        Q[Q[LEN]] = 0;
        Q[LEN]++;
        if(Q[LEN] >= LEN) //若到尾部位置，则将提前至第一位,实现循环数组
        {
            Q[LEN] = 0;
        }
        return x;
    }
    else
    {
        printf("队列已空\n");
        return 0;
    }
}