【数据结构】3道经典面试题带你玩转栈与队列

最新推荐文章于 2024-05-07 10:18:51 发布
最新推荐文章于 2024-05-07 10:18:51 发布
阅读量885 收藏 22
点赞数 15
分类专栏： 刷题 数据结构 文章标签： 数据结构 算法 面试 刷题 栈 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_72357342/article/details/134627363
版权

🦄个人主页:修修修也

🎏所属专栏:数据结构

⚙️操作环境:Visual Studio 2022

目录

一.有效的括号

二.用栈实现队列

三.用队列实现栈

结语

一.有效的括号

题目链接

20. 有效的括号icon-default.png?t=N7T8https://leetcode.cn/problems/valid-parentheses/

题目描述

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

  1. 左括号必须用相同类型的右括号闭合。
  2. 左括号必须以正确的顺序闭合。
  3. 每个右括号都有一个对应的相同类型的左括号。

题目详情

解题思路

本题解题思路为:

  • 创建一个栈
  • 遍历字符串s,遇到左括号则将其入栈
  • 遇到右括号则取栈顶元素和它匹配
  • 匹配成功则将栈顶元素出栈继续遍历,失败则返回false
  • 直到遍历完字符串s,栈中元素也都恰好匹配完毕则返回true

细节问题:动态开辟的内存需要换给系统,在程序设置好几个return点的情况下特别要保证每个return前都应有Destroy的操作.

解题代码

综上,本题解题代码如下:

typedef char STDataType;

typedef struct Stack
{
	STDataType*arr;
	int top;
	int capacity;
}ST;

bool STEmpty(ST* ps)//判空,为空则真
{
	assert(ps);
	return ps->top==0;
}

void STInit(ST* ps)
{
	assert(ps);

	ps->arr = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->arr == NULL)
	{
		perror("malloc fail::\n");
		return;
	}
	ps->capacity = 4;
	ps->top = 0;   //top表示栈顶元素的下一个
	               //top指向栈顶元素的话,top给-1
}

void STDestroy(ST* ps)
{
	assert(ps);
	free(ps->arr);
	ps->arr = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

void STPush(ST* ps, STDataType x)
{
	assert(ps);

	if (ps->top == ps->capacity)//扩容
	{
		STDataType* tmp = (STDataType*)realloc(ps->arr, sizeof(STDataType) * ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("realloc fail::\n");
			return;
		}
		ps->arr = tmp;
		ps->capacity *= 2;
	}
	ps->arr[ps->top] = x;
	ps->top++;
}

void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	ps->top--;
}

STDataType STTop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	return ps->arr[ps->top - 1];
}

bool isValid(char* s) 
{
    ST st;
    STInit(&st);
    char*cur=s;
   
    while(*cur!='\0')
    {
         //如果是左括号,入栈
        if(*cur=='{'||*cur=='['||*cur=='(')
        {
            STPush(&st,*cur);
        }
        //如果是右括号,和栈顶元素匹配,相同就出栈,不同就false
        else
        {
            if(STEmpty(&st))
            {
                STDestroy(&st);
                return false;
            }
            if(*cur==')'&&STTop(&st)=='(')
            {
                STPop(&st);
            }
            else if(*cur==']'&&STTop(&st)=='[')
            {
                STPop(&st);
            }
            else if(*cur=='}'&&STTop(&st)=='{')
            {
                STPop(&st);
            }
            else
            {
                STDestroy(&st);
                return false;
            }
        }
        cur++;
    }
    if(STEmpty(&st))
    {
         STDestroy(&st);
         return true;
    } 
    else
    {
         STDestroy(&st);
        return false;
    }
        
}

提交运行:

二.用栈实现队列

题目链接

232. 用栈实现队列icon-default.png?t=N7T8https://leetcode.cn/problems/implement-queue-using-stacks/

题目描述

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

  • void push(int x) 将元素 x 推到队列的末尾
  • int pop() 从队列的开头移除并返回元素
  • int peek() 返回队列开头的元素
  • boolean empty() 如果队列为空，返回 true ；否则，返回 false

