【刷题专栏—突破思维】栈和队列

最新推荐文章于 2024-07-23 12:24:57 发布
最新推荐文章于 2024-07-23 12:24:57 发布
阅读量938 收藏 31
点赞数 38
分类专栏： 【刷题专栏—突破思维】 文章标签： 数据结构 c语言 算法 栈 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73551991/article/details/135353057
版权

在这里插入图片描述

前言：
本篇博客讲解有关栈及队列的习题：有效的括号、用队列实现栈、用栈实现队列、设计循环队列。

文章目录

1. 有效的括号

题目链接：Leetcode 20. 有效的括号

题目介绍
给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
1.左括号必须用相同类型的右括号闭合。
2.左括号必须以正确的顺序闭合。
3.每个右括号都有一个对应的相同类型的左括号。
示例 1：
输入：s = “()”
输出：true
示例 2：
输入：s = “()[]{}”
输出：true
示例 3：
输入：s = “(]”
输出：false

这是一个典型的括号匹配问题，可以使用栈来解决。基本思路如下：

  1. 遍历字符串，对于每个字符：

    • 如果是左括号（‘(’，‘{’，‘[’），将其压入栈。
    • 如果是右括号（‘)’，‘}’，‘]’），则判断栈是否为空。
      • 如果栈为空，说明没有匹配的左括号，返回 false。
      • 如果栈不为空，弹出栈顶元素，并判断是否和当前右括号匹配。
        • 如果匹配，继续遍历下一个字符。
        • 如果不匹配，返回 false。

  2. 遍历完字符串后，检查栈是否为空。

    • 如果栈为空，说明所有括号都匹配，返回 true。
    • 如果栈不为空，说明有左括号没有匹配，返回 false。

代码实现：

// 定义栈元素的数据类型
typedef int STDataType;

// 定义栈结构体
typedef struct Stack {
    STDataType* a;   // 存储栈元素的数组
    int top;         // 标识栈顶
    int capacity;    // 容量
} ST;

// 初始化栈
void StackInit(ST* pst) {
    assert(pst);
    
    pst->a = NULL;
    pst->capacity = 0;
    pst->top = 0; // 指向栈顶下一个元素
}

// 销毁栈
void StackDestroy(ST* pst) {
    assert(pst);

    free(pst->a);
}

// 入栈
void StackPush(ST* pst, STDataType x) {
    assert(pst);

    // 如果栈满，进行动态扩容
    if (pst->top == pst->capacity) {
        int newcapacity = pst->capacity == 0 ? 4 : 2 * pst->capacity;
        STDataType* temp = realloc(pst->a, sizeof(STDataType) * newcapacity);
        if (temp == NULL) {
            perror("realloc fail");
            return;
        }

        pst->a = temp;
        pst->capacity = newcapacity;
    }

    pst->a[pst->top] = x;
    pst->top++;
}

// 出栈
void StackPop(ST* pst) {
    assert(pst);
    // 栈不为空
    assert(pst->top > 0);

    pst->top--;
}

// 获取栈顶元素
STDataType StackTop(ST* pst) {
    assert(pst);
    // 栈不为空
    assert(pst->top > 0);

    return pst->a[pst->top - 1];
}

// 判断栈是否为空
bool StackEmpty(ST* pst) {
    assert(pst);

    return pst->top == 0;
}

// 判断给定字符串是否是有效的括号组合
bool isValid(char* s) {
    ST st;
    StackInit(&st);

    // 遍历字符串
    while (*s) {
        if (*s == '[' || *s == '(' || *s == '{') {
            // 左括号入栈
            StackPush(&st, *s);
        } else {
            // 右括号处理
            // 如果栈为空，说明右括号多于左括号，返回 false
            if (StackEmpty(&st)) {
                StackDestroy(&st);
                return false;
            }

            char top = StackTop(&st);
            StackPop(&st);

            // 判断右括号和栈顶左括号是否匹配
            if ((*s == ']' && top != '[') ||
                (*s == ')' && top != '(') ||
                (*s == '}' && top != '{')) {
                StackDestroy(&st);
                return false;
            }
        }
        ++s;
    }

    // 栈为空，说明左括号多于右括号，返回 true
    bool ret = StackEmpty(&st);
    StackDestroy(&st);

    return ret;
}

