数据结构与算法01--堆栈 & 队列

最新推荐文章于 2022-04-24 17:43:02 发布

opera92

最新推荐文章于 2022-04-24 17:43:02 发布

阅读量1.6k

点赞数

分类专栏：数据结构与算法文章标签：数据结构

本文链接：https://blog.csdn.net/opera95/article/details/51205739

版权

数据结构与算法专栏收录该内容

9 篇文章 1 订阅

订阅专栏

基于顺序表的堆栈

基于链式表的堆栈

1 基于顺序表的堆栈

栈是一种特殊的线性表，是限定在线性表表尾进行插入删除操作的线性表。由栈的概念衍生出几个子概念，它们是：

1)栈顶，即允许进行插入、删除操作的一端，又称为表尾，用栈顶指针(top)来指示栈顶元素。

2)栈底，即固定端，又称为表头

3)空栈，即栈当中没有数据元素。

顺序栈是采用顺序存储结构的栈，即使用一组连续的存储单元（一般使用数组）来模拟栈，依次存放栈中的数据元素。

1.1 方案

顺序栈的基本操作包括：

1) 初始化操作，在初始化操作中将建立一个空栈。

2) 判断栈空，判断栈中的数据元素个数是否为0。

3) 入栈，在栈中加入一个数据元素。

4) 出栈，在栈中删除一个数据元素。

5) 取栈顶元素，将栈顶元素取出，但并不在栈中删除该元素。

1.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义栈

在C语言中：

1)定义一个一维数组来表示栈的顺序存储空间。

2)定义一个变量来指出栈顶的位置。

3)这两方面的信息共同描述一个栈，可将它们用结构体封装在一起。

代码如下：


    
    #define LISTSIZE 10
typedef int DataType;
struct Stack {
    DataType data[LISTSIZE];
    int top; //除了记录大小  还可以记录栈顶位置
};

上述代码中，以下代码：


    
    #define LISTSIZE 100

是用一个宏常量来定义顺序表的容量，这样定义的好处是当需要修改顺序表的容量的时候，只需要修改该宏常量即可。

上述代码中，以下代码：


    
    typedef int DataType;

是将数据类型int起了一个别名叫做DataType，并在后面的程序中只使用DataType，而不使用int。这样做的好处是当堆栈中的数据类型发生变化时，只需要修改此句中的int为要改变的数据类型，即可将程序中所有数据变量的数据类型变成指定的类型。

步骤二：初始化操作

在主程序中，定义栈结构体的变量。

在初始化函数中将该变量中的栈顶指针初始化为0，表示为空栈。

代码如下：


    
    void init(struct Stack *stack)
{
    stack->top = 0;
}
int main(int argc, const char * argv[])
{
    struct Stack stack;
    init(&stack);
}

步骤三：判断栈空

判断栈空实际上是判断栈顶指针是否为0，因为当栈顶指针为0时，代表栈中没有数据元素。

代码如下：


    
    bool empty(struct Stack* stack) {
    return stack->top == 0;
}

步骤四：入栈

入栈是在栈中加入一个数据元素，在入栈时，首先需要判断栈是否为满，如果栈满了，则就不能在向其中添加元素了，判断栈是否满的操作只有在顺序存储结构才会出现，因为采用顺序存储结构的栈是要事先定义栈的容量的。然后将数据元素放入栈中，并使栈顶指针加1，指向下一个位置。

代码如下：


    
    void push(struct Stack* stack, DataType d) {
    if (stack->top == LISTSIZE)
        return;
    stack->data[stack->top++] = d;
}

上述代码中，以下代码：


    
        if (stack->top == LISTSIZE)

是判断栈是否满，判断栈顶指针是否与栈的容量相等，如果是，则表示栈已经满了。

步骤五：出栈

出栈操作实际上是将栈中的栈顶元素删除，在出栈时，首先判断栈是否为空，如果栈为空则代表栈中已经没有数据元素了，此时是不可能进行出栈操作的。然后，将栈顶指针减1。

代码如下：


    
    void pop(struct Stack* stack) {
    if (empty(stack))
        return;
    stack->top--;
}

