有关栈和队列的三道OJ题【C语言】

最新推荐文章于 2024-07-25 19:28:17 发布
最新推荐文章于 2024-07-25 19:28:17 发布
阅读量496 收藏 1
点赞数 6
分类专栏： 刷题记录 文章标签： c语言 数据结构 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/C0631xjn_/article/details/126273083
版权

目录

1.认识栈和队列

概念

栈和队列是两个逻辑不同的数据结构

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列遵循先进先出FIFO(First In First Out) 的原则。入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头

🔎在C语言中，为了运用栈和队列来解决OJ题和实际问题，我们必须先自己写出来这两种数据结构才能用。因此我们先实现栈和队列，并用其来解决后面的问题。

实现

🌲栈的实现

//Stack.h
//顺序表实现栈
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

#define InitCapacity 4 //栈的初始容量
#define MUL 2 //栈每次扩容的倍数

typedef int StackDataType;
typedef struct
{
	StackDataType* arr;//栈主体
	int top;//栈顶(实际上是栈顶元素的下一个位置)
	size_t capacity;//容量
}Stack;

void StackInit(Stack* pst);//栈的初始化
void StackDestroy(Stack* pst);//栈的销毁
void StackPrint(Stack* pst);//打印
bool StackIsEmpty(Stack* pst);//判断栈是否为空
void StackPush(Stack* pst, StackDataType data);//压栈
void StackPop(Stack* pst);//出栈
StackDataType StackTop(Stack* pst);//获取栈顶元素
size_t StackSize(Stack* pst);//获取栈中有效元素的个数

//Stack.c
#define _CRT_SECURE_NO_WARNINGS 1
#include "Stack.h"