2. 用队列实现栈

题目链接：225. 用队列实现栈

题目描述：
请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。
实现 MyStack 类：
1.void push(int x) 将元素 x 压入栈顶。
2.int pop() 移除并返回栈顶元素。
3.int top() 返回栈顶元素。
4.boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。
注意：
你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。

两个队列之间进行元素的转移，以模拟栈的后进先出（LIFO）特性。基本思路：

  1. 使用两个队列，分别称为queue1和queue2。

  2. 当需要push一个元素时，将其加入非空的队列（假设初始时选择queue1）。

  3. 当需要pop一个元素时，将非空队列的前n-1个元素出队并入队到另一个空队列，然后将剩余的最后一个元素出队（即模拟栈的pop操作）。

  4. 将队列互换，使得新的非空队列成为主队列。

    在这里插入图片描述
    代码实现：

// 定义队列中元素的数据类型
typedef int QDataType;

// 节点结构体，表示队列中的每个元素
typedef struct QueueNode {
    QDataType val;           // 元素的值
    struct QueueNode* next;  // 指向下一个节点的指针
} QNode;

// 队列结构体，包含队头、队尾和元素数量信息
typedef struct Queue {
    QNode* phead;  // 队头节点
    QNode* ptail;  // 队尾节点
    int size;      // 元素长度
} Queue;

// 初始化队列，设置队头、队尾为NULL，元素数量为0
void QueueInit(Queue* pq) {
    assert(pq);
    pq->phead = pq->ptail = NULL;
    pq->size = 0;
}

// 销毁队列，释放队列中每个节点的内存
void QueueDestroy(Queue* pq) {
    assert(pq);

    QNode* cur = pq->phead;
    while (cur) {
        QNode* next = cur->next;
        free(cur);
        cur = next;
    }
    pq->phead = pq->ptail = NULL;
    pq->size = 0;
}

// 入队操作，将元素加入队尾
void QueuePush(Queue* pq, QDataType x) {
    assert(pq);

    // 创建新节点
    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    if (newnode == NULL) {
        perror("malloc fail");
        return;
    }

    // 设置节点值和指针
    newnode->val = x;
    newnode->next = NULL;

    // 判断队列是否为空，如果是，将队头和队尾都设置为新节点
    if (pq->ptail == NULL) {
        pq->ptail = pq->phead = newnode;
    } else {
        // 否则，将新节点连接到队尾，并更新队尾指针
        pq->ptail->next = newnode;
        pq->ptail = newnode;
    }

    // 更新元素数量
    pq->size++;
}

// 出队操作，删除队头元素
void QueuePop(Queue* pq) {
    assert(pq->phead);
    assert(pq);

    // 记录需要删除的节点
    QNode* del = pq->phead;
    // 更新队头指针
    pq->phead = pq->phead->next;
    // 释放节点内存
    free(del);
    del = NULL;

    // 如果队头为空，表示队列已空，更新队尾指针
    if (pq->phead == NULL)
        pq->ptail = NULL;

    // 更新元素数量
    pq->size--;
}

// 获取队头元素的值
QDataType QueueFront(Queue* pq) {
    assert(pq);
    assert(pq->phead);

    return pq->phead->val;
}

// 获取队尾元素的值
QDataType QueueBack(Queue* pq) {
    assert(pq);
    assert(pq->ptail);

    return pq->ptail->val;
}

// 判断队列是否为空
bool QueueEmpty(Queue* pq) {
    assert(pq);

    return pq->phead == NULL;
}

// 获取队列的元素数量
int QueueSize(Queue* pq) {
    assert(pq);

    return pq->size;
}



// 定义MyStack结构体，包含两个队列
typedef struct {
    Queue q1;
    Queue q2;
} MyStack;

