数据结构-堆栈与队列

于 2024-07-30 23:21:48 发布
阅读量470 收藏 9
点赞数 14
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73417081/article/details/140739450
版权

王道章节内容

知识框架

考纲内容

  1. 栈与队列的基本概念；
  2. 栈与队列的顺序存储结构；
  3. 栈与队列的链式存储结构；
  4. 多维数组的存储；
  5. 特殊矩阵的压缩存储；
  6. 栈、队列和数组的应用。 

 引入 

后缀表达式

后缀表达式转中缀表达式

6 2 / 3 - 4 2 * + = 

“逐一扫描”，首先是 6，存入；（6）；NULL

然后是 2，存入；（6 2）；NULL

再者是 /，符合条件做运算输出 6 / 2，更新为3；（6 2 /）——（3）;6 / 2

接着是 3，存入；（3 3）;6 / 2

下来是 -，符合条件做运算输出 - 3，更新为 0；（3 3 -）——（0）;6 / 2 - 3

然后是 4，存入；（0 4）；6 / 2 - 3

再者是 2，存入；（0 4 2）；6 / 2 - 3

接着是 *，根据“顺序存入，倒序输出”，顶上做运算更新为 8；（0 8）；6 / 2 - 3 ~ 4 * 2

下来是 +，符合条件做运算输出 + 4 * 2，更新为 8；（8）；6 / 2 - 3 + 4 * 2

最后是 =，符合条件输出 = 8，更新为NULL。（NULL）；6 / 2 - 3 + 4 * 2 = 8

栈

把以上过程抽象出来，就是我们粗糙的“栈”的出入操作。

定义

栈（stack）

栈是只允许在一端进行插入或删除操作的线性表；

允许插入和删除的一端叫栈顶（top），另一端叫栈底（bottom），不含数据元素的叫空栈；

栈又称为后进先出（Last In First Out）的线性表，简称 LIFO 结构。

插入数据：入栈（Push）；

删除数据：出栈（Pop）。

抽象数据类型描述（ADT）

  1. Stack CreateStack( int MaxSize )： 生成空堆栈，其最大长度为MaxSize；
  2. int IsFull( Stack S, int MaxSize )：判断堆栈S是否已满；
  3. void Push( Stack S, ElementType item )：将元素item压入堆栈；
  4. int IsEmpty ( Stack S )：判断堆栈S是否为空；
  5. ElementType Pop( Stack S )：删除并返回栈顶元素；

顺序栈

定义

顺序栈

采用顺序存储的栈称为顺序栈，它利用一组地址连续的存储单元存放自栈底到栈顶的数据元素，同时附设一个指针（ top ）指示当前栈顶元素的位置。

结构代码实现​​​​​​​

陈越实现：

#define MaxSize <储存数据元素的最大个数>
typedef struct SNode *Stack;
struct SNode{
ElementType Data[MaxSize];
int Top;
};

《大话》实现（与王道类似）：

/* 顺序栈结构 */
typedef struct
{
        SElemType data[MAXSIZE];
        int top; /* 用于栈顶指针 */
}SqStack;

名词解释：

typedef struct SNode *Stack

typedef 用于为现有的类型定义一个新的别名；

struct SNode *Stack; 定义了一个名为 Stack 的类型，它是 struct SNode 类型的指针；

通过这种方式，你可以使用 Stack 类型来声明指向 SNode 结构体的指针。

struct SNode { ElementType Data[MaxSize]; int Top; }

struct SNode 定义了一个结构体类型，用于表示栈的数据结构；

ElementType Data[MaxSize]; 定义了一个数组 Data，用于存储栈中的元素。ElementType表示栈中元素的数据类型。例如，如果栈中存储的是整数，则 ElementType 可能被定义为 int；

int Top; 定义了一个整型变量 Top，用于表示栈顶元素的位置索引。当栈为空时，Top 的值通常为 -1。

操作及实现

初始化

《大话》实现：

/*  构造一个空栈S */
Status InitStack(SqStack *S)
{ 
        /* S.data=(SElemType *)malloc(MAXSIZE*sizeof(SElemType)); */
        S->top=-1;
        return OK;
}

