C语言基础——⑩③数据结构——②栈和队列

一、栈(Stack)

1、基本概念

栈是一种逻辑结构,是特殊的线性表。特殊在:

只能在固定的一端操作

只要满足上述条件,那么这种特殊的线性表就会呈现一种"后进先出"的逻辑,这种逻辑就被称为栈。栈 在生活中到处可见,比如堆叠的盘子、电梯中的人们、嵌套函数的参数等等。

由于约定了只能在线性表固定的一端进行操作,于是给栈这种特殊的线性表的"插入"、"删除",另起了 下面这些特定的名称:

栈顶:可以进行插入删除的一端;
栈底:栈顶的对端;
入栈:将节点插入栈顶之上,也称为压栈,函数名通常为push();
出栈:将节点从栈顶剔除,也称为弹栈,函数名通常为pop();
取栈顶:取得栈顶元素,但不出栈,函数名通常为top()

基于这种固定一端操作的简单约定,栈获得了"后进先出"的基本特性,如下图所示,最后一个放入的元素,最先被拿出来:

2、存储形式

栈只是一种数据逻辑,如何将数据存储于内存则是另一回事。一般而言,可以采用顺序存储形成顺序栈 ,或采用链式存储形成链式栈

1.顺序栈(sequenceStack)

顺序存储意味着开辟一块连续的内存来存储数据节点,一般而言,管理栈数据除了需要一块连续的 内存之外,还需要记录栈的总容量、当前栈的元素个数、当前栈顶元素位置,如果有多线程还需要 配互斥锁和信号量等信息,为了便于管理,通常将这些信息统一于在一个管理结构体之中:

cs 复制代码
// 顺序栈节点
struct seqStack
{
    datatype *data; // 顺序栈入口
    int size;       // 顺序栈总容量
    int top;        // 顺序栈栈顶元素下标
};

2.链式栈(linkStack)

链式栈的组织形式与链表无异,只不过插入删除被约束在固定的一端。为了便于操作,通常也会创 建所谓管理结构体,用来存储栈顶指针、栈元素个数等信息:

cs 复制代码
// 链式栈节点
typedef struct node
{
    datatype data;
    struct node *next;
}node;
// 链式栈管理结构体
struct linkStack
{
    node *top; // 链式栈栈顶指针
    int  size; // 链式栈当前元素个数
};

3、完整代码

顺序栈(sequenceStack)

sstack.h
cs 复制代码
#ifndef __SSTACK_H
#define __SSTACK_H
// 数据类型
typedef int DATA;
// 顺序栈结构体
typedef  struct
{
    DATA      *pData; // 栈中元素的地址
    int         size; // 栈的总容量
    int         top;  // 栈顶元素下标
}SeqStack;
// 初始化栈
int SStack_init(SeqStack *s, int num);
// 判断栈是否已满
int SStack_isfull(SeqStack *st);
// 判断栈是否为空
int SStack_isempty(SeqStack *st);
// 入栈/压栈
int SStack_push(SeqStack *st,DATA data);
// 出栈/弹栈
int SStack_pop(SeqStack *st,DATA *data);
// 回收栈
int SStack_free(SeqStack *st);
#endif
sstack.c
cs 复制代码
#include <stdlib.h>
#include "sstack.h"
// 初始化栈
int SStack_init(SeqStack* s,int num)
{
    s -> pData = (DATA*)calloc(sizeof(DATA),num);
    if(s -> pData == NULL)
       return -1;
    s -> size  = num ;
    s -> top   = -1;
    return 0;
}
// 判断栈是否已满
int SStack_isfull(SeqStack *st)
{
    return st -> top + 1 == st -> size;
}
// 判断栈是否为空
int SStack_isempty(SeqStack *st)
{
    return st -> top == -1;
}
// 压栈/入栈
int SStack_push(SeqStack *st,DATA data)
{
    if(SStack_isfull(st))
       return -1;
    st -> top++;
    st -> pData[st -> top] = data;
    return 0;
}
// 出栈/弹栈
int SStack_pop(SeqStack *st,DATA *data)
{
    if(SStack_isempty(st))
       return -1;
    *data = st -> pData[st -> top];
    st -> top--;
    return 0;
}
// 回收栈
int SStack_free(SeqStack *st)
{
    if(st -> pData)
   {
         free(st->pData);
         st -> pData = NULL;
   }
    st -> top = -1;  
}
sstack_main.c
cs 复制代码
#include "sstack.h"
#include <stdio.h>
int main(void)
{
   SeqStack  st;
  
   SStack_init(&st,10);
   register int i = 1;
   for(; i <=10; i++)
      SStack_push(&st,i);
   if(-1 == SStack_push(&st,1024))
     fprintf(stderr,"满栈,插入失败\n");
    while(!SStack_isempty(&st))
   {
         DATA   data = 0;
         SStack_pop(&st,&data);
         printf("%4d",data);         
   }
    printf("\n");
    SStack_free(&st);
   
    return 0;  
}