步骤六：取栈顶元素

取栈顶元素操作实际上是仅返回栈顶元素，而栈顶指针并不变动。在取栈顶元素时，首先也要判断栈是否为空，因为空栈同样是不可能有数据元素的。

代码如下：


    
    DataType topData(struct Stack* stack) {
    return stack->data[stack->top - 1];
}

1.3 完整代码

本案例的完整代码如下所示：


    
    #include <stdio.h>
#include <stdbool.h>
#define LISTSIZE 10
typedef int DataType;
struct Stack {
    DataType data[LISTSIZE];
    int top; //处了记录大小  还可以记录栈顶位置
};
void init(struct Stack* stack)
{
    stack->top = 0;
}
bool empty(struct Stack* stack) {
    return stack->top == 0;
}
void push(struct Stack* stack, DataType d) {
    if (stack->top == LISTSIZE)
        return;
    stack->data[stack->top++] = d;
}
void pop(struct Stack* stack) {
    if (empty(stack))
        return;
    stack->top--;
}
DataType topData(struct Stack* stack) {
    return stack->data[stack->top - 1];
}
int main()
{
    struct Stack stack;
    init(&stack);
    push(&stack, 30);
    push(&stack, 60);
    push(&stack, 80);
    
    while (!empty(&stack)) {
        printf("%d ", topData(&stack));
        pop(&stack);
    }
    printf("\n");
    
    return 0;
}

2 基于链式表的堆栈

2.1 问题

链栈是采用链式存储结构的栈，即使用一组不要求连续的存储空间来模拟栈。每个栈元素为一个节点，每个节点中包含两个域，一个是数据域，用于存储栈元素的数据；另一个是指针域，用于存储下一个栈元素的地址。

2.2 方案

链栈的基本操作包括：

1) 初始化操作，在初始化操作中将栈顶指针置空。

2) 判断栈空，判断栈顶指针是否为空。

3) 入栈，在栈中加入一个数据元素。

4) 出栈，在栈中删除一个数据元素。

5) 取栈顶元素，将栈顶元素取出，但并不在栈中删除该元素。

2.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义栈元素节点

在C语言中：

1)定义一个变量来表示栈元素的数据。

2)定义一个指针来指向下一个栈元素的位置。

3)这两方面的信息共同描述一个栈元素节点，可将它们用结构体封装在一起。

代码如下：


    
    typedef int DataType;
struct Stack {
    DataType data;
    struct Stack *next;
};

上述代码中，以下代码：


    
        struct Stack *next;

是定义了一个指向下一个栈元素的指针，由于下一个栈元素的数据类型与当前栈元素的数据类型相同，所以指针的数据类型就是栈节点的指针数据类型。

步骤二：初始化操作

在主程序中，定义栈顶指针。

在初始化函数中将栈顶指针初始化为NULL，表示为空栈。

代码如下：


    
    void init(struct Stack** top)
{
    *top = NULL;
}
int main()
{
    struct Stack *top;
    init(&top);
    return 0;
}

上述代码中，以下代码：


    
    void init(struct Stack** top)

定义了初始化函数的函数头，该函数有一个形参，是栈元素结构体指针的指针。之所以使用指针的指针，是因为栈顶指针在函数执行过程中会被置空，而这种变化需要带回主函数。

步骤三：判断栈空

判断栈空操作实际上就是判断栈顶指针是否为空。

代码如下所示：


    
    bool empty(struct Stack* top)
{
    return top == NULL;
}

步骤四：入栈

入栈操作实际上就是在栈中加入一个数据元素，对于链栈，入栈操作本质上就是在栈中加入一个结点。

代码如下所示：


    
    void push(struct Stack** top, DataType d)
{
    struct Stack *newNode = (struct Stack*)malloc(sizeof(struct Stack));
    newNode->data = d;
    newNode->next = *top;
    *top = newNode;
}

上述代码中，以下代码：


    
    void push(struct Stack** top, DataType d)

定义了入栈函数的函数头，该函数有两个形参，第一个是栈结构的指针的指针，在这里使用指针的指针，还是因为需要将栈顶指针的变化带回主函数。第二个形参是需要入栈的数据。