王道实现：

void InitStack(SqStack &S){
    S.top = -1;  //初始化栈顶指针
}

名词解释：

使用引用 &S：

  • 当你使用引用 &S 时，函数参数 S 实际上是一个指向 SqStack 对象的引用。这意味着当你在函数内部修改 S 时，实际上是在修改原始的 SqStack 对象；
  • 使用引用可以避免复制整个 SqStack 对象，这对于较大的结构体来说可以节省内存和提高效率；
  • 引用确保你在函数内部所做的修改会反映到调用函数的上下文中。

使用指针 *S：

  • 如果你使用指针 *S，那么 S 将是一个指向 SqStack 的指针。这意味着你需要通过指针来访问和修改 SqStack 的成员；
  • 如果你使用指针，那么你需要使用间接访问运算符 -> 而不是成员访问运算符 . 来访问 SqStack 的成员；
  • 使用指针可以让你传递 SqStack 的地址，但在函数内部，你需要确保指针不是 NULL 并且正确地使用指针。

举个例子：

使用引用传递：

int main() {
    SqStack stack;
    InitStack(stack);  // 使用引用传递

    printf("Top index: %d\n", stack.top);  // 输出应为 -1

    return 0;
}

使用指针传递：

int main() {
    SqStack stack;
    InitStack(&stack);  // 使用指针传递

    printf("Top index: %d\n", stack.top);  // 输出应为 -1

    return 0;
}
判空

《大话》实现：

/* 若栈S为空栈，则返回TRUE，否则返回FALSE */
Status StackEmpty(SqStack S)
{ 
        if (S.top==-1)
                return TRUE;
        else
                return FALSE;
}

王道实现：

bool StackEmpty(SqStack S){
    if(S.top == -1 )  //栈空
        return true;
    else    
        return false;
}
求栈长

《大话》实现：

/* 返回S的元素个数，即栈的长度 */
int StackLength(SqStack S)
{ 
        return S.top+1;
}
入栈（Push）

陈越实现：

void Push( Stack PtrS, ElementType item )
{
 if ( PtrS->Top == MaxSize-1 ) {
 printf(“堆栈满”); return;
 }else {
 PtrS->Data[++(PtrS->Top)] = item;
 return;
 }
}

名词解释：

void Push(Stack PtrS, ElementType item)

  • void 表示函数不返回任何值。
  • Push 是函数名。
  • (Stack PtrS, ElementType item) 表示函数接收两个参数：一个 Stack 类型的指针 PtrS 和一个 ElementType 类型的变量 item。

《大话》实现：

/* 插入元素e为新的栈顶元素 */
Status Push(SqStack *S,SElemType e)
{
        if(S->top == MAXSIZE -1) /* 栈满 */
        {
                return ERROR;
        }
        S->top++;				/* 栈顶指针增加一 */
        S->data[S->top]=e;  /* 将新插入元素赋值给栈顶空间 */
        return OK;
}

王道实现：

bool Push(SqStack &S, ElemType x){
    if(S.top == Maxsize - 1)
        return false;
    S.data[++S.top]=x;    //指针先+1,后入栈
    return true;
}

名词解释：

bool Push(SqStack &S, ElemType x)

其作用是将一个元素 x 压入基于数组实现的栈 SqStack 中。如果栈已满，函数返回 false，表示压栈操作失败。否则，它将栈顶指针加一并将元素存入栈中，然后返回 true 表示成功。由于函数返回一个布尔值，因此返回类型为 bool。

 

出栈（Pop）

陈越实现：

ElementType Pop( Stack PtrS )
{
 if ( PtrS->Top == -1 ) {
 printf(“堆栈空”);
 return ERROR; /* ERROR是ElementType的特殊值，标志错误
*/
 } else 
 return ( PtrS->Data[(PtrS->Top)--] );
}

《大话》实现：

/* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
Status Pop(SqStack *S,SElemType *e)
{ 
        if(S->top==-1)
                return ERROR;
        *e=S->data[S->top];	/* 将要删除的栈顶元素赋值给e */
        S->top--;				/* 栈顶指针减一 */
        return OK;

王道实现：

bool Pop(SqStack &S, ElemType &x){
    if(S.top == - 1)
        return false;
    x=S.data[S.top--];    //指针先-1,后入栈
    return true;
}
读栈

读栈顶

《大话》实现:

/* 从栈底到栈顶依次对栈中每个元素显示 */
Status StackTraverse(SqStack S)
{
        int i;
        i=0;
        while(i<=S.top)
        {
                visit(S.data[i++]);
        }
        printf("\n");
        return OK;
}

共享栈

引子

定义

结构代码实现

陈越实现：

#define MaxSize <存储数据元素的最大个数>
struct DStack {
 ElementType Data[MaxSize]; 
 int Top1; /* 堆栈１的栈顶指针 */ 
 int Top2; /* 堆栈２的栈顶指针 */
} S;

 《大话》实现：

/* 两栈共享空间结构 */
typedef struct 
{
        SElemType data[MAXSIZE];
        int top1;	/* 栈1栈顶指针 */
        int top2;	/* 栈2栈顶指针 */
}SqDoubleStack;
操作及实现
初始化

《大话》实现：

/*  构造一个空栈S */
Status InitStack(SqDoubleStack *S)
{ 
        S->top1=-1;
        S->top2=MAXSIZE;
        return OK;
}
判栈空

《大话》实现：

/* 若栈S为空栈，则返回TRUE，否则返回FALSE */
Status StackEmpty(SqDoubleStack S)
{ 
        if (S.top1==-1 && S.top2==MAXSIZE)
                return TRUE;
        else
                return FALSE;
}
 求栈长

《大话》实现：

/* 返回S的元素个数，即栈的长度 */
int StackLength(SqDoubleStack S)
{ 
        return (S.top1+1)+(MAXSIZE-S.top2);
}
入栈

《大话》实现：

/* 插入元素e为新的栈顶元素 */
Status Push(SqDoubleStack *S,SElemType e,int stackNumber)
{
        if (S->top1+1==S->top2)	/* 栈已满，不能再push新元素了 */
                return ERROR;	
        if (stackNumber==1)			/* 栈1有元素进栈 */
                S->data[++S->top1]=e; /* 若是栈1则先top1+1后给数组元素赋值。 */
        else if (stackNumber==2)	/* 栈2有元素进栈 */
                S->data[--S->top2]=e; /* 若是栈2则先top2-1后给数组元素赋值。 */
        return OK;
}
出栈

《大话》实现：

/* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
Status Pop(SqDoubleStack *S,SElemType *e,int stackNumber)
{ 
        if (stackNumber==1) 
        {
                if (S->top1==-1) 
                        return ERROR; /* 说明栈1已经是空栈，溢出 */
                *e=S->data[S->top1--]; /* 将栈1的栈顶元素出栈 */
        }
        else if (stackNumber==2)
        { 
                if (S->top2==MAXSIZE) 
                        return ERROR; /* 说明栈2已经是空栈，溢出 */
                *e=S->data[S->top2++]; /* 将栈2的栈顶元素出栈 */
        }
        return OK;
}
读栈

《大话》实现：

Status StackTraverse(SqDoubleStack S)
{
        int i;
        i=0;
        while(i<=S.top1)
        {
                visit(S.data[i++]);
        }
        i=S.top2;
        while(i<MAXSIZE)
        {
                visit(S.data[i++]);
        }
        printf("\n");
        return OK;
}

链栈

定义

栈需要有栈顶指针，而单链表又可以有头指针，这启发我们可以将两者合二为一。

此时头结点失去其原有意义。至于为什么不取其他位置的指针，很简单，因为如果涉及插入和删除操作，不方便且有丢失数据逻辑关系的可能。

结构代码实现

陈越实现：

typedef struct SNode *Stack;
struct SNode{
ElementType Data;
struct SNode *Next;
} ;

《大话》实现：