【课堂练习1】

使用顺序栈,接收键盘的输入,实现如下功能:

  1. 输入数字时,依次入栈。

  2. 输入字母时,依次出栈。

  3. 每次入栈或者出栈,都将顺序栈中的各个元素输出出来。

完整代码(链式栈(linkStack))

linkstack.h
cs 复制代码
#ifndef __LINKSTACK_H
#define __LINKSTACK_H
// 数据类型
typedef   int   DATA;
// 链式栈节点
typedef   struct  _node
{
    DATA       data; // 数据
    struct _node *next; // 指向下一个栈的节点
}NODE;
// 链式栈管理结构体
typedef  struct
{
    NODE     *pHead;// 链式栈栈顶指针
    int       size; // 链式栈当前元素个数
    int       num;
}LinkStack;
// 初始化链式栈
int LStack_init(LinkStack *s, int num);
// 判断栈是否已满
int LStack_isfull(LinkStack *st);
// 判断栈是否为空
int LStack_isempty(LinkStack *st);
// 压栈/入栈
int LStack_push(LinkStack *st,DATA data);
// 弹栈/出栈
int LStack_pop(LinkStack *st,DATA *data);
// 回收栈
int LStack_free(LinkStack *st);
#endif
linkstack.c
cs 复制代码
#include "linkstack.h"
#include <stdio.h>
#include <stdlib.h>
// 初始化栈
int LStack_init(LinkStack *st, int num)
{
    st -> pHead = NULL;
    st -> size  = num;
    st -> num   = 0;
    return 0 ;
}
// 判断栈是否已满
int LStack_isfull(LinkStack *st)
{
    return st -> num == st -> size;
}
// 判断栈是否为空
int LStack_isempty(LinkStack *st)
{
     return st -> num == 0;
}
// 入栈
int LStack_push(LinkStack *st,DATA data)
{
    if(LStack_isfull(st))
       return -1;
    NODE* p = (NODE*)malloc(sizeof(NODE));
    if(!p)
       return -1;
    p -> data   = data;
    p -> next   = st -> pHead;
    st -> pHead = p;
    
   (st -> num)++;
    return 0;
}
// 出栈
int LStack_pop(LinkStack *st,DATA *data)
{
    if(LStack_isempty(st))
       return -1;
    NODE* p = st -> pHead;
    if(!p)
       return -1;
    *data = p -> data;
    st -> pHead = p -> next;
    free(p);
   (st -> num)--;
    return 0;
}
// 回收栈
int LStack_free(LinkStack *st)
{
    NODE* p = st -> pHead, *q = NULL;
    while(p)
   {
        q  = p;
        p  = p -> next;
        free(q);       
   }
    st -> pHead = NULL;
    st -> num   = 0;
    return 0;
}
linkstack_main.c
cs 复制代码
#include "linkstack.h"
#include <stdio.h>
int main(void)
{
   LinkStack  st;
   LStack_init(&st,10);
   register int i = 1;
   for(; i <= 10; i++)
      LStack_push(&st,i);
   if(-1 == LStack_push(&st,1024))
     fprintf(stderr,"满栈,插入失败\n");
    while(!LStack_isempty(&st))
   {
         DATA   data = 0;
         LStack_pop(&st,&data);
         printf("%4d",data);         
   }
    printf("\n");
    LStack_free(&st);
    return 0;  
}