上述代码中，以下代码：


    
        struct Stack *newNode = (struct Stack*)malloc(sizeof(struct Stack));

是构造一个新的栈元素节点。

上述代码中，以下代码：


    
        newNode->data = d;

是将需要入栈的元素放入新的栈元素节点中。

上述代码中，以下代码：


    
        newNode->next = *top;

是将新创建的栈元素节点加入到栈中原栈顶元素的前面，成为新的栈顶元素。

上述代码中，以下代码：


    
        *top = newNode;

是栈顶指针指向新创建的栈顶元素。正是由于这行代码，使栈顶指针发生了变化，而这种变化需要带回到主程序，所以函数的第一个形参必须是指针的指针。

步骤五：出栈

出栈操作实际上就是从栈中删除栈顶位置的元素，对于链栈，出栈操作本质上就是在栈中删除一个结点。

代码如下所示：


    
    void pop(struct Stack** top)
{
    if (empty(*top))
        return;
    struct Stack *tempNode = *top;
    *top = (*top)->next;
    free(tempNode);
}

上述代码中，以下代码：


    
        if (empty(*top))
        return;

是判断链栈是否为空，如果栈为空是不能从栈中删除元素的。

上述代码中，以下代码：


    
        struct Stack *tempNode = *top;
    *top = (*top)->next;
    free(tempNode);

首先用一个临时指针保存原栈顶指针指向的栈元素地址，即出栈元素的地址，然后将栈顶指针指向下一个元素，这样栈中就减少了一个元素。最后释放临时指针指向的元素，即释放出栈元素所占的存储空间。

步骤六：取栈顶元素

取栈顶元素实际上就是将栈顶元素的值返回，对于链栈，本质上是将栈顶节点的数据返回。注意，在取栈顶元素时，首先要判断栈是否为空，空栈是没有数据元素的。

代码如下：


    
    void topData(struct Stack* top, DataType* data)
{
    if (empty(top))
        return;
    *data = top->data;
}

2.4 完整代码

本案例的完整代码如下所示：


    
    #include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
typedef int DataType;
struct Stack {
    DataType data;
    struct Stack *next;
};
void init(struct Stack** top)
{
    *top = NULL;
}
bool empty(struct Stack* top)
{
    return top == NULL;
}
void push(struct Stack** top, DataType d)
{
    struct Stack *newNode = (struct Stack*)malloc(sizeof(struct Stack));
    newNode->data = d;
    newNode->next = *top;
    *top = newNode;
}
void pop(struct Stack** top)
{
    if (empty(*top))
        return;
    struct Stack *tempNode = *top;
    *top = (*top)->next;
    free(tempNode);
}
void topData(struct Stack* top, DataType* data)
{
    if (empty(top))
        return;
    *data = top->data;
}
int main()
{
    struct Stack *top;
    init(&top);
    push(&top, 30);
    push(&top, 60);
    push(&top, 80);
    
    while (!empty(top)) {
        int data;
        topData(top, &data);
        printf("%d ", data);
        pop(&top);
    }
    printf("\n");
    
    return 0;
}

1 基于顺序表的队列

1.1 问题

队列是一种特殊的线性表，是限定在线性表表尾进行插入操作，而在线性表表头进行删除的线性表。由队列的概念衍生出几个子概念，它们是队首：允许进行删除的一端，又称为队头，用队首指针(front)来指示要删除的元素；队尾：允许进行插入的一端，用队尾指针(rear)来指示要插入元素的位置；空队，队列中没有元素时称为空队列。

顺序队是采用顺序存储结构的队，即使用一组连续的存储单元（一般使用数组）来模拟队，依次存放队中的数据元素。

顺序队中存在一个“假溢出”的现象，“假溢出”是指随着入队、出队的进行，使整个队列在数组中整体向后移动，队尾指针已经移到了数组的最后一个元素，再有元素入队就会出现溢出，而事实上，此时队列中并未真的“满员”的现象，因为出队会使位置空出，所以数组的前部仍然有空间。