/* 链栈结构 */
typedef struct StackNode
{
        SElemType data;
        struct StackNode *next;
}StackNode,*LinkStackPtr;

typedef struct
{
        LinkStackPtr top;
        int count;
}LinkStack;

名词解释：

StackNode,*LinkStackPtr;

  • StackNode 是 struct StackNode 的类型别名。
  • *LinkStackPtr; 定义了 LinkStackPtr 类型，它是一个指向 StackNode 类型的指针。这意味着 LinkStackPtr 可以用于声明指向栈节点的指针。

王道实现：

typedef struct Linknode{
    ElemType data;    //数据域
    struct Linknode *next;    指针域
}LiStack;    栈类型定义
操作及实现
初始化

《大话》实现：

/*  构造一个空栈S */
Status InitStack(LinkStack *S)
{ 
        S->top = (LinkStackPtr)malloc(sizeof(StackNode));
        if(!S->top)
                return ERROR;
        S->top=NULL;
        S->count=0;
        return OK;
}

    p = (int *)malloc(sizeof(int))

  • 分配足够的内存来存储一个整数；
  • 这里的星号 * 在 malloc 函数调用的结果后面，用于类型转换；
  • (int *) 是类型转换操作，将 malloc 返回的 void * 类型转换为 int * 类型，使得 p 可以安全地指向这块内存。​​​​​​​

​​​​​​​为什么这里不用加  *  ？

  • S->top 是一个指向 StackNode 的指针变量；
  • LinkStackPtr 已经是一个指向 StackNode 类型的指针类型；
  • LinkStackPtr 相当于 struct StackNode *。
判栈空

陈越实现：

int IsEmpty(Stack S) 
{ /*判断堆栈S是否为空，若为空函数返回整数1，否
则返回0 */
return ( S->Next == NULL );
}

《大话》实现：

/* 若栈S为空栈，则返回TRUE，否则返回FALSE */
Status StackEmpty(LinkStack S)
{ 
        if (S.count==0)
                return TRUE;
        else
                return FALSE;
}
求栈长

《大话》实现：

/* 返回S的元素个数，即栈的长度 */
int StackLength(LinkStack S)
{ 
        return S.count;
}
进栈

陈越实现：

void Push( ElementType item, Stack S) 
{ /* 将元素item压入堆栈S */
struct SNode *TmpCell;
TmpCell=(struct SNode *)malloc(sizeof(struct SNode));
TmpCell->Element = item;
TmpCell->Next = S->Next;
S->Next = TmpCell;
}

《大话》实现：

/* 插入元素e为新的栈顶元素 */
Status Push(LinkStack *S,SElemType e)
{
        LinkStackPtr s=(LinkStackPtr)malloc(sizeof(StackNode)); 
        s->data=e; 
        s->next=S->top;	/* 把当前的栈顶元素赋值给新结点的直接后继，见图中① */
        S->top=s;         /* 将新的结点s赋值给栈顶指针，见图中② */
        S->count++;
        return OK;
}
出栈

陈越实现：

ElementType Pop(Stack S)
{ /* 删除并返回堆栈S的栈顶元素 */
 struct SNode *FirstCell;
ElementType TopElem;
if( IsEmpty( S ) ) {
printf(“堆栈空”); return NULL;
} else {
FirstCell = S->Next; 
S->Next = FirstCell->Next;
TopElem = FirstCell ->Element;
free(FirstCell);
return TopElem;
}
}

《大话》实现：

/* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
Status Pop(LinkStack *S,SElemType *e)
{ 
        LinkStackPtr p;
        if(StackEmpty(*S))
                return ERROR;
        *e=S->top->data;
        p=S->top;					/* 将栈顶结点赋值给p，见图中③ */
        S->top=S->top->next;    /* 使得栈顶指针下移一位，指向后一结点，见图中④ */
        free(p);                    /* 释放结点p */        
        S->count--;
        return OK;
}
读栈

《大话》实现：

Status StackTraverse(LinkStack S)
{
        LinkStackPtr p;
        p=S.top;
        while(p)
        {
                 visit(p->data);
                 p=p->next;
        }
        printf("\n");
        return OK;
}