【课堂练习2】

使用链式栈,实现十进制转八进制:键盘输入一个十进制数,经过链式栈的相关算法,输出八进制 数。

代码:

cs 复制代码
 

二、队列(queue)

1、基本概念

队列是一种逻辑结构,是一种 特殊的线性表。特殊在:只能在固定的两端操作线性表 只要满足上述条件,那么这种特殊的线性表就会呈现一种"先进先出"的逻辑,这种逻辑就被称为队列。

队列本质上,是从一端进,另一端出,为了保证跟生活的认知一致,我们建议把进的一端叫做队尾,出的一端叫做对头。

由于约定了只能在线性表固定的两端进行操作,于是给队列这种特殊的线性表的插入删除,起个特殊的名称:

队头:可以删除节点的一端;
队尾:可以插入节点的一端;
入队:将节点插入到队尾之后,函数名通常为enQueue();
出队:将队头节点从队列中剔除,函数名通常为outQueue();
取队头:取得队头元素,但不出队,函数名通常为front()。

由于这种固定两端操作的简单约定,队列获得了"先进先出"的基本特性,如下图所示:

2、顺序存储的队列:循环队列(sequenceQueue)

与其他的逻辑结构类似,队列可以采用顺序存储形成循环队列,也可以采用链式存储形成链式队列。 顺序存储的队列之所以被称为循环队列,是因为可以利用更新队头队尾的下标信息,来循环地利用整个数组,出队入队时也不必移动当中的数据。循环队列示意图如下所示:

从上述动图中可以观察到,需要牺牲至少数组中的一个存储位置,来区分循环队列中的满队和空队。 满队和空队的约定如下:

当front与rear相等时,队列为空;
当rear循环加一与front相等时,队列为满;

与其他数据结构一样,管理循环队列除了需要一块连续的内存之外,还需要记录队列的总容量、当前 队列的元素个数、当前队头、队尾元素位置,如果有多线程还需要配互斥锁和信号量等信息,为了便于管理,通常将这些信息统一于在一个管理结构体之中:

cs 复制代码
typedef   int   DATA;
typedef  struct
{
   DATA      *pData; // 队列入口
   int         size;   // 队列总容量
   int         head;   // 队列队头元素下标
   int         tail;   // 队列队尾元素下标
}SQueue;

3、完整代码(顺序-循环队列)

squeue.h

cs 复制代码
#ifndef __SQUEUE_H
#define __SQUEUE_H
typedef   int   DATA;
typedef  struct
{
   DATA      *pData; // 队列入口
   int         size;   // 队列总容量
   int         head;   // 队列队头元素下标
   int         tail;   // 队列队尾元素下标
}SQueue;
// 初始化队列
int SQ_init(SQueue *q, int num);
// 判断队列是否已满
int SQ_isfull(SQueue *q);
// 判断队列是否为空
int SQ_isempty(SQueue *q);
// 入队
int SQ_push(SQueue *q,DATA data);
// 出队
int SQ_pop(SQueue *q,DATA *data);
// 回收队
int SQ_free(SQueue *q);
#endif

squeue.c