void CheckCapacity(Stack* pst)//检查并扩容
{
	assert(pst);
	if (pst->capacity == pst->top)
	{
		size_t newcapacity = (pst->capacity == 0 ? InitCapacity : MUL * pst->capacity);
		StackDataType* tmp = (StackDataType*)realloc(pst->arr, sizeof(StackDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		//
		pst->arr = tmp;
		pst->capacity = newcapacity;
	}
}

void StackInit(Stack* pst)//栈的初始化
{
	assert(pst);
	pst->capacity = pst->top = 0;
	pst->arr = NULL;
}

void StackDestroy(Stack* pst)//栈的销毁
{
	assert(pst);
	//
	free(pst->arr);
	pst->arr = NULL;
	//
	pst->capacity = pst->top = 0;
}

void StackPrint(Stack* pst)//打印
{
	assert(pst);
	//
	if (StackIsEmpty(pst))
	{
		printf("NULL\n");
	}
	//
	for (int i = 0;i < pst->top;i++)
	{
		printf("%d ", pst->arr[i]);
	}
	printf("\n");
}

bool StackIsEmpty(Stack* pst)//判断栈是否为空
{
	assert(pst);
	//
	return pst->top == 0;
}

void StackPush(Stack* pst, StackDataType data)//压栈
{
	assert(pst);
	//
	CheckCapacity(pst);//检查容量
	//
	pst->arr[pst->top] = data;
	pst->top++;
}

void StackPop(Stack* pst)//出栈
{
	assert(pst);
	assert(!StackIsEmpty(pst));//判断栈是否为空，为空则无法出栈
	//
	pst->top--;
}

StackDataType StackTop(Stack* pst)//获取栈顶元素
{
	assert(pst);
	assert(!StackIsEmpty(pst));
	//
	return pst->arr[pst->top - 1];
}

size_t StackSize(Stack* pst)//获取栈中有效元素的个数
{
	assert(pst);
	return pst->top;
}

🌲队列的实现

//Queue.h
//链表实现队列
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

typedef int QueueDataType;
//队列的结点
typedef struct QueueNode
{
	QueueDataType data;
	struct QueueNode* next;
}QueueNode;

typedef struct
{
	QueueNode* front;//队头指针
	QueueNode* rear;//队尾指针
	int size;//队列的长度
}Queue;

void QueueInit(Queue* pqe);//队列初始化
void QueueDestroy(Queue* pqe);//队列销毁
void QueuePrint(Queue* pqe);//打印队列
bool QueueIsEmpty(Queue* pqe);//判断队列是否为空
void QueuePush(Queue* pqe, QueueDataType data);//队尾入元素
void QueuePop(Queue* pqe);//队头出元素
QueueDataType QueueFront(Queue* pqe);//获取队头元素
QueueDataType QueueRear(Queue* pqe);//获取队尾元素
int QueueSize(Queue* pqe);//获取队列中有效元素个数

//Queue.c
#define _CRT_SECURE_NO_WARNINGS 1
#include "Queue.h"

void QueueInit(Queue* pqe)//队列初始化
{
	assert(pqe);
	//
	pqe->front = pqe->rear = NULL;
	pqe->size = 0;
}

void QueueDestroy(Queue* pqe)//队列销毁
{
	assert(pqe);
	//
	QueueNode* cur = pqe->front;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	//
	pqe->front = pqe->rear = NULL;
}

void QueuePrint(Queue* pqe)//打印队列
{
	assert(pqe);
	//
	QueueNode* cur = pqe->front;
	while (cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

bool QueueIsEmpty(Queue* pqe)//判断队列是否为空
{
	assert(pqe);
	//
	return pqe->front == NULL && pqe->rear == NULL;
}

void QueuePush(Queue* pqe, QueueDataType data)//队尾入元素
{
	assert(pqe);
	//创建新结点
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = data;
	newnode->next = NULL;
	//链接
	if (pqe->front == NULL)
	{
		pqe->front = pqe->rear = newnode;
	}
	else
	{
		pqe->rear->next = newnode;
		pqe->rear = pqe->rear->next;
	}
	//
	pqe->size++;
}

void QueuePop(Queue* pqe)//队头出元素
{
	assert(pqe);
	assert(!QueueIsEmpty(pqe));
	//出列
	QueueNode* next = pqe->front->next;
	free(pqe->front);
	pqe->front = next;
	//如果删的是最后一个，删完front会变为NULL，此时rear也应该置为NULL
	if (pqe->front == NULL)
	{
		pqe->rear = NULL;
	}
	//
	pqe->size--;
}

QueueDataType QueueFront(Queue* pqe)//获取队头元素
{
	assert(pqe);
	assert(!QueueIsEmpty(pqe));
	//
	return pqe->front->data;
}

QueueDataType QueueRear(Queue* pqe)//获取队尾元素
{
	assert(pqe);
	assert(!QueueIsEmpty(pqe));
	//
	return pqe->rear->data;
}

int QueueSize(Queue* pqe)//获取队列中有效元素个数
{
	assert(pqe);
	return pqe->size;
}

2.用队列实现栈

🍉题目

在这里插入图片描述

🍎思路

🎈用两个队列实现后入先出的栈，我们的结构大概是这样的：
在这里插入图片描述
🎈因为栈的后入先出的特点和队列的先入先出的特点大不相同，因此我们在Pop（出栈）之前需要将先入的数据挪到另外一个队列。就像这样
在这里插入图片描述
在这里插入图片描述

因为4是后进入的数据，在栈的角度看它是栈顶，出栈时需要出的数据便是栈顶4。
另外需要注意的是，我们要保证至少有一个队列为空，在出栈挪动数据时将非空队列的所有数据挪动到空队列中。否则，会混乱模拟栈的顺序。

⭕综上所述，我们用队列模拟栈是这样实现的
在这里插入图片描述

从图中可以清晰地看到：
入栈：当两个队列皆为空时，我们可以选取任意的队列入数据。当两个队列一个为空一个不为空时，我们要选择不为空的队列入数据。
出栈： 每次出栈，我们关注不为空的队列，该队列的队尾既为模拟栈的栈顶。要想弹出这个队尾的数据，应该先将队尾前面的所有数据挪动到另外一个空队列，这样队尾便成了队头，直接从队头出数据即可。
取栈顶和判空： 而取栈顶元素就是取不为空的队列的队尾元素，判断栈是否为空只需要判断两个队列是否都为空即可，这两个接口相对容易实现。

🍑实现

//引用第一目我们实现的队列以及各种接口
//模拟栈的结构（由两个队列构成）
typedef struct {
    Queue q1;
    Queue q2;
} MyStack;

//创建一个模拟栈
MyStack* myStackCreate() {
    MyStack* tmp = (MyStack*)malloc(sizeof(MyStack));
    if(tmp == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    //
    QueueInit(&tmp->q1);
    QueueInit(&tmp->q2);
    return tmp;
}

//入栈,找到不为空的队列
void myStackPush(MyStack* obj, int x) {
    assert(obj);
    if(QueueIsEmpty(&obj->q1))//q1空q2不空 或 q1q2都空
    {
        QueuePush(&obj->q2,x);
    }
    else//q1不空q2空
    {
        QueuePush(&obj->q1,x);
    }
}

//出栈，要挪动数据
int myStackPop(MyStack* obj) {
    assert(obj);
    //找出空队列和非空队列(先默认q1为空q2为非空，再纠错)
    Queue* empty = &obj->q1;
    Queue* nonempty = &obj->q2;
    if(!QueueIsEmpty(&obj->q1))
    {
        empty = &obj->q2;
        nonempty = &obj->q1;
    }
    //挪动非空队列的数据到空队列,留下队尾
    while(QueueSize(nonempty)>1)
    {
        QueuePush(empty,QueueFront(nonempty));
        QueuePop(nonempty);
    }
    int ret = QueueFront(nonempty);
    QueuePop(nonempty);
    return ret;
}

//取栈顶元素
int myStackTop(MyStack* obj) {
    assert(obj);
    Queue* empty = &obj->q1;
    Queue* nonempty = &obj->q2;
    if(!QueueIsEmpty(&obj->q1))
    {
        empty = &obj->q2;
        nonempty = &obj->q1;
    }
    //
    return QueueRear(nonempty);
}

//判空
bool myStackEmpty(MyStack* obj) {
    assert(obj);
    return QueueIsEmpty(&obj->q1) && QueueIsEmpty(&obj->q2);
}

//释放空间
void myStackFree(MyStack* obj) {
    assert(obj);
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
}

3.用栈实现队列

🍉题目

在这里插入图片描述

🍎原理

🎈用栈模拟实现队列的结构是这样的，两个栈，一个用于入数据，一个用于出数据。
在这里插入图片描述

由于栈先入后出的特性，我们将pushST中的数据挪到popST中后，数据的顺序恰好会发生改变，这时先前的栈底（pushST的栈底）会变成栈顶（pushST的栈顶），这个栈顶就是模拟队列的队头，此时便可以通过popST出去。

在这里插入图片描述

🎈需要注意的是，每次我们要pop数据时，要检查popST中是否有数据。如果有就直接pop其中的数据，如果没有才需要将pushST中的数据挪动过来。否则也会导致队列的顺序混乱

⭕如下图：
在这里插入图片描述

🍑实现

typedef struct {
    Stack pushST;
    Stack popST;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* tmp = (MyQueue*)malloc(sizeof(MyQueue));
    if(tmp == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    //
    StackInit(&tmp->pushST);
    StackInit(&tmp->popST);
    //
    return tmp;
}

bool myQueueEmpty(MyQueue* obj) {
    assert(obj);
    return StackIsEmpty(&obj->pushST) && StackIsEmpty(&obj->popST);
}

void myQueuePush(MyQueue* obj, int x) {
    assert(obj);
    StackPush(&obj->pushST,x);
}

int myQueuePop(MyQueue* obj) {
    assert(obj);
    //如果popST为空，则将pushST中所有元素转移到popST中
    if(StackIsEmpty(&obj->popST))
    {
            while(!StackIsEmpty(&obj->pushST))
            {
                StackPush(&obj->popST,StackTop(&obj->pushST));
                StackPop(&obj->pushST);
            }
    }
    //popST出栈
    int ret = StackTop(&obj->popST);
    StackPop(&obj->popST);
    return ret;
}

int myQueuePeek(MyQueue* obj) {
    assert(obj);
    assert(!myQueueEmpty(obj));//控制队列不为空，才能取队头
    if(!StackIsEmpty(&obj->popST))
    {
        return StackTop(&obj->popST);
    }
    else
    {
        while(!StackIsEmpty(&obj->pushST))
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
        return StackTop(&obj->popST);
    }
}

void myQueueFree(MyQueue* obj) {
    assert(obj);
    StackDestroy(&obj->pushST);
    StackDestroy(&obj->popST);
    free(obj);
}

4.设计循环队列

🍉题目

在这里插入图片描述

🍎思路

在这里插入图片描述

💡循环队列的逻辑结构是这样的：队头与队尾相连接，并用front和rear两个指针分别控制队头和队尾，front和rear之间的空间为循环队列的有效空间。出入数据时，空间可以重复利用，提高的空间的使用率。

⭕这里其实用链表和数组（顺序表）都能实现循环队列，但是考虑到rear是队尾元素的下一个位置，使用单链表无法访问到队尾元素。为了结构的简洁性，这里我们用顺序表实现循环队列。

假设我们要设计一个长度为5的队列，那按正常思路我们开辟一个长度为5的数组应该是能够解决问题的，但当我们实际操作时，会遇到以下问题。
在这里插入图片描述

⭕无法区分队列的空和满该如何解决呢？有两种思路：
1.多开辟一个空间，这个空间不存储数据
2.利用变量Size记录队列的有效长度

我们用第一种思路，也是比较常见的一种思路，解决如下：
在这里插入图片描述

🎈我们可以看到，现在无论是哪种情况的满，rear的下一个位置是front，很好区分空和满，而且rear指向的空间永远没有值，这个空间是为了区分队列空和满而开辟的。

🔎我们还需要注意一种情况，当front和rear在队中时，移动时只需要+1即可。那么，如果他们在队尾应该怎么移动呢？根据循环队列的逻辑结构，我们知道当rear(或front)在队尾时，移动到下一个位置肯定是下标为0的位置，直接+1可能就越界了。粗暴一点解决就是直接加一个判断条件，如果rear(或front)在队尾便归回0。而巧妙运用一点数学，你会发现这其实非常简单。
假设队列的长度为N(有效长度为N-1)，那么在往后移动rear(或front)的时候，我们有一个公式：
rear = (rear+1)%N - - - (移动front就把rear换成front)

同理，在往前移动rear(或front)的时候，也有一个公式：
rear = (rear-1+N)%N - - - (移动front就把rear换成front)

这是一个通式，不管rear(或front)在队中还是队尾，都能正确的移动以达成我们想要的结果。

🔎相同道理，若要计算循环队列的有效长度Len，也有一个公式：
Len = (rear-front+N)%N

这个公式无论rear和front谁大谁小都是适用的
%N：确保了rear>front情况的准确性，可理解为此时rear-front是 有效长度
+N：确保了rear<front情况的准确性，可理解为此时rear-front的绝对值是 队列长度-有效长度

在这里插入图片描述
例如这种情况，(rear-front+N)%N = (1-3+6)%6 = 4
在这里插入图片描述
又如这种情况，(rear-front+N)%N = (5-1+6)%6 = 4

🍑实现

typedef struct {
    int* a;
    int front;
    int rear;
    int N;//队列的长度
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    int* pa = (int*)malloc(sizeof(int)*(k+1));
    //
    obj->a = pa;
    obj->front = obj->rear = 0;
    obj->N = k+1;//多开一块空间，用于判空满
    return obj;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    assert(obj);
    return obj->front == obj->rear;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    assert(obj);
    return obj->front == (obj->rear+1) % (obj->N);//运用公式，算得上rear的下一个位置的下标值
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    assert(obj);
    if(!myCircularQueueIsFull(obj))
    {
        obj->a[obj->rear] = value;
        obj->rear = (obj->rear+1) % (obj->N);//运用公式
        return true;
    }
    return false;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    assert(obj);
    if(!myCircularQueueIsEmpty(obj))
    {
        obj->front = (obj->front+1) % (obj->N);//运用公式
        return true;
    }
    return false;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->a[obj->front];
    }
}

int myCircularQueueRear(MyCircularQueue* obj) {
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->a[(obj->rear-1+obj->N)% obj->N];//运用公式
    }
}

void myCircularQueueFree(MyCircularQueue* obj) {
    assert(obj);
    free(obj->a);
    obj->a = NULL;
    free(obj);
}

🌝Good Night

超人不会飞）
关注
  • 6
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
OJ部分习题及解答（c语言）
03-16
3. **255-C小加随机数.c**：此题可能与随机数生成和数学运算有关，可能是要求程序生成一定范围内的随机数并进行特定的加法操作。 4. **833-取石子（七）.c**：这可能是一个典型的博弈论问题，可能涉及到动态规划...
oj软件课设（C语言版本代码）
01-18
在C语言中，可以使用队列、栈等数据结构来模拟游戏状态，通过深度优先搜索（DFS）或广度优先搜索（BFS）来检测是否存在死锁。 4. **大数相加**：在C语言中，标准库并不直接支持大整数操作。处理大数相加可能需要...
C语言描述数据结构 —— 栈和队列OJ题
weixin_59913110的博客
08-18 694
队列的特征是先进先出，如果我们入队的数据是 1、2、3、4、5 ，那么出队的顺序也是 1、2、3、4、5。而栈的特征是先进后出，即我们入栈的数据是 1、2、3、4、5，那么出栈的顺序是 5、4、3、2、1。对于栈和队列，C 语言的库中并没有这两个数据结构，但在 C++ 的库中是可以直接使用这两种数据结构的。这里的题目要求是用两个栈实现队列，那么肯定是要涉及倒数据的。我们先不关注题目的要求，就单单循环队列而言，我们先选择合适的数据结构。我们拿出我们使用链表实现队列的代码，并将它复制到我们的题目上面去。...
【LeetCode之栈和队列】：关于栈和队列经典的OJ题（用C语言实现，附图详解）
平凡的指针的博客
11-04 611
LeetCode题目1、括号匹配问题2、用队列实现栈3、用栈实现队列4、设计循环队列 1、括号匹配问题 LeetCode链接： 【20. 有效的括号】 这道题就是经典的利用栈解决问题的例子；思路如下： 遍历一遍字符串，如果遇倒左括号就入栈，如果遇倒右括号取栈顶的元素进行匹配并出栈顶的元素，如果相匹配就继续，不匹配就返回false。 但是要注意这样只能检验出左右括号相等的情况下才可以，如果左右括号不相等呢？ 如果左括号多于右括号，并且遍历结束后它们都是匹配的，这种情况并不是完全匹配的，因为栈里还有元素剩余
数据结构：栈
qq_55996124的博客
08-03 516
栈(Stack) 1. 概念 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作 进行数据插入和删除操作的一端称为栈顶，另一端称为栈底 栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶 出栈：栈的删除操作叫做出栈。出数据在栈顶 栈的常用方法： 方法 解释 E push(E item) 压栈 E pop() 出栈 E peek() 查看栈顶元素 ..
C语言【数据结构】栈和队列【OJ题（C++）、选择题】
冰果滴的博客
06-12 2183
目录一.OJ题1.225. 用队列实现栈2.232. 用栈实现队列3.622. 设计循环队列4.20. 有效的括号二.选择题1.下列关于栈的叙述正确的是（B）2.一个栈的入栈序列为ABCDE，则不可能的出栈序列为（D）3.链栈与顺序栈相比，比较明显的优点是（C）4.下列关于用栈实现队列的说法中错误的是（B）5.用无头单链表存储队列，其头指针指向队头结点，尾指针指向队尾结点，则在进行出队操作时（C）6.以下不是队列的基本运算的是（B）7.下面关于栈和队列的说法中错误的是（AB）8.下列关于顺序结构实现循环队列
【C语言】浅_刷 —— 栈 - 队列 OJ题，看了就会~（详解版）
上上谦. 的博客
04-04 1682
有了上面队列的结构，再加上之前实现的栈的结构，我们来做几道OJ练习来加强对知的理解。
华农C语言程序设计OJ代码
03-11
【华农C语言程序设计OJ代码】是一个与计算机编程相关的资源集合，主要涉及C语言这一编程语言在解决在线评测（Online Judge，简称OJ）系统中的问题。OJ是用于测试和练习编程技能的平台，它允许程序员提交源代码，并在...
湖南理工oj题解（学习用）-共230道题
12-21
【标题】：“湖南理工oj题解（学习用）-共230道题”揭示了这是一个针对湖南理工大学在线编程竞赛平台（Online Judge，简称OJ）的题解集合，包含了230个不同题目。这类资源通常由参赛者或者经验丰富的程序员整理，...
ZZULIOJ部分答案（C语言免费下载）.7z
10-20
6. **数据结构应用**：C语言中的数组、链表、栈、队列、树、图等数据结构可能会在代码中体现，学习者可以通过代码了解这些数据结构的实际应用场景。 7. **文件操作**：如果代码涉及读写文件，那么会涵盖C语言的文件...
C/C++进阶 （8）哈希表（STL）
敲代码嘞~的博客
07-24 857
个人主页：专题分栏：本文着重于模拟实现哈希表，并非是哈希表的使用。实现的哈希表的底层用的是线性探测法，并非是哈希桶。
嵌入式初学-C语言-前言
MaBaB的博客
07-24 1071
原码就是符号位加上真值的绝对值，即用第一位表示符号，其余位表示值。比如：如果是8位二进制：[+1]原= 0000 0001[-1]原= 1000 0001第一位是符号位，因为第一位是符号位，所以8位二进制数的取值范围就是：（即第一位不表示值，只表示正负。[1111 1111 , 0111 1111] 即 [-127 , 127]原码是人脑最容易理解和计算的表示方式。
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 208
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
c语言（7.23）
fhgfyrsg的博客
07-23 477
【代码】c语言（7.23）
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 781
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
数据结构之判断完全二叉树详解与示例（C，C++）
qq_35320456的博客
07-23 402
通过上述C和C++的实现示例，我们可以看到判断一个二叉树是否为完全二叉树的基本方法是使用层序遍历。在遍历过程中，我们通过设置一个标记来区分节点是否应该为叶子节点，从而判断二叉树是否满足完全二叉树的条件。这种方法的时间复杂度为O(n)，其中n是二叉树中节点的数量，因为每个节点最多只会被访问一次。在实际应用中，完全二叉树由于其特殊的结构，常用于堆的实现，因为它可以在数组中有效地表示，同时保持堆的操作效率。理解并掌握判断完全二叉树的方法，对于深入理解二叉树结构和相关算法有重要意义。
数据结构（特殊二叉树-平衡二叉树）
weixin_65029285的博客
07-23 953
待删除节点左右子树非空，则根据左右子树的高度，选择高的一边子树，如果是左子树高，选择左子树中的最大节点赋值给待删除节点，然后再左子树中继续删除该最大节点，相当于继续处理情况1或情况2；由于节点的位置要受到相互之间值的影响，并且在往平衡二叉树中添加节点或者删除节点前，二叉树本身是平衡的，所以只可能在最后操作的节点附近不满足平衡条件，因此需要在该过程中对该节点进行判断并调整。如果一个搜索二叉树呈现或接近单支状，它的查找效率很低，很接近链表，因此如果能让它平衡时，查找效率最高。待删除的节点是叶子节点，直接删除。
数据结构——单链表OJ题（下）
最新发布
2301_81888634的博客
07-25 609
链表既然包括单链表，就还有其他种类啦~敬请期待“双向链表”~
【数据结构】AVL树(平衡二叉搜索树)
weixin_69380220的博客
07-24 1106
AVL树的相关操作
C语言孪生素数oj题
05-30
下面是一道关于C语言中孪生素数的OJ题目： 题目描述： 输入一个正整数n，求出n以内的所有孪生素数（若存在）。输出格式为每个孪生素数对占一行，数字之间用一个空格隔开。如果不存在孪生素数，则输出"NO"。 输入...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值