队列

定义

队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表；

允许插入的一头叫队尾，允许删除的一头叫队尾；

队列是一种先进先出（First In First Out）的线性表，简称 FIFO 结构。

抽象数据类型描述

  1. Queue CreatQueue( int MaxSize )：生成长度为MaxSize的空队列；
  2. int IsFullQ( Queue Q, int MaxSize )：判断队列Q是否已满；
  3. void AddQ( Queue Q, ElementType item )： 将数据元素item插入队列Q中；
  4. int IsEmptyQ( Queue Q )： 判断队列Q是否为空；
  5. ElementType DeleteQ( Queue Q )：将队头数据元素从队列中删除并返回。

顺序存储结构

定义

为什么要引入 front 和 rear？

让我们想一下，当执行入列操作时是在队尾，，直接插入，不需要移动其他任何元素，时间复杂度低；但是，在执行出列操作时，按以往案例，似乎需要删除头结点，同时所有节点向前移动，时间复杂度较高。

怎么办呢？

不妨想想，假设对头不一定要在头结点位置，同时为了方便解决当只有一个数据元素时对头队尾重合的问题（难以判断是空还是只有一个），我们在出队时选择直接“原地”消失队头，同时引入 front 指针指向队头元素，rear 指针指向队尾的下一个位置。

这样当然还会有新的问题，比如但我们进行入列和出列，使得前面几个位置空出，后面几个位置占满，此时 rear就会超出数组之外，指向非法位置，但此时空间并没有全部利用，存在“伪溢出”。

如何解决这个问题呢，很简单，头尾相接。

循环队列

定义

循环队列

队列中的头尾相接的顺序存储结构（有点拗口哈哈）；

即把出存储队列元素的表从逻辑上视为一个环；

队列空时，front = rear ;队列满时，选择空出一个元素空间，使得（ rear + 1 ）% QueueSize == front 。

 补充：

通用的计算队列长度的公式：

（ rear - front + QueueSize ）% QueueSize

 结构代码实现

《大话》实现：

/* 循环队列的顺序存储结构 */
typedef struct
{
	QElemType data[MAXSIZE];
	int front;    	/* 头指针 */
	int rear;		/* 尾指针，若队列不空，指向队列尾元素的下一个位置 */
}SqQueue;

Status visit(QElemType c)
{
	printf("%d ",c);
	return OK;
}
操作及实现
初始化

《大话》实现：

/* 初始化一个空队列Q */
Status InitQueue(SqQueue *Q)
{
	Q->front=0;
	Q->rear=0;
	return  OK;
}

王道实现：

void IniQueue(SqQueue &Q){
    Q.rear = Q.front = 0;    //初始化队头、队尾指针
}
判队空

《大话》实现：

/* 若队列Q为空队列,则返回TRUE,否则返回FALSE */
Status QueueEmpty(SqQueue Q)
{ 
	if(Q.front==Q.rear) /* 队列空的标志 */
		return TRUE;
	else
		return FALSE;
}

王道实现：

bool isEmpty(SqQueue Q){
    if (Q.rear == Q.front)
        return true;
    else
        return false;
}
入队

《大话》实现：

/* 若队列未满，则插入元素e为Q新的队尾元素 */
Status EnQueue(SqQueue *Q,QElemType e)
{
	if ((Q->rear+1)%MAXSIZE == Q->front)	/* 队列满的判断 */
		return ERROR;
	Q->data[Q->rear]=e;			/* 将元素e赋值给队尾 */
	Q->rear=(Q->rear+1)%MAXSIZE;/* rear指针向后移一位置， */
								/* 若到最后则转到数组头部 */
	return  OK;
}

王道实现：

void EnQueue(LinkQueue &Q,ElemType x){
    LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode));
    s->data = x;
    s->next = NULL;
    Q.rear->next = s;    //插入队尾
    Q.rear = s;    //修改队尾指针
}