为充分利用数组空间，克服“假溢出”现象，将队列分配的向量空间看成为一个首尾相接的圆环，并称这种队列为循环队列。

1.2 方案

顺序队的基本操作包括：

1) 初始化操作，在初始化操作中将建立一个空队。

2) 判断队空，判断队中的数据元素个数是否为0。

3) 入队，在队中加入一个数据元素。

4) 出队，在队中删除一个数据元素。

5) 取队首元素，将队首元素取出，但并不在队中删除该元素。

1.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义队

在C语言中：

1)定义一个一维数组data，来表示队的顺序存储空间。

2)定义一个变量front，来存储队首的位置。

3)定义一个变量rear，来存储队尾的位置。

4)这三方面的信息共同描述一个队，可将它们封装在一起。

代码如下：


    
    typedef int DataType;
struct Queue2 {
    DataType data[6];
    int front; //队首指针
    int rear; //队尾指针
};

上述代码中，以下代码：


    
    typedef int DataType;

是将数据类型int起了一个别名叫做DataType，并在后面的程序中只使用DataType，而不使用int。这样做的好处是当队列中的数据类型发生变化时，只需要修改此句中的int为要改变的数据类型，即可将程序中所有数据变量的数据类型变成指定的类型。

步骤二：初始化操作

在主程序中，定义队结构体的变量。

在初始化函数中将该变量中的队首、队尾指针初始化为0，表示为空队。

代码如下：


    
    void init(struct Queue2 *q)
{
    q->front = q->rear = 0;
}
int main(int argc, const char * argv[])
{
    Queue2 q2;
    init(&q2);
}

步骤三：判断队空

判断队空实际上是判断队首指针与队尾指针是否相同，当队首指针与队尾指针相同时，代表队中没有数据元素。

代码如下：


    
    bool empty(struct Queue2 *q) {
    return q->rear - q->front == 0;
}

步骤四：入队

入队是在队中加入一个数据元素，在入队时，首先需要判断队是否为满，如果队满了，则就不能在向其中添加元素了，判断队是否满的操作只有在顺序存储结构才会出现，因为采用顺序存储结构的队是要事先定义队的容量的。然后将数据元素放入栈中，并使队首指针加1，指向下一个位置。

代码如下：


    
    bool push(struct Queue2 *q, DataType d) {
    if (q->rear - q->front == 6) return false;
    q->data[q->rear++ % 6] = d;
    return true;
}

上述代码中，以下代码：


    
        if (q->rear - q->front == 6) return false;

是判断队是否满，当队尾指针与队首指针的差值为6时，则表示队已经满了。6是步骤一定义队时定义的队容量。

上述代码中，以下代码：


    
        q->data[q->rear++ % 6] = d;

是将入队元素d放置在队尾指针指向的位置。其中q->rear++ % 6是形成循环队列的关键，队尾指针对6求余数，则保证了数组q->data[]的下标永远在0~5之间变化，因为任何正整数对6求余数，余数只能是0~5，这样就保证数组不会越界访问，即防止了“假溢出”现象的出现。

步骤五：出队

出队操作实际上是将队中的队首元素删除，在出队时，首先判断队是否为空，如果队为空则代表队中已经没有数据元素了，此时是不可能进行出队操作的。然后，将队首指针加1。

代码如下：


    
    bool pop(struct Queue2 *q) {
    if (empty(q)) return false;
    q->front++;
    return true;
}

步骤六：取队首元素

取队首元素操作实际上是仅返回队首元素，而队首指针并不变动。在取队首元素时，首先也要判断队是否为空，因为空队同样是不可能有数据元素的。

代码如下：


    
    DataType getFront(struct Queue2 *q) {
    return q->data[q->front % 6];
}

上述代码中q->front % 6同样是形成循环队列的关键，队首指针对6求余数，则保证了数组q->data[]的下标永远在0~5之间变化，因为任何正整数对6求余数，余数只能是0~5，这样就保证数组不会越界访问，即防止了“假溢出”现象的出现。

1.4 完整代码

本案例的完整代码如下所示：


    
    //循环队列
