【基础数据结构】二叉树的遍历

已于 2024-01-18 12:59:07 修改
阅读量810 收藏 13
点赞数 24
分类专栏： 基础数据结构 文章标签： 数据结构 算法
于 2024-01-18 12:55:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62704693/article/details/135668925
版权

二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

示例 1：

输入：root = [1,null,2,3]
输出：[1,2,3]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

示例 4：

输入：root = [1,2]
输出：[1,2]

示例 5：

输入：root = [1,null,2]
输出：[1,2]

提示：

  • 树中节点数目在范围 [0, 100] 内
  • -100 <= Node.val <= 100

 官方题解（写的很详细）

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/binary-tree-preorder-traversal/solutions/461821/er-cha-shu-de-qian-xu-bian-li-by-leetcode-solution/编译环境Dev-cpp(C++)

#include <stdio.h>
#include <stdlib.h>

typedef struct TreeNode {
    int val;  // 节点值
    struct TreeNode* left;  // 左子树指针
    struct TreeNode* right;  // 右子树指针
} TreeNode;

// 前序遍历二叉树的函数
void preorderTraversalHelper(struct TreeNode* root, int* result, int* index) {
    if (root == NULL) {
        return;
    }

    // 访问当前节点
    result[(*index)++] = root->val;

    // 递归遍历左子树
    preorderTraversalHelper(root->left, result, index);

    // 递归遍历右子树
    preorderTraversalHelper(root->right, result, index);
}

int* preorderTraversal(struct TreeNode* root, int* returnSize) {
    // 计算二叉树节点个数
    int count = 0;
    struct TreeNode* node = root;
    while (node != NULL) {
        count++;
        node = node->left;
    }

    // 分配存储结果的数组内存
    int* result = (int*)malloc(count * sizeof(int));
    int index = 0;

    // 调用辅助函数进行前序遍历
    preorderTraversalHelper(root, result, &index);

    // 设置返回结果的大小
    *returnSize = index;

    return result;
}

// 创建二叉树节点的函数
struct TreeNode* createNode(int val) {
    struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    newNode->val = val;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// 构建二叉树的函数
struct TreeNode* buildTree() {
    struct TreeNode* root = createNode(1);
    root->right = createNode(2);
    root->right->left = createNode(3);
    return root;
}

// 释放二叉树节点内存的函数
void freeTree(struct TreeNode* root) {
    if (root == NULL) {
        return;
    }
    freeTree(root->left);
    freeTree(root->right);
    free(root);
}

int main() {
    // 构建二叉树
    struct TreeNode* root = buildTree();

    // 前序遍历二叉树
    int returnSize;
    int* result = preorderTraversal(root, &returnSize);

    // 打印结果
    printf("Preorder Traversal: [");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i != returnSize - 1) {
            printf(", ");
        }
    }
    printf("]\n");

    // 释放二叉树节点内存
    freeTree(root);

    // 释放结果数组内存
    free(result);

    return 0;
}

官方题解

方法一：递归

void preorder(struct TreeNode* root, int* res, int* resSize) {
    if (root == NULL) {
        return;
    }
    res[(*resSize)++] = root->val;
    preorder(root->left, res, resSize);
    preorder(root->right, res, resSize);
}