Q.rear->next = s;

  • 目的：将新节点 s 插入到队列的末尾。

  • 作用：设置当前队尾节点 Q.rear 的 next 指针指向新节点 s。

Q.rear = s;

  • 目的：更新队尾指针 Q.rear，使其指向新加入的节点 s。

  • 作用：将 Q.rear 设置为新节点 s，确保 Q.rear 指向队列的最后一个节点。

出队

《大话》实现：

/* 若队列不空，则删除Q中队头元素，用e返回其值 */
Status DeQueue(SqQueue *Q,QElemType *e)
{
	if (Q->front == Q->rear)			/* 队列空的判断 */
		return ERROR;
	*e=Q->data[Q->front];				/* 将队头元素赋值给e */
	Q->front=(Q->front+1)%MAXSIZE;	/* front指针向后移一位置， */
									/* 若到最后则转到数组头部 */
	return  OK;
}

王道实现：

bool DeQueue(LinkQueue &Q,ElemType &x){
    if(Q.front == Q.rear)
        return false;
    LinkNode *q = Q.front->next;    //创建一个临时指针 q，用于指向删除后的队首节点。
    x = p->data;
    Q.front->next = p->next;
    if(Q.rear == p)
        Q.rear = Q.front;    //若原队列只有一个结点，删除后变空
    free(p);
    return true;
}
读队

《大话》实现：

/* 从队头到队尾依次对队列Q中每个元素输出 */
Status QueueTraverse(LinkQueue Q)
{
	QueuePtr p;
	p=Q.front->next;
	while(p)
	{
		 visit(p->data);
		 p=p->next;
	}
	printf("\n");
	return OK;
}

链式存储结构

链队列，即使用尾进头出的单链表，插入和删除分别在链表的两头进行。

结构代码实现

陈越实现：

struct Node{
 ElementType Data;
 struct Node *Next;
}; 
struct QNode{ /* 链队列结构 */
 struct Node *rear; /* 指向队尾结点 */
 struct Node *front; /* 指向队头结点 */
}; 
typedef struct QNode *Queue;
Queue PtrQ;

 《大话》实现：

typedef struct QNode	/* 结点结构 */
{
   QElemType data;
   struct QNode *next;
}QNode,*QueuePtr;

typedef struct			/* 队列的链表结构 */
{
   QueuePtr front,rear; /* 队头、队尾指针 */
}LinkQueue;
操作及实现
初始化
/* 构造一个空队列Q */
Status InitQueue(LinkQueue *Q)
{ 
	Q->front=Q->rear=(QueuePtr)malloc(sizeof(QNode));
	if(!Q->front)
		exit(OVERFLOW);
	Q->front->next=NULL;
	return OK;
}
判队空
/* 若Q为空队列,则返回TRUE,否则返回FALSE */
Status QueueEmpty(LinkQueue Q)
{ 
	if(Q.front==Q.rear)
		return TRUE;
	else
		return FALSE;
}
求队长
/* 求队列的长度 */
int QueueLength(LinkQueue Q)
{ 
	int i=0;
	QueuePtr p;
	p=Q.front;
	while(Q.rear!=p)
	{
		 i++;
		 p=p->next;
	}
	return i;
}
入队
/* 插入元素e为Q的新的队尾元素 */
Status EnQueue(LinkQueue *Q,QElemType e)
{ 
	QueuePtr s=(QueuePtr)malloc(sizeof(QNode));
	if(!s) /* 存储分配失败 */
		exit(OVERFLOW);
	s->data=e;
	s->next=NULL;
	Q->rear->next=s;	/* 把拥有元素e的新结点s赋值给原队尾结点的后继，见图中① */
	Q->rear=s;		/* 把当前的s设置为队尾结点，rear指向s，见图中② */
	return OK;
}
出队

陈越实现：

//不带头结点的链式队列出队操作的一个示例