#include <stdio.h>
#include <stdbool.h>
typedef int DataType;
struct Queue2 {
    DataType data[6];
    int front; //开始位置
    int rear; //结束位置
};
void init(struct Queue2 *q)
{
    q->front = q->rear = 0;
}
bool empty(struct Queue2 *q) {
    return q->rear - q->front == 0;
}
bool push(struct Queue2 *q, DataType d) {
    if (q->rear - q->front == 6) return false;
    q->data[q->rear++ % 6] = d;
    return true;
}
bool pop(struct Queue2 *q) {
    if (empty(q)) return false;
    q->front++;
    return true;
}
DataType getFront(struct Queue2 *q) {
    return q->data[q->front % 6];
}
int main() {
    
    struct Queue2 q2;
    init(&q2);
    for (int i = 0; i < 6; i++) {
        push(&q2, i);
    }
    pop(&q2);
    push(&q2, 300);
    pop(&q2);
    pop(&q2);
    push(&q2, 200);
    while (!empty(&q2)) {
        printf("%d ", getFront(&q2));
        pop(&q2);
    }
    printf("\n");
    
    return 0;
}

2 基于链式表的队列

2.1 问题

链队是采用链式存储结构的队，即使用一组不要求连续的存储空间来模拟队。每个队元素为一个节点，每个节点中包含两个域，一个是数据域，用于存储队元素的数据；另一个是指针域，用于存储下一个队元素的地址。

2.2 方案

链队的基本操作包括：

1) 初始化操作，在初始化操作中将队头、队尾指针置空。

2) 判断队空，判断队首指针(front)是否为空。

3) 入队，在队中加入一个数据元素。

4) 出队，在队中删除一个数据元素。

5) 取队首元素，将队首元素取出，但并不在队中删除该元素。

2.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义队元素节点

在C语言中：

1)定义一个变量来表示队元素的数据。

2)定义一个指针来指向下一个队元素的位置。

3)这两方面的信息共同描述一个队元素节点，可将它们用结构体封装在一起。

代码如下：


    
    typedef int DataType;
struct Queue {
    DataType data;
    struct Queue *next;
};

上述代码中，以下代码：


    
        struct Queue *next;

是定义了一个指向下一个队元素的指针，由于下一个队元素的数据类型与当前队元素的数据类型相同，所以指针的数据类型就是队节点的指针数据类型。

步骤二：初始化操作

在主程序中，定义队头、队尾指针。

在初始化函数中将队头、队尾指针初始化为NULL，表示为空栈。

代码如下：


    
    void init(struct Queue** front, struct Queue** rear)
{
    *front = NULL;
    *rear = NULL;
}
int main()
{
    struct Queue *front, *rear;
    init(&front, &rear);
    return 0;
}

上述代码中，以下代码：


    
    void init(struct Queue** front, struct Queue** rear)

定义了初始化函数的函数头，该函数有两个形参，都是队元素结构体指针的指针。之所以使用指针的指针，是因为队头、队尾指针在函数执行过程中会被置空，而这种变化需要带回主函数。

步骤三：判断队空

判断队空操作实际上就是判断队头或队尾是否为空。

代码如下所示：


    
    bool empty(struct Queue* node)
{
    return node == NULL;
}

步骤四：入队

入队操作实际上就是在队中加入一个数据元素，对于链队，入队操作本质上就是在队中加入一个结点。

代码如下所示：


    
    void push(struct Queue** front, struct Queue** rear, DataType d)
{
    struct Queue *newNode = (struct Queue*)malloc(sizeof(struct Queue));
    newNode->data = d;
    newNode->next = NULL;
    if (*rear != NULL)
        (*rear)->next = newNode;
    *rear = newNode;
    if (*front == NULL)
        *front = *rear;
}

上述代码中，以下代码：


    
    void push(struct Queue** front, struct Queue** rear, DataType d)

定义了入队函数的函数头，该函数有三个形参，前两个是队结构的指针的指针，在这里使用指针的指针，还是因为需要将队头、队尾指针的变化带回主函数。第三个形参是需要入栈的数据。

上述代码中，以下代码：


    
        struct Queue *newNode = (struct Queue*)malloc(sizeof(struct Queue));