cs 复制代码
#include <stdlib.h>
#include "squeue.h"
// 初始化队列
int SQ_init(SQueue* q,int num)
{
    q -> pData = (DATA*)calloc(sizeof(DATA),num);
    if(q -> pData == NULL)
       return -1;
    q -> size  = num ;
    q -> head  = q -> tail = 0;
    return 0;
}
// 判断队列是否已满
int SQ_isfull(SQueue *q)
{
    return (q -> tail + 1) % q -> size  == q -> head;
}
// 判断队列是否为空
int SQ_isempty(SQueue *q)
{
    return q -> tail  == q -> head;
}
// 出队
int SQ_push(SQueue *st,DATA data)
{
    if(SQ_isfull(st))
       return -1;
    st -> pData[st -> tail] = data;
    st -> tail = (st -> tail+1) % st -> size;
    return 0;
}
// 入队
int SQ_pop(SQueue *st,DATA *data)
{
    if(SQ_isempty(st))
       return -1;
    *data = st -> pData[st -> head];
    st -> head = (st -> head+1) % st -> size;
    return 0;
}
// 回收队列
int SQ_free(SQueue *st)
{
    if(st -> pData)
   {
         free(st->pData);
         st -> pData = NULL;
   }
    st -> head = st -> tail  = 0;  
}

注意: 循环队列中,需要牺牲一个存储位置来区分空队和满队

【课堂练习3】

构建一个顺序存储的循环队列,当用户输入数字时,将数字入队,当用户输入字母时,将队头元素出队。每次操作队列之后,将队列中的元素显示出来。

4、链式存储的队列:链式队列(linkQueue)

链式队列的组织形式与链表无异,只不过插入删除被约束在固定的两端。为了便于操作,通常也会创建所谓管理结构体,用来存储队头指针、队尾指针、队列元素个数等信息:

从上图可以看到,链式队列主要控制队头和队尾,由于管理结构体中保存了当前队列元素个数size,因 此可以不必设计链表的头节点,初始化空队列时只需要让队头队尾指针同时指向空即可。

以下是队列链表节点设计和管理结构体设计的示例代码:

cs 复制代码
typedef  int  DATA;
// 链式队列节点
typedef struct _node
{
    DATA        data;
    struct _node  *next;
}NODE/*,*PNODE*/;

// 链式队列管理结构体
typedef struct
{
   NODE     *pHead; // 队头指针
   NODE     *pTail; // 队尾指针
   int       size ; // 队列当前元素个数
   int       num ;
}LinkQueue;

5、完整代码(链式队列(linkQueue))

当进入新数据时,创建新节点

linkQueue.h

cs 复制代码
#ifndef __LINKQUEUE_H
#define __LINKQUEUE_H
typedef  int  DATA;
// 链式队列节点
typedef struct _node
{
    DATA        data;
    struct _node  *next;
}NODE/*,*PNODE*/;
// 链式队列管理结构体
typedef struct
{
   NODE     *pHead; // 队头指针
   NODE     *pTail; // 队尾指针
   int       size ; // 队列当前元素个数
   int       num ;
}LinkQueue;
void LQ_init(LinkQueue *q,int sz);
int  LQ_isfull(LinkQueue *q);
int  LQ_isempty(LinkQueue *q);
int  LQ_push(LinkQueue *q,DATA data);
int  LQ_pop(LinkQueue *q,DATA *data);
int LQ_free(LinkQueue *q);
#endif

linkQueue.c