ElementType DeleteQ ( Queue PtrQ )
{ struct Node *FrontCell; 
 ElementType FrontElem;
 if ( PtrQ->front == NULL) {
 printf(“队列空”); return ERROR;
 } 
 FrontCell = PtrQ->front;
 if ( PtrQ->front == PtrQ->rear) /* 若队列只有一个元素 */
 PtrQ->front = PtrQ->rear = NULL; /* 删除后队列置为空 */
 else 
 PtrQ->front = PtrQ->front->Next;
 FrontElem = FrontCell->Data;
 free( FrontCell ); /* 释放被删除结点空间 */
 return FrontElem;
}

《大话》实现：

/* 若队列不空,删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR */
Status DeQueue(LinkQueue *Q,QElemType *e)
{
	QueuePtr p;
	if(Q->front==Q->rear)
		return ERROR;
	p=Q->front->next;		/* 将欲删除的队头结点暂存给p，见图中① */
	*e=p->data;				/* 将欲删除的队头结点的值赋值给e */
	Q->front->next=p->next;/* 将原队头结点的后继p->next赋值给头结点后继，见图中② */
	if(Q->rear==p)		/* 若队头就是队尾，则删除后将rear指向头结点，见图中③ */
		Q->rear=Q->front;
	free(p);
	return OK;
}
读队
/* 从队头到队尾依次对队列Q中每个元素输出 */
Status QueueTraverse(LinkQueue Q)
{
	QueuePtr p;
	p=Q.front->next;
	while(p)
	{
		 visit(p->data);
		 p=p->next;
	}
	printf("\n");
	return OK;
}

双端队列

参考

王道《数据结构》；

程杰《大话数据结构》；

陈越《数据结构》。