说明：

  • 你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
  • 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

题目详情

解题思路

本题解题思路为:

  • 先定义栈的结构并完成其相关操作函数(即定义栈,实现栈)
  • 创建MyQueue结构体,其中包含两个栈(push栈和pop栈)
  • MyQueue入队入push栈即可.
  • MyQueue出队出pop栈顶的元素,如果pop栈为空,则先将push栈中的所有元素依次入pop栈后再出pop栈顶元素,图示如下:
  • MyQueue初始化,取队头元素,查空,销毁函数逻辑较简单,思路见下方解题代码注释.

解题代码

综上,本题解题代码如下:

//先创建两个栈及栈的相关操作,然后组合实现队列的效果
//定义栈:
typedef int STDataType;
typedef struct Stack
{
	STDataType*arr;
	int top;
	int capacity;
}ST;

void STInit(ST* ps);
void STDestroy(ST* ps);
void STPush(ST* ps, STDataType x);
void STPop(ST* ps);
int STSize(ST* ps);
bool STEmpty(ST* ps);//判空,为空则真
STDataType STTop(ST* ps);
//实现栈:
void STInit(ST* ps)
{
	assert(ps);
	ps->arr = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->arr == NULL)
	{
		perror("malloc fail::\n");
		return;
	}
	ps->capacity = 4;
	ps->top = 0;   //top表示栈顶元素的下一个
	               //top指向栈顶元素的话,top给-1
}

void STDestroy(ST* ps)
{
	assert(ps);
	free(ps->arr);
	ps->arr = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

void STPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)//扩容
	{
		STDataType* tmp = (STDataType*)realloc(ps->arr, sizeof(STDataType) * ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("realloc fail::\n");
			return;
		}
		ps->arr = tmp;
		ps->capacity *= 2;
	}
	ps->arr[ps->top] = x;
	ps->top++;
}

void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	ps->top--;
}

int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

bool STEmpty(ST* ps)//判空,为空则真
{
	assert(ps);
	return ps->top==0;
}

STDataType STTop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	return ps->arr[ps->top - 1];
}

//实现队列


typedef struct {
    ST pushst;
    ST popst;
} MyQueue;


MyQueue* myQueueCreate() //MyQueue结构体初始化,将两个栈分别初始化即可
{
    MyQueue *obj=(MyQueue*)malloc(sizeof(MyQueue));
    if(obj==NULL)
    {
        perror("malloc fail::\n");
        return NULL;
    }
    STInit(&obj->pushst);
    STInit(&obj->popst);
    return obj;
}

void myQueuePush(MyQueue* obj, int x) //MyQueue进栈,进栈元素进pushst栈即可
{
    STPush(&obj->pushst , x);
}

int myQueuePop(MyQueue* obj)//MyQueue出栈
{
    //如果pop栈不为空就出pop栈顶的元素
    if(!STEmpty(&obj->popst))
    {
        int x=STTop(&obj->popst);
        STPop(&obj->popst);
        return x; 
    }
    else//如果pop栈为空,就先倒Push栈的元素过来,再出pop栈顶的元素
    {
        while(!STEmpty(&obj->pushst))//倒push栈必须将现有的元素全部倒过来
        {
            int x=STTop(&obj->pushst);
            STPush(&obj->popst , x);
            STPop(&obj->pushst);
        }
        //倒完出pop栈顶元素
        int x=STTop(&obj->popst);
        STPop(&obj->popst);
        return x;
    }
}

int myQueuePeek(MyQueue* obj)//MyQueue取栈顶元素(逻辑比出栈少一个出) 
{
    if(!STEmpty(&obj->popst))
    {
        return STTop(&obj->popst);
    }
    else//如果pop栈为空,就先倒Push的过来,再pop
    {
        while(!STEmpty(&obj->pushst))
        {
            int x=STTop(&obj->pushst);
            STPush(&obj->popst , x);
            STPop(&obj->pushst);
        }
        return STTop(&obj->popst);
    }
}