cs 复制代码
#include "LinkQueue.h"
#include <stdlib.h>
void LQ_init(LinkQueue *q,int sz)
{
    q -> pHead = q -> pTail = NULL;
    q -> size  = sz;
    q -> num   = 0;
}
int  LQ_isfull(LinkQueue *q)
{
    return q -> num == q -> size;
}
int  LQ_isempty(LinkQueue *q)
{
    return q -> num == 0;
}
int  LQ_push(LinkQueue *q,DATA data)
{
    if(LQ_isfull(q))
       return -1;
    NODE* pNew = (NODE*)malloc(sizeof(NODE));
    if(!pNew)
        return -1;
    pNew -> data  = data;
    pNew -> next  = NULL;
    if(!(q -> pTail))
       q -> pHead = q -> pTail = pNew;
    else
   {       
       q -> pTail -> next  = pNew;
       q -> pTail = pNew;
   }
    q -> num ++;
    return 0;
}
int  LQ_pop(LinkQueue *q,DATA *data)
{
    if(LQ_isempty(q))
       return -1;
     NODE* p = q -> pHead;
     *data  = p -> data;
     if(p == q -> pTail)
         q -> pHead = q -> pTail = NULL;
     else     
         q -> pHead = p -> next;
         
     free(p);
     q -> num --;
 
    return 0;
}
int LQ_free(LinkQueue *queue)
{
    NODE* p = queue -> pHead, *q = NULL;
    while(p)
   {
        q  = p;
        p  = p -> next;
        free(q);
   }
    queue -> pHead = queue -> pTail = NULL;
    queue -> num   = 0;
    return 0;
}

linkQueue_main.c

cs 复制代码
#include "LinkQueue.h"
#include <stdio.h>
int main(void)
{
    LinkQueue    queue;
    LQ_init(&queue,10);
    register  int i = 1;    
    for(; i <= 10 ; i++) 
       LQ_push(&queue, i);
    if( -1 == LQ_push(&queue,1024))
      fprintf(stderr,"满队,入队失败!\n");
    while(!LQ_isempty(&queue))
   {
        DATA   data;
        LQ_pop(&queue,&data);
        printf("%4d",data);
   }
    printf("\n");
    LQ_free(&queue);
    return 0; 
}

【课堂练习4】

构建一个链式队列,当用户输入数字时,将数字入队,当用户输入字母时,将队头元素出队。每次操作队列之后,将队列中的元素显示出来。

章节作业

(栈的基本操作)

【1】编程实现功能:将键盘输入的十进制数,转换为十六进制输出。

(栈的基本操作)(选做)

【2】编程实现汉诺塔游戏。

(栈的基本操作)(选做)

【3】面试题

(队列的基本操作)(选做)

【4】蜗牛在制定今天的旅游计划,有 nn 个景点可选,它已经把这些景点按照顺路游览的顺序排成一排了,每个地方有相应的景观标号,这里用一个整数表示,相同的标号意味着相同的景观。 蜗牛希望选取连续的一段景点,还要选出来的每一个景点的景观都不同,问它最多能选出多少个景点进行旅游。

提示:

假设景点的景观标号是: 6 2 8 2 6

那么蜗牛可选的最长不重复的连续景点数是3,即前三个6 2 8,或后三个8 2 6

v图像 小部件

相关推荐
肥猪猪爸1 小时前
使用卡尔曼滤波器估计pybullet中的机器人位置
数据结构·人工智能·python·算法·机器人·卡尔曼滤波·pybullet
linux_carlos1 小时前
环形缓冲区
数据结构
readmancynn1 小时前
二分基本实现
数据结构·算法
Bucai_不才1 小时前
【数据结构】树——链式存储二叉树的基础
数据结构·二叉树
盼海1 小时前
排序算法(四)--快速排序
数据结构·算法·排序算法
一直学习永不止步1 小时前
LeetCode题练习与总结:最长回文串--409
java·数据结构·算法·leetcode·字符串·贪心·哈希表
珹洺2 小时前
C语言数据结构——详细讲解 双链表
c语言·开发语言·网络·数据结构·c++·算法·leetcode
几窗花鸢3 小时前
力扣面试经典 150(下)
数据结构·c++·算法·leetcode
.Cnn3 小时前
用邻接矩阵实现图的深度优先遍历
c语言·数据结构·算法·深度优先·图论
2401_858286113 小时前
101.【C语言】数据结构之二叉树的堆实现(顺序结构) 下
c语言·开发语言·数据结构·算法·