是构造一个新的队元素节点。

上述代码中，以下代码：


    
        newNode->data = d;
    newNode->next = NULL;

是将需要入队的元素放入新的队元素节点中。

上述代码中，以下代码：


    
        if (*rear != NULL)
        (*rear)->next = newNode;
    *rear = newNode;

首先判断队尾指针是否为空，如果不为空，则将新创建的队元素节点加入到队中原队尾元素的后面，成为新的队尾元素，并将队尾指针指向新创建的队元素节点。如果队尾指针为空，则表示此时队中没有元素，所以直接将队尾指针指向新创建的队元素节点即可。正是由于第三行代码，使队尾指针发生了变化，而这种变化需要带回到主程序，所以函数的第二个形参必须是指针的指针。

上述代码中，以下代码：


    
        if (*front == NULL)
        *front = *rear;

是判断队头指针是否为空，如果为空，则表示队中没有元素，此时入队的元素为队中的唯一一个元素，所以此时队头、队尾指针均指向它。由于第二行代码，使队头指针发生了变化，而这种变化需要带回到主程序，所以函数的第一个形参必须是指针的指针。

步骤五：出队

出队操作实际上就是从队中删除队尾位置的元素，对于链队，出队操作本质上就是在队中删除一个结点。

代码如下所示：


    
    void pop(struct Queue** front, struct Queue** rear)
{
    if (empty(*rear))
        return;
    struct Queue *tempNode = *front;
    *front = (*front)->next;
    free(tempNode);
    if (*front == NULL)
        *rear = NULL;
}

上述代码中，以下代码：


    
        if (empty(*rear))
        return;

是判断链队是否为空，如果队为空是不能从队中删除元素的。

上述代码中，以下代码：


    
        struct Queue *tempNode = *front;
    *front = (*front)->next;
    free(tempNode);

首先用一个临时指针保存原队头指针指向的队元素地址，即出队元素的地址，然后将队头指针指向下一个元素，这样队中就减少了一个元素。最后释放临时指针指向的元素，即释放出队元素所占的存储空间。

上述代码中，以下代码：


    
        if (*front == NULL)
        *rear = NULL;

是判断删除一个队元素后，队是否为空，如果队中没有元素了，也应该将队尾指针置为空，否则队尾指针将是野指针。

步骤六：取队首元素

取队首元素实际上就是将队头元素的值返回，对于链队，本质上是将队头节点的数据返回。注意，在取队首元素时，首先要判断队是否为空，空队是没有数据元素的。

代码如下：


    
    void topData(struct Queue* front, DataType* data)
{
    if (empty(front))
        return;
    *data = front->data;
}

2.4 完整代码

本案例的完整代码如下所示：


    
    #include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
typedef int DataType;
struct Queue {
    DataType data;
    struct Queue *next;
};
void init(struct Queue** front, struct Queue** rear)
{
    *front = NULL;
    *rear = NULL;
}
bool empty(struct Queue* node)
{
    return node == NULL;
}
void push(struct Queue** front, struct Queue** rear, DataType d)
{
    struct Queue *newNode = (struct Queue*)malloc(sizeof(struct Queue));
    newNode->data = d;
    newNode->next = NULL;
    if (*rear != NULL)
        (*rear)->next = newNode;
    *rear = newNode;
    if (*front == NULL)
        *front = *rear;
}
void pop(struct Queue** front, struct Queue** rear)
{
    if (empty(*rear))
        return;
    struct Queue *tempNode = *front;
    *front = (*front)->next;
    free(tempNode);
    if (*front == NULL)
        *rear = NULL;
}
void topData(struct Queue* front, DataType* data)
{
    if (empty(front))
        return;
    *data = front->data;
}
int main()
{
    struct Queue *front, *rear;
    init(&front, &rear);
    push(&front, &rear, 30);
    push(&front, &rear, 60);
    push(&front, &rear, 80);
    
    while (!empty(front)) {
        int data;
        topData(front, &data);
        printf("%d ", data);
        pop(&front, &rear);
    }
    printf("\n");
    return 0;
}