bool myQueueEmpty(MyQueue* obj)//MyQueue查空,push和pop栈都为空则MyQueue为空
 {
    return (STEmpty(&obj->pushst)&&STEmpty(&obj->popst));
}

void myQueueFree(MyQueue* obj) //MyQueue销毁,分别将push栈和pop栈销毁后把obj销毁即可
{
    STDestroy(&obj->pushst);
    STDestroy(&obj->popst);
    free(obj);
}

提交运行:

三.用队列实现栈

题目链接

225. 用队列实现栈icon-default.png?t=N7T8https://leetcode.cn/problems/implement-stack-using-queues/

题目描述

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

  • void push(int x) 将元素 x 压入栈顶。
  • int pop() 移除并返回栈顶元素。
  • int top() 返回栈顶元素。
  • boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：

  • 你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
  • 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

题目详情

解题思路

本题解题思路为:

  • 先定义队列的结构并完成其相关操作函数(即定义队列,实现队列)
  • 创建MyStack结构体,其中包含两个队列(q1队列和q2队列),结构图示如下:
  • 我们需要一直保持q1和q2中有一个空队列,以便可以模拟出栈.
  • MyStack入栈时入q1和q2中的非空栈,图示如下:
  • MyStack出栈时将q1和q2中的非空队的前n-1个元素全部入队到空队列中,然后将剩下的那个元素出栈,图示如下:
  • MyStack取栈顶元素相当于取非空队的队尾元素.
  • MyStack初始化,判空,销毁逻辑较为简单,思路见下方解题代码注释.

解题代码

//先自己创建两个队列,然后调用这两个队列完成栈的操作.

//定义队列
typedef int QDatatype;
typedef struct QueueNode//一个是结点结构
{
	struct QueueNode* next;
	QDatatype data;
}QNode;
typedef struct Queue//一个是队列整体结构
{
	QNode* head;
	QNode* tail;
	int size ;
}Que;
void QueueInit(Que* pq);
void QueueDestroy(Que* pq);
void QueuePush(Que* pq,QDatatype x);
void QueuePop(Que* pq);
int QueueSize(Que* pq);
bool QueueEmpty(Que* pq);
QDatatype QueueFront(Que* pq);
QDatatype QueueBack(Que* pq);

//实现队列操作
void QueueInit(Que* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
	pq->size = 0;
}
void QueueDestroy(Que* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;
}

void QueuePush(Que* pq, QDatatype x) //入队是尾插
{
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->head == NULL)//头插
	{
		assert(pq->tail == NULL);
		pq->head = pq->tail = newnode;
	}
	else//尾插
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
	pq->size++;
}

void QueuePop(Que* pq)//出队是头删
{
	assert(pq);
	assert(!QueueEmpty(pq));//assert为假会终止程序
	QNode* cur = pq;
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
	pq->size--;
}

int QueueSize(Que* pq)
{
	assert(pq);
	return pq->size;
}

bool QueueEmpty(Que* pq)//判空!为空返回真!
{
	assert(pq);
	return pq->size==0;
}

QDatatype QueueFront(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->head->data;
}

QDatatype QueueBack(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->data;
}

//实现栈
typedef struct 
{
    Que q1;
    Que q2;
} MyStack;

MyStack* myStackCreate() 
{
    MyStack*obj=(MyStack*)malloc(sizeof(MyStack));
    if(obj==NULL)
    {
        perror("malloc fail::\n");
        return NULL;
    }
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);
    return obj;
}

void myStackPush(MyStack* obj, int x) //入栈入非空队
{
    if(QueueEmpty(&obj->q1))//如果q1为空,入q2
    {
        QueuePush(&obj->q2,x);
    }
    else
    {
        QueuePush(&obj->q1,x);
    }

    //都为空走else,也可以
}