王悦雨的向北日记
关注
  • 14
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python 实现数据结构-堆栈和队列的操作方法
09-19
堆栈和队列是两种基本且常见的线性数据结构，它们各自具有特定的存取规则。 堆栈（Stack）是一种“后进先出”（Last In, First Out，简称LIFO）的数据结构。它的操作主要包括压栈（Push）和弹栈（Pop）。压栈是指将...
数据结构——堆栈和队列
02-06
在这个主题中，我们将深入探讨两个关键的数据结构：堆栈（Stack）和队列（Queue）。这两个数据结构在编程中扮演着至关重要的角色，特别是在处理算法和程序流程控制方面。 堆栈是一种后进先出（LIFO，Last In First ...
数据结构-堆栈和队列
留下虚度光阴的一些证据。
06-04 869
数据结构-堆栈和队列
数据结构--堆栈和队列
亲，如果文章对你有帮助的话请点个关注吧！
04-04 3607
数据结构仔细看完课本，发现堆栈和队列并没有自己理解的那么困难在逻辑结构上，堆栈和队列都是线性表在存储结构上，都可以划分为顺序结构和链表结构在运算结构上，堆栈是后进先出，队列是先进先出。可以将堆栈和数列理解为运算受限的线性表、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、下面是我课前预习收集整理的资料，受益匪浅    侵权立删堆栈和队列（数据结构）（1）堆栈基本概念(a)定义:限定...
数据结构实验3---堆栈和队列的使用
qq_66451743的博客
05-28 509
一、实验目的: 1．掌握堆栈、队列的存储方式和基本操作 2．掌握堆栈及队列运算原则在解决实际问题中的应用 二、实验内容: 1.利用栈结构，编写程序将十进制数转换成N进制数。 说明:十进制数值转换成二进制使用辗转相除法将一个十进制数值转换成二进制数值。即用该十进制数值除以2，并保留其余数；重复此操作，直到该十进制数值为0为止。最后将所有的余数反向输出就是所对应的二进制数值。十进制数值转换成八进制算法类似。转换算法要求用一个函数完成。 2.编程判断一个字符串是否为回文。 说明:要求使用堆栈和队
数据结构---堆栈和队列
wuwndj的博客
05-16 213
顺序堆栈算法： 注意状态，要包含头文件，保存时以.h形式保存 注意存储空间初始分配量的使用，明确函数返回值含义 形参类型 主函数测试： 运行结果： 链式堆栈： 运行结果：
数据结构-堆栈和队列的实验
hling_so的博客
10-18 1427
堆栈 队列
C语言数据结构-栈与队列
qq_55391702的博客
01-18 1178
栈与队列栈与队列栈的定义栈的实现栈的初始化栈的删除栈的压入栈顶元素的取出队列的定义队列的实现队列的初始化队列的删除队列的插入队头元素的取出 栈与队列 栈的定义 栈（stack）是限定仅在表尾进行插入或删除操作的线性表。因此，对栈来说，表尾端有其特殊含义，称为栈顶（top），相应的，表头端称为栈底（bottom）。不含元素的空表称为空栈。因为仅在表尾进行操作所以符合先进后出的规律。 栈的实现 栈的定义如下： #define STACK_INIT_SIZE 100 //定义初始分配空间大小 typedef
巧用javascript数组实现数据结构-堆栈与队列
冰豆中国
05-02 927
简单的利用javascript的数组实现数据结构中的堆栈和队列。 Stack.js源码： /* * @brief: 定义堆栈类 * @remark: 实现堆栈基本功能 */ function Stack(){ //存储元素数组 var aElement = new Array(); /* * @brief: 元素入栈 * @param: 入
数据结构题目-栈与队列
江船夜雨听笛的博客
11-30 198
不多说 牛逼
7-1 堆栈模拟队列
weixin_60593311的博客
11-06 453
设已知有两个堆栈S1和S2，请用这两个堆栈模拟出一个队列Q。所谓用堆栈模拟队列，实际上就是通过调用堆栈的下列操作函数:实现队列的操作，即入队和出队。输入首先给出两个正整数和，表示堆栈和的最大容量。随后给出一系列的队列操作：表示将入列（这里假设为整型数字）；表示出队操作；表示输入结束。对输入中的每个操作，输出相应出队的数字，或者错误信息。如果入队操作无法执行，也需要输出。每个输出占1行。 输出样例: 代码示例如下：
数据结构-堆栈和队列实验报告.pdf
09-30
数据结构中的堆栈和队列是两种非常基础且重要的数据结构，它们在计算机科学和编程中扮演着不可或缺的角色。本实验报告主要关注堆栈和队列的实现与应用。 堆栈（Stack）是一种后进先出（Last In First Out, LIFO）的...
数据结构-堆栈和队列实验报告.doc
09-26
数据结构-堆栈和队列实验报告.doc
学习记录day18——数据结构 算法
weixin_64918301的博客
07-24 748
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
（数据结构）二叉树
2401_83526138的博客
07-24 621
树是一种非线性的数据结构，它是由n（n>=0）个有限节点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：有一个特殊的节点，称为根节点，根节点没有前驱节点除根节点外，其余节点被分成M（M > 0）个互不相交的集合T1, T2, ......, Tm，其中每一个集合Ti(1 <= i <= m)又是一棵与树类似的子树。每棵子树的根节点有且只有一个前驱，可以有0个或多个后继树是递归定义的。
【C语言】数组栈的实现
最新发布
2301_80840905的博客
07-25 745
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端
数据结构——双向链表及其总结
2406_83392683的博客
07-23 341
1.概述链表根据是否带头、是否双向、是否循环可以分为八种，双向链表是典型的带头双向循环链表。2.双向链表的实现过程及其解析双向链表的实现依旧包含List.h，List.c，test.c2.1 链表初始化双向链表为空的情况：只有一个哨兵位。2.2插入数据。
7.24数据结构
2301_81236242的博客
07-24 579
1>树形结构：表示数据元素之间存在一对多的关系2>树：是由一个根节点多个子树构成的树形结构3>节点：就是树中的数据元素4>父亲节点：当前节点的直接上级节点5>孩子节点：当前节点的直接下架节点6>祖先节点：当前节点的直接或间接上级节点7>子孙节点：当前节点的直接或间接下级节点8>兄弟节点：拥有相同父节点的所有节点互称为兄弟节点9>堂兄弟节点：其父节点在同一层的所有节点，互为堂兄弟节点10>根节点：没有父节点的节点11>叶子节点：没有子节点的节点称为叶子节点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

王悦雨的向北日记

我找不到很好的原因

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值