// 创建并初始化MyStack结构体，内部调用QueueInit初始化两个队列
MyStack* myStackCreate() {
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&pst->q1);
    QueueInit(&pst->q2);

    return pst;
}

// 入栈操作，将元素加入非空队列
void myStackPush(MyStack* obj, int x) {
    if (!QueueEmpty(&obj->q1)) {
        QueuePush(&obj->q1, x);
    } else {
        QueuePush(&obj->q2, x);
    }
}

// 出栈操作，模拟栈的pop操作
int myStackPop(MyStack* obj) {
    // 选择非空队列为需要操作的队列，将元素转移到另一队列，直到只剩一个元素
    Queue* emptyq = &obj->q1;
    Queue* nonemptyq = &obj->q2;
    if (!QueueEmpty(&obj->q1)) {
        emptyq = &obj->q2;
        nonemptyq = &obj->q1;
    }

    while (QueueSize(nonemptyq) > 1) {
        QueuePush(emptyq, QueueFront(nonemptyq));
        QueuePop(nonemptyq);
    }

    // 获取并删除最后一个元素，模拟栈的pop操作
    int top = QueueFront(nonemptyq);
    QueuePop(nonemptyq);
    return top;
}

// 获取栈顶元素的值
int myStackTop(MyStack* obj) {
    if (!QueueEmpty(&obj->q1)) {
        return QueueBack(&obj->q1);
    } else {
        return QueueBack(&obj->q2);
    }
}

// 判断栈是否为空
bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

// 释放MyStack结构体和两个队列的内存
void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);

    free(obj);
}

3. 用栈是实现队列

题目链接：Leetcode 232.用栈实现队列

题目描述：
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：
实现 MyQueue 类：
1.void push(int x) 将元素 x 推到队列的末尾
2.int pop() 从队列的开头移除并返回元素
3.int peek() 返回队列开头的元素
4.boolean empty() 如果队列为空，返回 true ；否则，返回 false

用两个栈来实现队列的基本思路：

  1. 两个栈： 使用两个栈，一个用于入队（push操作），另一个用于出队（pop操作）。

  2. 入队操作： 将元素压入入队栈中。这样，最新的元素会始终位于栈顶，而最早加入的元素则位于栈底。

  3. 出队操作： 如果出队栈不为空，直接从出队栈弹出元素；否则，将入队栈的元素逐个弹出并压入出队栈，然后从出队栈弹出元素。这确保了队列的先进先出特性。
    在这里插入图片描述
    代码实现：

typedef int STDataType;

typedef struct Stack {
    STDataType* a;   // 栈数组
    int top;         // 标识栈顶
    int capacity;    // 容量
} ST;

// 栈的初始化
void StackInit(ST* pst) {
    assert(pst);
    pst->a = NULL;
    pst->capacity = 0;
    pst->top = 0;  // 指向栈顶下一个元素
}

// 栈的销毁
void StackDestroy(ST* pst) {
    assert(pst);
    free(pst->a);
}

// 入栈操作
void StackPush(ST* pst, STDataType x) {
    assert(pst);

    if (pst->top == pst->capacity) {
        int newcapacity = pst->capacity == 0 ? 4 : 2 * pst->capacity;
        STDataType* temp = realloc(pst->a, sizeof(STDataType) * newcapacity);
        if (temp == NULL) {
            perror("realloc fail");
            return;
        }

        pst->a = temp;
        pst->capacity = newcapacity;
    }

    pst->a[pst->top] = x;
    pst->top++;
}

// 出栈操作
void StackPop(ST* pst) {
    assert(pst);
    // 不为空
    assert(pst->top > 0);

    pst->top--;
}

// 获取栈顶元素
STDataType StackTop(ST* pst) {
    assert(pst);
    // 不为空
    assert(pst->top > 0);

    return pst->a[pst->top - 1];
}

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

// 获取栈的大小
int StackSize(ST* pst) {
    assert(pst);
    return pst->top;
}

// 队列结构
typedef struct {
    ST pushst;  // 入队栈
    ST popst;   // 出队栈
} MyQueue;