//出栈把非空队前n-1个元素全部插入空队,然后出非空队
int myStackPop(MyStack* obj) 
{
    if(QueueEmpty(&obj->q1))//如果q1为空,出q2的n-1元素到q1
    {
        int n=QueueSize(&obj->q2)-1;
        while(n--)//先出q2再入q1
        {
            int x=QueueFront(&obj->q2);
            QueuePush(&obj->q1,x);
            QueuePop(&obj->q2);
        }
        //q2的最后一个元素出函数
        int top=QueueFront(&obj->q2);
        QueuePop(&obj->q2);
        return top;
    }
    else//如果q2为空,出q1的n-1元素到q2
    {
        int n=QueueSize(&obj->q1)-1;
        while(n--)//先出q2再入q1
        {
            int x=QueueFront(&obj->q1);
            QueuePush(&obj->q2,x);
            QueuePop(&obj->q1);
        }
        //q2的最后一个元素出函数
        int top=QueueFront(&obj->q1);
        QueuePop(&obj->q1);
        return top;
    }
}

int myStackTop(MyStack* obj)//栈顶=队尾
{
    if(QueueEmpty(&obj->q1))//如果q1为空,返回q2队尾
    {
        return QueueBack(&obj->q2);
    }
    else
    {
        return QueueBack(&obj->q1);
    }
}

bool myStackEmpty(MyStack* obj) //q1&&q2为空才为空
{
    return (QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2));
}

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

提交运行:

结语

希望通过上面的题目能使大家对栈和队列这两个经典的数据结构的理解以及运用能够更上一层楼,欢迎大佬们留言或私信与我交流.学海漫浩浩,我亦苦作舟!关注我,大家一起学习,一起进步!

修修修也
关注
  • 15
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构：导论、栈与队列
01-20
导论 算法的特征：有穷性（finiteness），确定性（definiteness），输入，输出，有效性/可行性（effectiveness） O表示法表示的是当N->某一值或者无穷大时，斜率的变化。重要的是曲线的形状，而不是具体的曲线的值，因为曲线的值可以通过常数C来变化。 大O表示法：用一个常数倍的简单函数，包裹住T（N），由此来表示“上界” 大Ω\OmegaΩ表示法：下界 大Θ\ThetaΘ表示法：既是上界也是下界 小o表示法：严格上届（严格大于） 线性表 用链表表示的时候，一定要记住**添加判断：是否为最后一个节点？是否可能遇到NULL->某个域**！！！！！ 栈（Stack） LIF
数据结构栈和队列试题及答案
11-26
栈和队列考试题 复习 栈和队列考试题 复习栈和队列考试题 复习
数据结构-栈与队列
01-07
数据结构-栈与队列一、顺序栈1.顺序栈的定义2：入栈二、顺序队列1：顺序栈的定义2：入队3：出队三、链队列1：链队列的定义：2：入队3：出队 一、顺序栈 1.顺序栈的定义 #define MaxSize 64 /* const int MaxSize =64; */ typedef int datatype; typedef struct{ datatype data[MaxSize ]; int top; }seqstack 2：入栈 int Push ( seqstack *sstack, datatype x) { if (s
C++数据结构实验二：栈与队列的应用
03-31
1．熟练掌握栈和队列的基本运算。 2．掌握在两种存储结构上对栈和队列所施加的入栈、出栈、入队和出队的实现。 3.掌握栈和队列的逻辑结构特点、顺序存储结构、链式存储结构、顺序栈和链栈的结构体类型定义、循环队列和链队列的结构体类型定义、栈和队列在两种存储结构上的各种基本操作的实现算法。 4.将任意十进制数转换为三种进制数（二进制、八进制、十六进制）。 5.输入任意一串由括号（、）、[、]、{、}组成的括号序列，判断括号是否匹配。
ACM大牛带你玩转数据结构与算法-视频教程网盘链接提取码下载.txt
08-31
这是一门由ACM大牛主讲的数据结构与算法课程，通过学习该课程，你将掌握各种常用的数据结构和算法的实现原理和应用场景。课程内容丰富多样，包括数组、链表、栈、队列、树、图等数据结构，以及排序、查找、动态规划、贪心算法等常见算法。通过编程实践和题目练习，帮助你提高解决问题的能力和编程技巧，为你在竞赛和面试中脱颖而出提供有力支持。 视频大小：16.8G
玩转算法之面试-第六章（栈和队列）
古月哲亭
08-24 140
leetcode 20 此时栈顶的左括号和当前遍历的右括号匹配，故将左括号从栈顶pop出。 leetcode 150： leetcode 71
手把手教你如何玩转面试（数据结构知识）
Cs_hnu_scw的博客
04-11 4895
        本篇是讲解关于JavaWeb岗位面试方面的一些对于数据结构知识的整理，当然，不只是需要知道这个方面的内容，还需要掌握其他方面的知识，我都根据自己的经历来进行了整理，方便大家进行系统化的学习，只有多复习多研究，才能对技术有更好的掌握，才能拿到更好的offer。 下面是其他方面的知识点，欢迎大家进行浏览 Java基础：https://blog.csdn.net/Cs_hnu_scw...