int* preorderTraversal(struct TreeNode* root, int* returnSize) {
    int* res = malloc(sizeof(int) * 2000);
    *returnSize = 0;
    preorder(root, res, returnSize);
    return res;
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/binary-tree-preorder-traversal/solutions/461821/er-cha-shu-de-qian-xu-bian-li-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

方法二：迭代

int* preorderTraversal(struct TreeNode* root, int* returnSize) {
    int* res = malloc(sizeof(int) * 2000);
    *returnSize = 0;
    if (root == NULL) {
        return res;
    }

    struct TreeNode* stk[2000];
    struct TreeNode* node = root;
    int stk_top = 0;
    while (stk_top > 0 || node != NULL) {
        while (node != NULL) {
            res[(*returnSize)++] = node->val;
            stk[stk_top++] = node;
            node = node->left;
        }
        node = stk[--stk_top];
        node = node->right;
    }
    return res;
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/binary-tree-preorder-traversal/solutions/461821/er-cha-shu-de-qian-xu-bian-li-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

（官方题解的迭代过程有动画更便于理解）

二叉树的中序遍历

给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

示例 1：

输入：root = [1,null,2,3]
输出：[1,3,2]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

提示：

  • 树中节点数目在范围 [0, 100] 内
  • -100 <= Node.val <= 100

 官方题解（有动画）

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/binary-tree-inorder-traversal/solutions/编译环境Dev-cpp(C++)

#include <stdio.h>
#include <stdlib.h>

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

// 定义栈结构
struct Stack {
    struct TreeNode** array;
    int size;
    int capacity;
};

// 创建栈
struct Stack* createStack(int capacity) {
    struct Stack* stack = (struct Stack*)malloc(sizeof(struct Stack));
    stack->array = (struct TreeNode**)malloc(capacity * sizeof(struct TreeNode*));
    stack->size = 0;
    stack->capacity = capacity;
    return stack;
}

// 判断栈是否为空
int isEmpty(struct Stack* stack) {
    return stack->size == 0;
}

// 判断栈是否已满
int isFull(struct Stack* stack) {
    return stack->size == stack->capacity;
}

// 入栈
void push(struct Stack* stack, struct TreeNode* item) {
    if (isFull(stack)) {
        return;
    }
    stack->array[stack->size++] = item;
}

// 出栈
struct TreeNode* pop(struct Stack* stack) {
    if (isEmpty(stack)) {
        return NULL;
    }
    return stack->array[--stack->size];
}

// 释放栈内存
void freeStack(struct Stack* stack) {
    free(stack->array);
    free(stack);
}

int* inorderTraversal(struct TreeNode* root, int* returnSize) {
    // 创建结果数组和栈
    int* result = (int*)malloc(100 * sizeof(int));
    struct Stack* stack = createStack(100);
    int index = 0;

    // 中序遍历
    struct TreeNode* current = root;
    while (current != NULL || !isEmpty(stack)) {
        // 将左子树的所有节点入栈
        while (current != NULL) {
            push(stack, current);
            current = current->left;
        }

        // 弹出栈顶节点并添加到结果数组
        current = pop(stack);
        result[index++] = current->val;

        // 处理右子树
        current = current->right;
    }

    // 设置返回结果的大小
    *returnSize = index;

    // 释放栈内存
    freeStack(stack);

    return result;
}

// 创建二叉树节点的函数
struct TreeNode* createNode(int val) {
    struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    newNode->val = val;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// 构建二叉树的函数
struct TreeNode* buildTree() {
    struct TreeNode* root = createNode(1);
    root->right = createNode(2);
    root->right->left = createNode(3);
    return root;
}

// 释放二叉树节点内存的函数
void freeTree(struct TreeNode* root) {
    if (root == NULL) {
        return;
    }
    freeTree(root->left);
    freeTree(root->right);
    free(root);
}

int main() {
    // 构建二叉树
    struct TreeNode* root = buildTree();

    // 中序遍历
    int returnSize = 0;
    int* result = inorderTraversal(root, &returnSize);

    // 打印结果
    printf("Inorder Traversal: ");
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", result[i]);
    }
    printf("\n");

    // 释放二叉树节点内存
    freeTree(root);

    // 释放结果数组内存
    free(result);

    return 0;
}

官方题解

方法一：递归

void inorder(struct TreeNode* root, int* res, int* resSize) {
    if (!root) {
        return;
    }
    inorder(root->left, res, resSize);
    res[(*resSize)++] = root->val;
    inorder(root->right, res, resSize);
}

int* inorderTraversal(struct TreeNode* root, int* returnSize) {
    int* res = malloc(sizeof(int) * 501);
    *returnSize = 0;
    inorder(root, res, returnSize);
    return res;
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/binary-tree-inorder-traversal/solutions/412886/er-cha-shu-de-zhong-xu-bian-li-by-leetcode-solutio/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 方法二：迭代

int* inorderTraversal(struct TreeNode* root, int* returnSize) {
    *returnSize = 0;
    int* res = malloc(sizeof(int) * 501);
    struct TreeNode** stk = malloc(sizeof(struct TreeNode*) * 501);
    int top = 0;
    while (root != NULL || top > 0) {
        while (root != NULL) {
            stk[top++] = root;
            root = root->left;
        }
        root = stk[--top];
        res[(*returnSize)++] = root->val;
        root = root->right;
    }
    return res;
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/binary-tree-inorder-traversal/solutions/412886/er-cha-shu-de-zhong-xu-bian-li-by-leetcode-solutio/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

二叉树的后序遍历

给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

示例 1：

输入：root = [1,null,2,3]
输出：[3,2,1]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

提示：

  • 树中节点的数目在范围 [0, 100] 内
  • -100 <= Node.val <= 100

官方题解（有动画）

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/binary-tree-postorder-traversal/solutions/431066/er-cha-shu-de-hou-xu-bian-li-by-leetcode-solution/ 编译环境Dev-cpp(C++)

#include <stdio.h>
#include <stdlib.h>

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

// 定义栈结构
struct Stack {
    struct TreeNode** array;
    int size;
    int capacity;
};

// 创建栈
struct Stack* createStack(int capacity) {
    struct Stack* stack = (struct Stack*)malloc(sizeof(struct Stack));
    stack->array = (struct TreeNode**)malloc(capacity * sizeof(struct TreeNode*));
    stack->size = 0;
    stack->capacity = capacity;
    return stack;
}

// 判断栈是否为空
int isEmpty(struct Stack* stack) {
    return stack->size == 0;
}

// 判断栈是否已满
int isFull(struct Stack* stack) {
    return stack->size == stack->capacity;
}

// 入栈
void push(struct Stack* stack, struct TreeNode* item) {
    if (isFull(stack)) {
        return;
    }
    stack->array[stack->size++] = item;
}

// 出栈
struct TreeNode* pop(struct Stack* stack) {
    if (isEmpty(stack)) {
        return NULL;
    }
    return stack->array[--stack->size];
}

// 释放栈内存
void freeStack(struct Stack* stack) {
    free(stack->array);
    free(stack);
}

int* postorderTraversal(struct TreeNode* root, int* returnSize) {
    // 创建结果数组和栈
    int* result = (int*)malloc(100 * sizeof(int));
    struct Stack* stack = createStack(100);
    int index = 0;

    // 定义前一个访问的节点
    struct TreeNode* prev = NULL;

    // 后序遍历
    while (root != NULL || !isEmpty(stack)) {
        // 将当前节点及其左子树的所有节点入栈
        while (root != NULL) {
            push(stack, root);
            root = root->left;
        }

        // 检查栈顶节点的右子树
        struct TreeNode* top = stack->array[stack->size - 1];

        // 如果栈顶节点的右子树为空或已经被访问过，则可以访问栈顶节点
        if (top->right == NULL || top->right == prev) {
            result[index++] = top->val;
            prev = top;
            pop(stack);
        } else {
            // 否则，将栈顶节点的右子树作为当前节点继续遍历
            root = top->right;
        }
    }

    // 设置返回结果的大小
    *returnSize = index;

    // 释放栈内存
    freeStack(stack);

    return result;
}

// 创建二叉树节点的函数
struct TreeNode* createNode(int val) {
    struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    newNode->val = val;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// 构建二叉树的函数
struct TreeNode* buildTree() {
    struct TreeNode* root = createNode(1);
    root->right = createNode(2);
    root->right->left = createNode(3);
    return root;
}

// 释放二叉树节点内存的函数
void freeTree(struct TreeNode* root) {
    if (root == NULL) {
        return;
    }
    freeTree(root->left);
    freeTree(root->right);
    free(root);
}

int main() {
    // 构建二叉树
    struct TreeNode* root = buildTree();

    // 后序遍历
    int returnSize = 0;
    int* result = postorderTraversal(root, &returnSize);

    // 打印结果
    printf("Postorder Traversal: ");
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", result[i]);
    }
    printf("\n");

    // 释放二叉树节点内存
    freeTree(root);

    // 释放结果数组内存
    free(result);

    return 0;
}

官方题解

方法一：递归

void postorder(struct TreeNode *root, int *res, int *resSize) {
    if (root == NULL) {
        return;
    }
    postorder(root->left, res, resSize);
    postorder(root->right, res, resSize);
    res[(*resSize)++] = root->val;
}

int *postorderTraversal(struct TreeNode *root, int *returnSize) {
    int *res = malloc(sizeof(int) * 2001);
    *returnSize = 0;
    postorder(root, res, returnSize);
    return res;
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/binary-tree-postorder-traversal/solutions/431066/er-cha-shu-de-hou-xu-bian-li-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

方法二：迭代

int *postorderTraversal(struct TreeNode *root, int *returnSize) {
    int *res = malloc(sizeof(int) * 2001);
    *returnSize = 0;
    if (root == NULL) {
        return res;
    }
    struct TreeNode **stk = malloc(sizeof(struct TreeNode *) * 2001);
    int top = 0;
    struct TreeNode *prev = NULL;
    while (root != NULL || top > 0) {
        while (root != NULL) {
            stk[top++] = root;
            root = root->left;
        }
        root = stk[--top];
        if (root->right == NULL || root->right == prev) {
            res[(*returnSize)++] = root->val;
            prev = root;
            root = NULL;
        } else {
            stk[top++] = root;
            root = root->right;
        }
    }
    return res;
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/binary-tree-postorder-traversal/solutions/431066/er-cha-shu-de-hou-xu-bian-li-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

提示：

  • 树中节点数目在范围 [0, 2000] 内
  • -1000 <= Node.val <= 1000

 大佬题解


/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */


/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
    int** ans=(int**)malloc(sizeof(int*)*2000);
    *returnSize=0;
    if(!root) return NULL;//要在return前给出*returnSize的取值不然过不去；！！
    int columnSizes[2000];//记录每一行的列数（每层结点数），因为要给出* returnColumnSizes
    struct TreeNode* queue[2000];//模拟队列
    int rear=0;int head=0;//记录队列头尾
    queue[rear++]=root;//录入根结点

    while(rear!=head){//队列不为空
        ans[(*returnSize)]=(int*)malloc(sizeof(int)*(rear-head));
        columnSizes[(*returnSize)]=rear-head;
        int start=head;//记录遍历开始位置，即为本层的头
        head=rear;//本层的尾部成为下次的头，因为所有的元素均弹出队列
        //在这里下层的头head同时作为遍历结束的位置，因为在遍历中rear会不断改变，成为下层的尾
        for(int i=start;i<head;i++){//弹出start到未变化的rear（即为head）之间的所有元素
            ans[(*returnSize)][i-start]=queue[i]->val;
            if(queue[i]->left) queue[rear++]=queue[i]->left;
            if(queue[i]->right) queue[rear++]=queue[i]->right;//rear不断改变
        }
        (*returnSize)++;//一层遍历完*returnSize加一；
       
    }
    *returnColumnSizes=(int*)malloc(sizeof(int)*(*returnSize));//给出*returnColumnSizes
    for(int i=0;i<*returnSize;i++) (*returnColumnSizes)[i]=columnSizes[i];
    return ans;
}

作者：我不是朝伟
链接：https://leetcode.cn/problems/binary-tree-level-order-traversal/solutions/2149734/er-cha-shu-de-ceng-xu-bian-li-chun-cwu-x-c8yq/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

优先搜索

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

叶子节点 是指没有子节点的节点。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]

示例 2：

输入：root = [1,2,3], targetSum = 5
输出：[]

示例 3：

输入：root = [1,2], targetSum = 0
输出：[]

提示：

  • 树中节点总数在范围 [0, 5000] 内
  • -1000 <= Node.val <= 1000
  • -1000 <= targetSum <= 1000

官方题解

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/path-sum-ii/solutions/427759/lu-jing-zong-he-ii-by-leetcode-solution/ 方法一：深度优先搜索

int** ret;
int retSize;
int* retColSize;

int* path;
int pathSize;

void dfs(struct TreeNode* root, int targetSum) {
    if (root == NULL) {
        return;
    }
    path[pathSize++] = root->val;
    targetSum -= root->val;
    if (root->left == NULL && root->right == NULL && targetSum == 0) {
        int* tmp = malloc(sizeof(int) * pathSize);
        memcpy(tmp, path, sizeof(int) * pathSize);
        ret[retSize] = tmp;
        retColSize[retSize++] = pathSize;
    }
    dfs(root->left, targetSum);
    dfs(root->right, targetSum);
    pathSize--;
}

int** pathSum(struct TreeNode* root, int targetSum, int* returnSize, int** returnColumnSizes) {
    ret = malloc(sizeof(int*) * 2001);
    retColSize = malloc(sizeof(int) * 2001);
    path = malloc(sizeof(int) * 2001);
    retSize = pathSize = 0;
    dfs(root, targetSum);
    *returnColumnSizes = retColSize;
    *returnSize = retSize;
    return ret;
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/path-sum-ii/solutions/427759/lu-jing-zong-he-ii-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

方法二：广度优先搜索

int** ret;
int retSize;
int* retColSize;

int* path;
int pathSize;

typedef struct {
    struct TreeNode* key;
    struct TreeNode* val;
    UT_hash_handle hh;
} hashTable;

hashTable* parent;

void insertHashTable(struct TreeNode* x, struct TreeNode* y) {
    hashTable* rec = malloc(sizeof(hashTable));
    rec->key = x;
    rec->val = y;
    HASH_ADD_PTR(parent, key, rec);
}

struct TreeNode* queryHashTable(struct TreeNode* x) {
    hashTable* rec;
    HASH_FIND_PTR(parent, &x, rec);
    return rec->val;
}

void getPath(struct TreeNode* node) {
    int* tmp = malloc(sizeof(int) * 2001);
    int tmpSize = 0;
    while (node != NULL) {
        tmp[tmpSize++] = node->val;
        node = queryHashTable(node);
    }
    for (int i = 0; i < tmpSize / 2; i++) {
        int t = tmp[i];
        tmp[i] = tmp[tmpSize - 1 - i], tmp[tmpSize - 1 - i] = t;
    }
    ret[retSize] = tmp;
    retColSize[retSize++] = tmpSize;
}

int** pathSum(struct TreeNode* root, int targetSum, int* returnSize, int** returnColumnSizes) {
    ret = malloc(sizeof(int*) * 2001);
    retColSize = malloc(sizeof(int) * 2001);
    path = malloc(sizeof(int) * 2001);
    retSize = pathSize = 0;
    parent = NULL;
    insertHashTable(root, NULL);

    if (root == NULL) {
        *returnColumnSizes = retColSize;
        *returnSize = retSize;
        return ret;
    }

    struct TreeNode* que_node[10001];
    int que_sum[10001];
    int left = 0, right = 0;
    que_node[right] = root;
    que_sum[right++] = 0;

    while (left < right) {
        struct TreeNode* node = que_node[left];
        int rec = que_sum[left++] + node->val;
        if (node->left == NULL && node->right == NULL) {
            if (rec == targetSum) {
                getPath(node);
            }
        } else {
            if (node->left != NULL) {
                insertHashTable(node->left, node);
                que_node[right] = node->left;
                que_sum[right++] = rec;
            }
            if (node->right != NULL) {
                insertHashTable(node->right, node);
                que_node[right] = node->right;
                que_sum[right++] = rec;
            }
        }
    }

    *returnColumnSizes = retColSize;
    *returnSize = retSize;
    return ret;
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/path-sum-ii/solutions/427759/lu-jing-zong-he-ii-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
Polaris北极星少女
关注
  • 24
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构之二叉树遍历
weixin_46059788的博客
07-25 58
深度遍历-前序遍历、中序遍历和后序遍历 1.前序遍历 （1)递归实现 class Solution { public List<Integer> preorderTraversal(TreeNode root) { List<Integer> ans=new ArrayList<Integer>(); preorder(root,ans); return ans; } public void preorder(
数据结构之二叉树的遍历
panrenqiu的博客
03-27 4222
二叉树的遍历：先序遍历： 先访问根节点                     再遍历左子树                      再遍历右子树中序遍历：中序遍历左子树                      再访问根节点                       中序遍历右子树后序遍历：中序遍历左子树                     中序遍历右子树                ...
ArrayList源码分析
我要做的就是比昨天的我更强
12-05 454
ArrayList源码分析,基本是一行一行写注释,欢迎大家来阅读
每日一题——力扣144. 二叉树的前序遍历（举一反三+思想解读+逐步优化）五千字好文
weixin_44915521的博客
06-28 899
这段代码有效地实现了二叉树的前序遍历，并且时间复杂度和空间复杂度都是合理的。注意，空间复杂度中的 O(h) 部分是由于递归调用栈的使用，这在树的高度较大时可能会成为一个问题。在实际应用中，需要考虑树的平衡性以及可能的最大高度。
数据结构--二叉树遍历(详细过程)
热门推荐
m0_56283131的博客
04-21 3万+
详细到啰嗦的程度，完全0基础都可完成。
二叉树遍历，c语言 实现数据结构二叉树遍历
04-19
二叉树遍历是计算机科学中数据结构领域的重要概念，主要应用于树形数据结构的处理。在C语言中实现二叉树遍历涉及到对指针的熟练操作和递归理解。下面将详细介绍二叉树的三种基本遍历方法：前序遍历、中序遍历和后序...
数据结构二叉树遍历有关算法.doc
05-07
数据结构二叉树遍历有关算法 数据结构中的二叉树是一种常用的数据结构形式，二叉树遍历是一种基本的算法操作，旨在访问二叉树中的每个节点，并对其进行相应的处理。以下是相关的知识点： 一、 二叉树的定义 在...
数据结构_二叉树遍历_
09-29
二叉树作为一种重要的数据结构，其遍历算法是理解和应用二叉树的基础。本程序聚焦于二叉树的三种基本遍历方法：先序遍历、中序遍历和后序遍历。 **一、先序遍历** 先序遍历的顺序是：根节点 -> 左子树 -> 右子树。...
数据结构二叉树遍历.doc
10-02
数据结构二叉树遍历 二叉树遍历是指按某种规则访问二叉树的每个结点，且每个结点仅被访问一次。访问的含义十分广泛，包括对结点所作的各种操作与处理，如打印每个学生的学号、姓名、成绩等信息，将每个学生的成绩由...
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1067
可以参考以下视频。
数据结构day3
qq_55245263的博客
07-18 286
顺序表实现学生管理系统
【面试题】数据结构：堆排序的排序思想？
Colorful___的博客
07-18 714
堆排序是一种高效的排序算法，其基本思想是利用堆这种数据结构来实现排序。堆是一种特殊的完全二叉树，通常用数组来表示。
数据结构---二叉树
weixin_47808575的博客
07-22 47
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
数据结构第35节 性能优化 算法的选择
hummhumm的专栏
07-18 734
算法的选择对于优化程序性能至关重要。不同的算法在时间复杂度、空间复杂度以及适用场景上有着明显的差异。下面我将结合具体的代码示例，来讲解几种常见的算法选择及其优化方法。
【数据结构】堆的实现以及建堆算法和堆排序
2301_81670477的博客
07-19 973
哈喽，各位小伙伴大家好！上期给大家讲了树，二叉树以及堆。今天带着大家实现堆这个数据结构，以及堆排序。话不多说，咱们进入正题！向大厂冲锋！
数据结构之细说链表
m0_73634434的博客
07-17 1082
这里while循环的条件判断必须是tail->next->next，因为我们需要释放最后一个节点的地址，所以需要利用它前面一共节点来释放它，然后将tail->next置空，如果我们直接找最后一个地址然后将它释放前面一个节点就会指向被释放的地址变成一个野指针，因为我们已经找不到前面一个节点的位置了。头插就比较简单了，将该节点连接在第一个节点和第二个节点之间就可以了，但是我们需要先连接第二个和新节点，如果先连接第一个节点和新节点就会找不到第二个节点的地址。下面我们给出链表的构成，看看链表是如何解决这些问题的。
24暑假算法刷题 | Day16 | LeetCode 513. 找树左下角的值，112. 路径总合，106. 从中序和后序遍历序列构造二叉树
weixin_54468359的博客
07-18 1102
24暑假刷题day15打卡 二叉树进阶
数据结构~~顺序表
最新发布
TU^的博客
07-22 374
定义：顺序表是用一组连续的存储单元依次存储数据元素的线性结构。特点：1. 逻辑顺序与物理顺序一致：元素顺序存储，相邻元素物理位置相邻。2. 可以快速访问任意元素：通过索引直接访问元素。优点：1. 实现简单。2. 随机访问方便。缺点：1. 插入、删除操作可能需要移动大量元素，效率较低。2. 需要预先确定固定的存储空间，可能造成空间浪费或不足。基本操作：包括初始化、插入、删除、查找、遍历等。
数据结构和算法（刷题）- 用栈实现队列
yunshancangcang_的博客
07-19 365
出队涉及AB两栈的迁移。这是均摊时间复杂度，均摊到每次出队上就是。只用1个栈肯定不行，得用两个栈。思考：入队的时间复杂度显然是。思路：一个栈A，一个栈B。
数据结构二叉树遍历特性
08-20
- *1* *2* [数据结构7：基本的二叉树遍历及题目](https://blog.csdn.net/m0_53607711/article/details/128331361)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Polaris北极星少女

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

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

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

打赏作者

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

抵扣说明：

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

余额充值