// 创建一个新的队列
MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    if (obj != NULL) {
        StackInit(&obj->pushst);
        StackInit(&obj->popst);
    }

    return obj;
}

// 将元素入队
void myQueuePush(MyQueue* obj, int x) {
    StackPush(&obj->pushst, x);
}

// 查看队头元素
int myQueuePeek(MyQueue* obj) {
    // popst为空，StackEmpty(&obj->popst)为真
    // popst不为空，直接执行return StackPop(&obj->popst);
    if (StackEmpty(&obj->popst)) {
        // pushst若不为空，将pushst中数据推入popst中
        while (!StackEmpty(&obj->pushst)) {
            StackPush(&obj->popst, StackTop(&obj->pushst));
            StackPop(&obj->pushst);
        }
    }
    return StackTop(&obj->popst);
}

// 出队操作
int myQueuePop(MyQueue* obj) {
    STDataType front = myQueuePeek(obj);
    StackPop(&obj->popst);

    return front;
}

// 判断队列是否为空
bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->pushst) && StackEmpty(&obj->popst);
}

// 释放队列内存
void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->pushst);
    StackDestroy(&obj->popst);
    free(obj);
}

4. 设计循环队列

题目链接：Leetcode 622. 设计循环队列

题目描述：
设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。
你的实现应该支持如下操作：
1.MyCircularQueue(k): 构造器，设置队列长度为 k 。
2.Front: 从队首获取元素。如果队列为空，返回 -1 。
3.Rear: 获取队尾元素。如果队列为空，返回 -1 。
4.enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
5.deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
6.isEmpty(): 检查循环队列是否为空。
7.isFull(): 检查循环队列是否已满。
示例：
MyCircularQueue circularQueue = new MyCircularQueue(3); // 设置长度为 3
circularQueue.enQueue(1); // 返回 true
circularQueue.enQueue(2); // 返回 true
circularQueue.enQueue(3); // 返回 true
circularQueue.enQueue(4); // 返回 false，队列已满
circularQueue.Rear(); // 返回 3
circularQueue.isFull(); // 返回 true
circularQueue.deQueue(); // 返回 true
circularQueue.enQueue(4); // 返回 true
circularQueue.Rear(); // 返回 4

基本思路：
在实现循环队列时，我们选择数组来实现。相对于循环链表，数组实现循环队列更加容易访问数据，且在空间上连续。
在这里插入图片描述
代码实现：

// 定义循环队列的结构体
typedef struct {
    int* a;     // 用于存储队列元素的数组
    int front;   // 指向队列头部
    int back;    // 指向队列尾部的下一位
    int k;       // 队列的容量
} MyCircularQueue;

// 创建循环队列并初始化
MyCircularQueue* myCircularQueueCreate(int k) {
    // 分配内存并初始化结构体成员
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a = (int*)malloc(sizeof(int) * (k + 1)); // 长度为 k+1，避免判满和判空时的歧义
    obj->front = 0;
    obj->back = 0;
    obj->k = k;

    return obj;
}

// 判断循环队列是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->back == obj->front;
}

// 获取循环队列尾部元素
int myCircularQueueRear(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj)) {
        return -1; // 队列为空，返回特定值表示错误
    } else {
        return obj->a[(obj->back + obj->k) % (obj->k + 1)]; // 利用取模操作实现循环
    }
}

// 判断循环队列是否已满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->back + 1) % (obj->k + 1) == obj->front; // 利用取模操作实现循环
}

// 入队操作
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (myCircularQueueIsFull(obj)) {
        return false; // 队列已满，无法入队
    }
    obj->a[obj->back] = value; // 将元素存储在队尾
    ++obj->back; // 尾指针后移
    obj->back %= (obj->k + 1); // 利用取模操作实现循环
    return true;
}

// 出队操作
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj)) {
        return false; // 队列为空，无法出队
    }
    ++obj->front; // 头指针后移
    obj->front %= (obj->k + 1); // 利用取模操作实现循环
    return true;
}

// 获取循环队列头部元素
int myCircularQueueFront(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj)) {
        return -1; // 队列为空，返回特定值表示错误
    }
    return obj->a[obj->front]; // 返回队头元素
}