【超全汇总】学习数据结构与算法，计算机基础知识，看这篇就够了
帅地
01-18 10万+
由于文章有点多，并且发的文章也不是一个系列一个系列发的，不过我的文章大部分都是围绕着 数据结构 + 算法 + 计算机网络 + 操作系统 + Linux + 数据库 这几个方面发的，为了方便大家阅读，我整理了一波。不过公众号可以说是不支持修改文章，因为我决定每两三个月就整理一次，会非常详细着按照类别整理出来哦，并且也给出了目录哦。大家记得多看看哦，好多文章都是面试中常问滴 文章目录一、经验/经历/所...
最新 运维面试2396道题 都掌握吊打面试官 offer到手
辅导自学转行
06-02 3万+
244. 在/home/work目录下，有10000个文件，你如何统计出里面含有yicha.cn的文件，并将包含有yicha.cn的文件发送到[email protected]。88. 将/home/stud1/wang目录做归档压缩，压缩后生成wang.tar.gz文件，并将此文件保存到/home目录下。247. 一台linux服务器，上面只运行apche，突然访问变的很慢，你是如何分析问题所在的？60. 在一个系统中，cpu正常，内存使用非常大，系统各项服务都很慢，你会怎么判断和解决。
Java经典面试题 带答案（三）
weixin_43474701的博客
07-27 8839
Java经典面试题 带答案（三） 1、面向对象的特征有哪些方面？ 答：面向对象的特征主要有以下几个方面： 抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象 两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。 继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类 （超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有 了一定的延续性，同时继承也是封装程序中可变因素的重要手段（如果不能理解请阅读阎 宏博士的《Java
万字长文丨7个经典问题，助你拿下Java面试（建议收藏）_你需要存储元素到某种数据结构中,而且要确保元素在自然队列中没有重复(3)
2301_77110912的博客
05-03 678
因此，要想玩转大数据，或多或少需要对Java有所了解。对于一个初级岗求职者或者应届毕业生来说，公司除了对项目经验有所问询之外，最好的考察办法就是检查基本功，包括编程风格，以及程序结构，的理解。因此面试之前，一定要对自己所掌握的基本概念知识较为熟悉，尤其是对各种细致的考点要加以重视。Java程序设计基本概念考察中，对类型转换和异常处理的考察最为常见，有以下原因：1、在Java程序中，不同的基本类型的值经常需要进行互相转换，实际工作中因为对它们的掌握不够熟练写出错误代码的情况经常发生。
linux c语言常见面试题及答案,Linux下C语言的几道经典面试题小结(分享)
weixin_30424427的博客
05-13 2056
Linux下C语言的几道经典面试题小结(分享)本篇文章整理了几道Linux下C语言的经典面试题，相信对大家更好的理解Linux下的C语言会有很大的帮助，欢迎大家探讨指正。1、如果在Linux下使用GCC编译器执行下列程序，输出结果是什么？答案如下：2、C语言程序不使用任何条件运算符，打印出十次"Hello"？答案如下：或是：3、如果在Linux下使用GCC编译器执行下列程序，输出结果是什么？答案如...
手把手教你如何玩转Java基础面试题
Cs_hnu_scw的博客
10-18 1万+
下面的这些题目，主要是根据自己的亲身经历以及在学习的过程中碰到比较典型的内容，所以把这些进行整理，方便于更多的人进行学习和交流。 内容有点多，可能你会很反感，但是，我相信，如果你能认真的看完我这些，当你回头再回想整个Java内容的时候，你就会清晰很多。因为，这是自己的学习经历，我相信有很多的人跟自己都一样，所以，给点信心，别怕多，这么多学习干货，为什么要回避呢？ 下面是其他方面...
Java面试题大全（2021版）
热门推荐
Java笔记
11-25 29万+
发现网上很多Java面试题都没有答案，所以花了很长时间搜集整理出来了这套Java面试题大全，希望对大家有帮助哈~ 本套Java面试题大全，全的不能再全，哈哈~ 一、Java基础知识面试题 1、Java概述 ①. 何为编程 编程就是让计算机为解决某个问题而使用某种程序设计语言编写程序代码，并最终得到结果的过程。 为了使计算机能够理解人的意图，人类就必须要将需解决的问题的思路、方法、和手段通过计算机能够理解的形式告诉计算机，使得计算机能够根据人的指令一步一步去工作，完成某种特定的任务。这种人和计算机
【C语言视角】数据结构之~二叉树
循环渐进学习编程，成长
05-01 1167
设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。第一层是根结点，只有一个，所以2(1-1）=20=1。终端结点数其实就是叶子结点数，而一棵二叉树，除了叶子结点外，剩下的就是度为1或2的结点数了，我们设n1为度是1的结点数。终端结点数其实就是叶子结点数，而一棵二叉树，除了叶子结点外，剩下的就是度为1或2的结点数了，我们设n1为度是1的结点数。
数据结构-线性表-应用题-2.2-3
最新发布
muse3159546973的博客
05-07 80
对长度为n的顺序表L,编写一个时间复杂度为O（n）,空间复杂度为O（1）的算法，该算法删除线性表中所有值为x的数据元素。遍历顺序表，用k记录顺序表中不等于x的元素个数，同时扫描时将不等于x的元素移动到下标k的位置。
《数据结构》C语言版 (清华严蔚敏考研版） 第二章 线性表知识梳理与总结
路漫漫其修远兮，吾将上下而求索。小手点一波关注进阶的李仙桎，我们一起携手进步，
04-28 1592
线性表是数据结构的一种，它是一组具有相同数据类型的数据元素的有限序列。在线性表中，除了第一个和最后一个数据元素之外，每个数据元素均只有一个直接前驱和一个直接后继。线性表的元素个数n（n≥0）定义为线性表的长度，当n=0时，称为空表。线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链表的形式存储线性表的抽象数据类型定义ADT List{数据对象:D={ai|aiEElemSet.i=1,2,…,n,n≥0} //任意数据元素的集合。
redis核心数据结构——跳表项目设计与实现（跳表结构插入数据、删除数据、展示数据）
qq_63149342的博客
05-01 506
另外就是每次创建新节点时需要随机分配层数，加上一开始用两个变量分别记录最大层数和当前层数，分配后该层数不能超过最大层数，且如果大于当前层数，需要将当前层数进行更新。向跳表中插入一对数据，如果跳表中已存在该键值对，则不做任何操作，返回 1，如果不存在该键值对，则将该键值对插入到跳表中，返回 0。此成员函数需要从跳表中删除键为 key 的节点。在跳表中查询键值为 key 的键值对，如果跳表中已存在该键值对，则返回 true，否则返回 false。参数说明： K key：要删除的元素的键，其中 K 是键的类型。
数据结构栈和队列课后习题头歌
10-18
根据提供的引用内容，我可以为您解答数据结构栈和队列课后习题的相关问题。 根据引用中的内容，我们可以知道栈和队列都是线性结构，栈是一种特殊的线性表，允许插入和删除运算的一端称为栈顶，不允许插入和删除运算...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

修修修也

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值