// 释放循环队列的内存
void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}

在这里插入图片描述
如果你喜欢这篇文章，点赞👍+评论+关注⭐️哦！
欢迎大家提出疑问，以及不同的见解。

拉普达的城
关注
  • 38
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 15
    评论
专栏目录
2024华为OD统一考试题库清单（持续收录中）以及考点说明
学Java，找哪吒
07-14 3万+
每一题都有详细的答题思路、详细的代码注释、样例测试，发现新题目，随时更新，全天CSDN在线答疑。
LabVIEW专栏七、队列
04-25
多维队列允许存储和处理复杂的数据结构，而优先级队列则允许根据特定条件优先处理某些元素。 理解并熟练掌握LabVIEW中的队列是提高程序效率和扩展功能的关键。在设计复杂的测试系统或自动化流程时，队列可以作为一...
【2024年开年纪】华为OD统一考试题库清单（已收录355题），又快又全的OD题库大整理
热门推荐
学Java，找哪吒
12-04 1万+
华为机考的分数是按照测试用例通过的比例来确定的，比如第一题满分100，如果你提交代码后显示测试用例通过率为80%，那么这道题你就只能得80分，所以其实成绩你在考试的时候就心知肚明了！，每一题都有详细的答题思路、详细的代码注释、样例测试，订阅后，专栏内的文章都可看，可加入华为OD刷题群（私信即可），发现新题目，随时更新，全天CSDN在线答疑。很多考过的小伙伴，总结了宝贵的经验，多刷题，先易后难，前期积累自信，后期逐一突破，效果最佳。下面是我花了一天时间整理的 算法和数据结构的知识结构，大家可以看看。
2024最新D卷 华为OD统一考试题库清单（按算法分类），如果你时间紧迫，就按这个刷
学Java，找哪吒
06-15 2357
D卷新题正在疯狂更新中...
华为OD机试（含D卷）真题2024 算法分类版，如果距离机考时间不多了，就看这个吧，稳稳的
学Java，找哪吒
06-24 921
目前正在考的是D卷，按照华为OD往常的操作，D卷题目是由往年真题（C卷/A卷/B卷）+全新题目组成，也就是说D卷还会考到C卷、A卷和B卷的题目的，比例大概是1道新题、2道旧题的样子。，每一题都有详细的答题思路、详细的代码注释、样例测试，订阅后，专栏内的文章都可看，可加入华为OD刷题群（私信即可），发现新题目，随时更新，全天CSDN在线答疑。很多考过的小伙伴，总结了宝贵的经验，多刷题，先易后难，前期积累自信，后期逐一突破，效果最佳。下面是我花了一天时间整理的 算法和数据结构的知识结构，大家可以看看。
【2023年冬季】华为OD统一考试（B卷）题库清单（已收录345题），又快又全的 B 卷题库大整理
学Java，找哪吒
10-29 3096
华为机考的分数是按照测试用例通过的比例来确定的，比如第一题满分100，如果你提交代码后显示测试用例通过率为80%，那么这道题你就只能得80分，所以其实成绩你在考试的时候就心知肚明了！，每一题都有详细的答题思路、详细的代码注释、样例测试，订阅后，专栏内的文章都可看，可加入华为OD刷题群（私信即可），发现新题目，随时更新，全天CSDN在线答疑。很多考过的小伙伴，总结了宝贵的经验，多刷题，先易后难，前期积累自信，后期逐一突破，效果最佳。下面是我花了一天时间整理的 算法和数据结构的知识结构，大家可以看看。
2023华为OD统一考试（B卷）题库清单（持续收录中）以及考点说明
学Java，找哪吒
10-22 2536
华为机考的分数是按照测试用例通过的比例来确定的，比如第一题满分100，如果你提交代码后显示测试用例通过率为80%，那么这道题你就只能得80分，所以其实成绩你在考试的时候就心知肚明了！，每一题都有详细的答题思路、详细的代码注释、样例测试，订阅后，专栏内的文章都可看，可加入华为OD刷题群（私信即可），发现新题目，随时更新，全天CSDN在线答疑。很多考过的小伙伴，总结了宝贵的经验，多刷题，先易后难，前期积累自信，后期逐一突破，效果最佳。下面是我花了一天时间整理的 算法和数据结构的知识结构，大家可以看看。
阿里、力扣、政采云的15位专家分享前端面试与招聘视角
三钻 - 之前端到全栈之路
06-04 5063
本次大会一共有15位来源于各大厂公司的高级前端工程师和技术专家，每个讲师都给我带来了精彩绝伦的知识与干货。 这次大会的内容不只给我的技术生涯中带来了冲劲，让我认知到自己还有很多的不足与未知。同时也让我认知到了优秀的技术人才与团队的能力模型，讲师们有说到他们的经历和三观，引发了我对自己“保安式”的灵魂拷问。
少儿C++编程如何入门
青少年趣味编程
09-16 7088
少儿C++编程如何入门
如何搞定不同公司的算法面试？（早早聊分享文字版）
azl397985856的专栏
05-07 601
前几天西法参加了《前端早早聊》第 24 界的分享。我的分享主题是《如何搞定不同公司的算法面试？》 这是这次分享的文字版，供大家查看。如果大家需要分享的原版 ppt，也可以到我的公众号《脑洞...
uniapp专栏思维导图
03-03
uniapp专栏思维导图，想要了解更多还需要去看官网：https://uniapp.dcloud.net.cn/component/view.html#
我的django专栏029阶段Celery消息队列的配置和实现的源码
08-04
在本篇内容中，我们将深入探讨Django框架与Celery消息队列的集成与实现，这是"我的django专栏029阶段"的重点话题。Celery是一个分布式任务队列，广泛用于处理异步任务，提高Web应用的响应速度和可扩展性。在Django...
码猿技术专栏思维导图.zip
08-18
"码猿技术专栏思维导图.zip"这个压缩包文件很可能包含了一系列与Java相关的技术主题和学习路径的思维导图，旨在帮助Java开发者或学习者系统地理解和掌握这门语言及其相关框架和技术。 思维导图作为一种有效的学习...
JavaWeb每日总结思维导图
05-22
选择下载该内容的大多应该是想要从事Java后端开发的学习者，本人更新的“软件设计”专栏有助于大家理解常见开源项目的设计，练就扎实内功，建议从头阅读，相信会对你有所启发。宝剑锋从磨砺出，梅花香自苦寒来。练就...
数据结构——二叉树性质
最新发布
鲸落博客
07-23 286
这个性质很好记忆，观察一下图6-5-5。第一层是根结点，只有一个，所以2^(1-1)=2^0=1。第二层有两个，2^(2-1)=2=2。第三层有四个，2^(3-1)=2^2=4。第四层有八个，2^(4-1)=2^3=8。通过数据归纳法的论证，可以很容易得出在二叉树的第i层上至多有2^(i-1)个结点(i≥1)的结论。
数据结构-＞线性结构-＞顺序存储-＞静态链表
qq_68495605的博客
07-20 214
【代码】数据结构-＞线性结构-＞顺序存储-＞静态链表。
数据结构(5.2_3)——二叉树的存储结构
m0_65240792的博客
07-19 312
1%29%5D1。
《数据结构-用C语言描述第三版》课后答案 第三章
m0_62469100的博客
07-19 1072
b[2] = 2;b[n+1] = 2;i>=2;i--){若调用 bin ( A ,5)，给出 A 数组中第1个到第6个数组元素的值。答：数组中的值为每次递归将后面一个元素赋值为2，然后前面的元素分别加等其前面的元素。
csdn中fpga和matlab博主的专栏值得买吗
10-11
对于是否购买CSDN中FPGA和Matlab博主的专栏，需要综合考虑几个方面。 首先，需要考虑FPGA和Matlab在你的学习或工作中的需求程度。如果你对FPGA和Matlab有浓厚的兴趣，并且需要深入学习或应用它们，那么购买这些专栏...
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值