【面试题】-二叉树

最新推荐文章于 2021-12-13 17:43:35 发布
最新推荐文章于 2021-12-13 17:43:35 发布
阅读量681 收藏 1
点赞数
分类专栏： 数据结构与算法 编程语言 文章标签： 二叉树面试题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zwhlxl/article/details/46610177
版权

二叉树的结点个数

1、如果二叉树为空，节点个数为0
2、不为空，节点个数 = 左子树节点个数 + 右子树节点个数 +　１

/*
二叉树的节点个数
1、如果二叉树为空，节点个数为0
2、不为空，节点个数 = 左子树节点个数 + 右子树节点个数 +　１
*/
int  GetTreeNum(pTree T)
{
    if(T == NULL)
        return 0;

    return GetTreeNum(T->Left) + GetTreeNum(T->Right) + 1;
}

二叉树的深度

1、如果二叉树为空，深度为0
2、不为空，深度为 = max(左子树深度，右子树深度) +　１

/*
二叉树的深度
1、如果二叉树为空，深度为0
2、不为空，深度为 = max(左子树深度，右子树深度)  +　１
*/

int GetTreeDepth(pTree T)
{
    if(T == NULL)
        return 0;
    return max(GetTreeDepth(T->Left), GetTreeDepth(T->Right)) + 1;
}

二叉树的遍历

前序遍历递归实现

1、二叉树为空，返回
2、不为空，先访问根节点，然后遍历左子树，最后遍历右子树

/*
前序遍历（递归解法）
1、二叉树为空，返回
2、不为空，先访问根节点，然后遍历左子树，最后遍历右子树
*/
void PreOrderTraverse(pTree T)
{
    if(T == NULL)
        return;
    cout << T->value;
    PreOrderTraverse(T->Left);
    PreOrderTraverse(T->Right);
}
前序遍历非递归实现（栈模拟）

先访问，再入栈；
1、如果T非空，访问栈顶元素，把T入栈，T指向左儿子。。
2、如果T为空，说明已经向左走到尽头了，弹出当前栈顶元素，T指向右儿子。

/*
前序遍历（非递归解法——栈模拟递归实现）
先访问，再入栈；
1、如果T非空，访问栈顶元素，把T入栈，T指向左儿子。。
2、如果T为空，说明已经向左走到尽头了，弹出当前栈顶元素，T指向右儿子。
*/
void PreOrderTraverse2(pTree T)
{
    if(T == NULL)
        return;
    stack<pTree> Stk;

    while(T || !Stk.empty())
    {
        if(T)
        {
            cout << T->value;
            Stk.push(T);
            T = T->Left;
        }
        else
        {
            T = Stk.top();
            Stk.pop();
            T = T->Right;
        }
    }
}
中序遍历递归实现

1、二叉树为空，返回
2、不为空，先遍历左子树，然后访问根节点，最后遍历右子树

/*
中序遍历（递归解法）
1、二叉树为空，返回
2、不为空，先遍历左子树，然后访问根节点，最后遍历右子树
*/
void InOrderTraverse(pTree T)
{
    if(T == NULL)
        return;
    InOrderTraverse(T->Left);
    cout << T->value;
    InOrderTraverse(T->Right);
}
中序遍历非递归实现（栈模拟）

先入栈，后访问；
1、如果T非空，把T入栈，T指向左儿子。。
2、如果T为空，说明已经向左走到尽头了，弹出当前栈顶元素，进行访问，然后T指向右儿子。

/*
中序遍历（非递归解法——栈模拟递归实现）
先入栈，后访问；
1、如果T非空，把T入栈，T指向左儿子。。
2、如果T为空，说明已经向左走到尽头了，弹出当前栈顶元素，进行访问，然后T指向右儿子。
*/
void InOrderTraverse2(pTree T)
{
    if(T == NULL)
        return;
    stack<pTree> Stk;

    while(T || !Stk.empty())
    {
        if(T)
        {
            Stk.push(T);
            T = T->Left;
        }
        else
        {
            T = Stk.top();
            Stk.pop();
            cout << T->value;
            T = T->Right;
        }
    }
}
后序遍历递归实现

1、二叉树为空，返回
2、不为空，先遍历左子树，然后遍历右子树，最后访问根节点

/*
后序遍历（递归解法）
1、二叉树为空，返回
2、不为空，先遍历左子树，然后遍历右子树，最后访问根节点
*/
void PostOrderTraverse(pTree T)
{
    if(T == NULL)
        return;
    PostOrderTraverse(T->Left);

    PostOrderTraverse(T->Right);

    cout << T->value;
}
后序遍历非递归实现（双栈模拟）

采用两个栈来实现，不过就是先压入当前节点的左子树，后压入当前节点的右子树。得到的顺序是根节点-右子树-左子树，刚好是后序遍历的逆序，所以再利用一个栈解决就可以倒过来。

/*
后序遍历（非递归解法）
采用两个栈来实现，不过就是先压入当前节点的左子树，后压入当前节点的右子树。
得到的顺序是根节点-右子树-左子树，刚好是后序遍历的逆序，所以再利用一个栈解决就可以倒过来。
*/
void PostOrderTraverse2(pTree T)
{
    if(T == NULL)
        return;

    stack<pTree> Stk1,Stk2;

    Stk1.push(T);

    while(!Stk1.empty())
    {
        pTree p = Stk1.top();
        Stk1.pop();
        Stk2.push(p);

        if(p->Left)
            Stk1.push(p->Left);
        if(p->Right)
            Stk1.push(p->Right);
    }

    while(!Stk2.empty())
    {
        cout << Stk2.top()->value;
        Stk2.pop();
    }
}
层序遍历队列实现

层序遍历就是从上到下从左到右访问树的节点。采用FIFO(先进先出)的数据结构-队列先将根节点入队，当队列不为空时，弹出一个节点，然后访问，若左子树或右子树不为空，将其入队

/*
层序遍历（队列）
层序遍历就是从上到下从左到右访问树的节点。采用FIFO(先进先出)的数据结构-队列
先将根节点入队，当队列不为空时，弹出一个节点，然后访问，若左子树或右子树不为空，
将其入队
*/
void LevelTraverse(pTree T)
{
    if(T == NULL)
        return;

    queue<pTree> que;
    que.push(T);

    while(!que.empty())
    {
        pTree p = que.front();
        que.pop();
        cout << p->value;
        if(p->Left)
            que.push(p->Left);
        if(p->Right)
            que.push(p->Right);
    }
}

二叉搜索树转换双向链表

http://blog.csdn.net/zwhlxl/article/details/46622981

二叉树第K层的结点个数

递归解法：
1、如果二叉树为空且k<1 则返回0；
2、如果二叉树不为空且k=1,返回1；
3、如果二叉树不为空且k>1,返回左子树中k-1层的结点个数与右子树中K-1层的结点个数之和

/*
二叉树第K层的结点个数
1、如果二叉树为空且k<1 则返回0；
2、如果二叉树不为空且k=1,返回1；
3、如果二叉树不为空且k>1,返回左子树中k-1层的结点个数与右子树中K-1层的结点个数之和

*/

int GetKthLevelNode(pTree T, int k)
{
    if(T == NULL || k < 0)
        return 0;
    if(k == 1)
        return 1;

    int leftnum = GetKthLevelNode(T->Left, k - 1);
    int rightnum = GetKthLevelNode(T->Right, k - 1);

    return leftnum + rightnum;
}

非递归解法：
利用队列解决

int GetKthLevelNode2(pTree T, int k)
{
    if(T == NULL || k < 0)
        return 0;
    int curLevel = 0;
    int curLevelNode = 0;
    queue<pTree> que;
    que.push(T);

    while(!que.empty())
    {
        curLevel ++;
        curLevelNode = que.size(); // 当前层的结点个数
        if(curLevel == k)  // 如果当前层数等于所求的层数，跳出循环
            break;
        int cntNode = 0 ;
        while(cntNode < curLevelNode)  //如果当前层数还没到求的层数，将当前层结点弹出，下一层结点入栈
        {
            cntNode ++;
            T = que.front();
            que.pop();
            if(T->Left != NULL)
                que.push(T->Left);
            if(T->Right != NULL)
                que.push(T->Right);
        }

    }

    while(!que.empty())
        que.pop();
    if(curLevel == k)
        return curLevelNode;
    return 0;  //k 值大于树的深度，返回0
}

寻找二叉树两个节点的最低公共祖先

http://www.acmerblog.com/lca-lowest-common-ancestor-5574.html

#include <iostream>
#include <vector>

using namespace std;

struct Node
{
    int key;
    struct Node *left;
    struct Node *right;
};

Node* newNode(int k)
{
    Node* tmp = new Node;
    tmp->key = k;
    tmp->left = NULL;
    tmp->right = NULL;
}

bool FindPath(Node* root, vector<int> &path, int key)
{
    if(root == NULL)
        return false;
    path.push_back(root->key);
    if(root->key == key)
        return true;

    bool found = (FindPath(root->left, path, key) | FindPath(root->right, path, key));

    /*
    bool found = false;


    found = FindPath(root->left, path, key);

    if(!found)
        found = FindPath(root->right, path, key);
*/
    if(!found)
        path.pop_back();

    return found;

}

int FindLCA(Node* root, int key1, int key2)
{
    vector<int> path1, path2;
    int ans;
    bool found1 = FindPath(root, path1, key1);
    bool found2 = FindPath(root, path2, key2);

    if(found1 && found2)
    {
        for(int i = 0; i < path1.size(); i ++)
        {
            if(path1[i] != path2[i])
                break;
            else
                ans = path1[i];
        }

        return ans;
    }

    return -1;
}

int main(int argc, char const *argv[])
{
    Node* Tree = newNode(1);
    Tree->left = newNode(2);
    Tree->right = newNode(3);
    Tree->left->left = newNode(4);
    Tree->left->right = newNode(5);
    Tree->right->left = newNode(6);
    Tree->right->right= newNode(7);
    cout << "LCA(4,5)" << FindLCA(Tree, 4, 5) << endl;
    cout << "LCA(4,6)" << FindLCA(Tree, 4, 6) << endl;
    return 0;
}

测试程序

分别有求二叉树的节点个数，深度，和前序，中序，后序的递归和非递归实现

#include <iostream>
#include <stack>
#include <queue>


/*
          A
      B       C
    D   E   F    G
  H       I         J
    K


*/
using namespace std;

#define OK 1
#define ERROR 0
#define TRUE  1
#define FALSE 0

typedef char ElementType;


typedef struct TreeNode
{
    ElementType value;
    struct TreeNode *Left;
    struct TreeNode *Right;
}TreeNode, *pTree;

int index = 0;
char str[] = "ABDH#K###E##CFI###G#J##";

void DeleteTree(pTree *T)
{
    if(*T)
    {
        if((*T)->Left)
            DeleteTree(&(*T)->Left);
        if((*T)->Right)
            DeleteTree(&(*T)->Right);
        free(*T);
        *T = NULL;
    }
}

void CreatTree(pTree *T)
{
    ElementType ch;
    ch = str[index ++];
    if(ch == '#')
        *T = NULL;
    else
    {
        //(pTree) *T = new TreeNode;
        *T = (pTree)malloc(sizeof(TreeNode));
        if(*T == NULL)
            exit(ERROR);

        (*T)->value = ch;
        CreatTree(&(*T)->Left);
        CreatTree(&(*T)->Right);

    }
}



/*
二叉树的节点个数
1、如果二叉树为空，节点个数为0
2、不为空，节点个数 = 左子树节点个数 + 右子树节点个数 +　１
*/
int  GetTreeNum(pTree T)
{
    if(T == NULL)
        return 0;

    return GetTreeNum(T->Left) + GetTreeNum(T->Right) + 1;
}

/*
二叉树的深度
1、如果二叉树为空，深度为0
2、不为空，深度为 = max(左子树深度，右子树深度)  +　１
*/

int GetTreeDepth(pTree T)
{
    if(T == NULL)
        return 0;
    return max(GetTreeDepth(T->Left), GetTreeDepth(T->Right)) + 1;
}

/*
前序遍历（递归解法）
1、二叉树为空，返回
2、不为空，先访问根节点，然后遍历左子树，最后遍历右子树
*/
void PreOrderTraverse(pTree T)
{
    if(T == NULL)
        return;
    cout << T->value;
    PreOrderTraverse(T->Left);
    PreOrderTraverse(T->Right);
}

/*
中序遍历（递归解法）
1、二叉树为空，返回
2、不为空，先遍历左子树，然后访问根节点，最后遍历右子树
*/
void InOrderTraverse(pTree T)
{
    if(T == NULL)
        return;
    InOrderTraverse(T->Left);
    cout << T->value;
    InOrderTraverse(T->Right);
}

/*
后序遍历（递归解法）
1、二叉树为空，返回
2、不为空，先遍历左子树，然后遍历右子树，最后访问根节点
*/
void PostOrderTraverse(pTree T)
{
    if(T == NULL)
        return;
    PostOrderTraverse(T->Left);

    PostOrderTraverse(T->Right);

    cout << T->value;
}

/*
前序遍历（非递归解法——栈模拟递归实现）
先访问，再入栈；
1、如果T非空，访问栈顶元素，把T入栈，T指向左儿子。。
2、如果T为空，说明已经向左走到尽头了，弹出当前栈顶元素，T指向右儿子。
*/
void PreOrderTraverse2(pTree T)
{
    if(T == NULL)
        return;
    stack<pTree> Stk;

    while(T || !Stk.empty())
    {
        if(T)
        {
            cout << T->value;
            Stk.push(T);
            T = T->Left;
        }
        else
        {
            T = Stk.top();
            Stk.pop();
            T = T->Right;
        }
    }
}

/*
中序遍历（非递归解法——栈模拟递归实现）
先入栈，后访问；
1、如果T非空，把T入栈，T指向左儿子。。
2、如果T为空，说明已经向左走到尽头了，弹出当前栈顶元素，进行访问，然后T指向右儿子。
*/
void InOrderTraverse2(pTree T)
{
    if(T == NULL)
        return;
    stack<pTree> Stk;

    while(T || !Stk.empty())
    {
        if(T)
        {
            Stk.push(T);
            T = T->Left;
        }
        else
        {
            T = Stk.top();
            Stk.pop();
            cout << T->value;
            T = T->Right;
        }
    }
}


/*
后序遍历（非递归解法）
采用两个栈来实现，不过就是先压入当前节点的左子树，后压入当前节点的右子树。
得到的顺序是根节点-右子树-左子树，刚好是后序遍历的逆序，所以再利用一个栈解决就可以倒过来。
*/
void PostOrderTraverse2(pTree T)
{
    if(T == NULL)
        return;

    stack<pTree> Stk1,Stk2;

    Stk1.push(T);

    while(!Stk1.empty())
    {
        pTree p = Stk1.top();
        Stk1.pop();
        Stk2.push(p);

        if(p->Left)
            Stk1.push(p->Left);
        if(p->Right)
            Stk1.push(p->Right);
    }

    while(!Stk2.empty())
    {
        cout << Stk2.top()->value;
        Stk2.pop();
    }
}

/*
层序遍历（队列）
层序遍历就是从上到下从左到右访问树的节点。采用FIFO(先进先出)的数据结构-队列
先将根节点入队，当队列不为空时，弹出一个节点，然后访问，若左子树或右子树不为空，
将其入队
*/
void LevelTraverse(pTree T)
{
    if(T == NULL)
        return;

    queue<pTree> que;
    que.push(T);

    while(!que.empty())
    {
        pTree p = que.front();
        que.pop();
        cout << p->value;
        if(p->Left)
            que.push(p->Left);
        if(p->Right)
            que.push(p->Right);
    }
}

/*
二叉树第K层的结点个数
1、如果二叉树为空且k<1 则返回0；
2、如果二叉树不为空且k=1,返回1；
3、如果二叉树不为空且k>1,返回左子树中k-1层的结点个数与右子树中K-1层的结点个数之和

*/

int GetKthLevelNode(pTree T, int k)
{
    if(T == NULL || k < 1)
        return 0;
    if(k == 1)
        return 1;

    int leftnum = GetKthLevelNode(T->Left, k - 1);
    int rightnum = GetKthLevelNode(T->Right, k - 1);

    return leftnum + rightnum;
}

int GetKthLevelNode2(pTree T, int k)
{
    if(T == NULL || k < 0)
        return 0;
    int curLevel = 0;
    int curLevelNode = 0;
    queue<pTree> que;
    que.push(T);

    while(!que.empty())
    {
        curLevel ++;
        curLevelNode = que.size(); // 当前层的结点个数
        if(curLevel == k)  // 如果当前层数等于所求的层数，跳出循环
            break;
        int cntNode = 0 ;
        while(cntNode < curLevelNode)  //如果当前层数还没到求的层数，将当前层结点弹出，下一层结点入栈
        {
            cntNode ++;
            T = que.front();
            que.pop();
            if(T->Left != NULL)
                que.push(T->Left);
            if(T->Right != NULL)
                que.push(T->Right);
        }

    }

    while(!que.empty())
        que.pop();
    if(curLevel == k)
        return curLevelNode;
    return 0;  //k 值大于树的深度，返回0
}

/*
求二叉树的叶结点个数（叶结点指没有左儿子和右儿子的结点）
*/

int GetTreeLeafsNum(pTree T)
{
    if(T == NULL)
        return 0;
    if(T->Left == NULL && T->Right == NULL)
        return 1;
    int leftnum = GetTreeLeafsNum(T->Left);
    int rightnum = GetTreeLeafsNum(T->Right);

    return leftnum + rightnum;
}

bool FindPath(TreeNode* root, vector<ElementType>& path, ElementType ch)
{
    if(root == NULL)
        return false;

    path.push_back(root->value);
    if(ch == root->value)
        return true;

    bool found = false;

    found = (FindPath(root->Left, path, ch) | FindPath(root->Right, path, ch));

    if(!found)
        path.pop_back();

    return found;

}

ElementType FindLCA(TreeNode * root, ElementType ch1, ElementType ch2)
{
    vector<ElementType> path1, path2;
    ElementType ans;
    bool find1 = FindPath(root, path1, ch1);
    bool find2 = FindPath(root, path2, ch2);

    if(find1 && find2)
    {
        for(int i = 0; i < path1.size(); i ++)
        {
            if(path1[i] != path2[i])
                break;

            else 
                ans = path1[i];

        }

        return ans;

    }

    return -1;

}

int main(int argc, char const *argv[])
{
    /* code */
    pTree Tnode = NULL;
    CreatTree(&Tnode);

    cout << "该二叉树节点个数为  " << GetTreeNum(Tnode) << endl;

    cout << "该二叉树深度为  " << GetTreeDepth(Tnode) << endl;

    cout << "前序遍历（递归）" << endl;
    PreOrderTraverse(Tnode);
    cout << endl;

    cout << "前序遍历（非递归）" << endl;
    PreOrderTraverse2(Tnode);
    cout << endl;


    cout << "中序遍历（递归）" << endl;
    InOrderTraverse(Tnode);
    cout << endl;

    cout << "中序遍历（非递归）" << endl;
    InOrderTraverse2(Tnode);
    cout << endl;

    cout << "后序遍历（递归）" << endl;
    PostOrderTraverse(Tnode);
    cout << endl;

    cout << "后序遍历（非递归）" << endl;
    PostOrderTraverse2(Tnode);
    cout << endl;

    cout << "层序遍历（队列）" << endl;
    LevelTraverse(Tnode);
    cout << endl;

    cout << "二叉树第3层的结点个数为(递归)： " << GetKthLevelNode(Tnode, 3) << endl;

    cout << "二叉树第3层的结点个数为(非递归)： " << GetKthLevelNode2(Tnode, 3) << endl;

    cout << "二叉树叶结点个数为(递归)： " << GetTreeLeafsNum(Tnode) << endl;

    cout << "两个结点的最低公共祖先" << endl;


    /*
           A
      B         C
    D   E    F     G
  H        I         J
    K


*/
    cout << "LCA(H,K)" << FindLCA(Tnode, 'H', 'K') << endl;

    cout << "LCA(H,I)" << FindLCA(Tnode, 'H', 'I') << endl;

    cout << "LCA(F,G)" << FindLCA(Tnode, 'F', 'G') << endl;
    return 0;
}
zengwh513
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】求二叉树深度的算法
没有感情的代码机器的博客
10-18 7837
要求二叉树的深度，方法是先求出左子树的深度，再求出右子树的深度，二叉树的深度就是左子树的深度和右子树的深度中的最大值加1. 自然而然想到用后根遍历的思想实现 主要步骤如下： 若二叉树为空，则返回0值，否则 求左子树的深度； 求右子树的深度； 将左子树、右子树深度的最大值加1并返回其值。 //求二叉树深度的算法 public int getDepth(BiTreeNode T) { if...
算法面试题-----二叉树完整刷题总结
爱喝舒化奶的博客
03-19 3326
题目：输入一颗二叉树，返回他的深度（包括最大深度，最小深度） 解题：可以通过DFS，BFS两种方式进行计算 【剑指offer】面试题55 二叉树的深度 leetcode 104. Maximum Depth of Binary Tree （求二叉树的最大深度,DFS,BFS） leetcode 111. Minimum Depth of Binary Tree(求二叉树的最小深度，DFS,BFS)...
数据结构与算法基础——二叉树
weixin_49305355的博客
07-06 133
二叉树 二叉树的性质 性质1：在二叉树的第i层上至多有\\(2^{i-1}\\) 性质2：深度为k的二叉树至多有\\(2^k-1\\)个结点 性质3：对任何一颗二叉树T，如果其叶子数为\\(n\_0\\)，度为2的结点数为\\(n\_2\\)，则\\(n\_0=n\_2+1\\) 性质4：具有n个结点的完全二叉树的深度为\\([log\_2n]+1\\) 性质5：略 顺序存储 按**满二叉树**的结点层次编号，依次存放二叉树中的数据元素 特点： 1.结点间关系蕴含在其存储位置中 2.浪费空间，适
二叉树先序遍历(递归)
brucehb的专栏
11-15 421
#include using namespace std; struct Node { int value; Node *left; Node *right; }; void preorderTraverse(Node *root) { if (NULL == root) { return; } cout v
二叉树的经典面试题总结
snow_5288的博客
05-04 9112
1、二叉树的构造 2、遍历二叉树 3、求二叉树的高度（深度） 4、求二叉树中节点的个数 5、求二叉树中叶子节点的个数 6、求二叉树第K层的节点个数 7、判断一个节点是否在二叉树中 8、求两个节点的最近公共祖先9、判断一棵二叉树是否是平衡二叉树10、求二叉树中最远的两个节点的距离 11、由前序遍历和中序遍历重建二叉树12、判断一棵树是否是完全二叉树13、求二叉树的镜像14、二叉搜索树->有序双链表
二叉树-顺序-先序-中序-后序遍历---递归-非递归算法实现
qq_44952181的博客
12-13 370
二叉树-顺序-先序-中序-后序遍历---递归-非递归算法实现
IT面试题-二叉树的三种遍历的递归与非递归实现，详细代码
04-13
在IT面试中，二叉树的遍历是一个常见的知识点，尤其对于编程岗位来说更是必不可少的考察点。二叉树的遍历主要有三种方式：先序遍历、中序遍历和后序遍历。这些遍历方法可以使用递归或非递归的方式实现。 **先序遍历...
算法大全-面试题-链表-栈-二叉树-数据结构.docx
最新发布
09-01
【链表】 链表是一种线性数据结构，其中元素以节点的...这些操作展示了链表的灵活性和多样性，理解和熟练掌握这些操作对于解决实际问题和面试准备至关重要。在实际编程中，了解和应用这些算法能够提高解决问题的效率。
算法大全-面试题-链表-栈-二叉树-数据结构
05-26
"算法大全-面试题-链表-栈-二叉树-数据结构"这个压缩包文件提供了丰富的知识资源，旨在帮助学习者深入理解和应用这些核心概念。 链表是一种线性数据结构，与数组不同，它的元素在内存中不是连续存储的。链表由一...
二叉树的深度
m0_57375647的博客
09-08 814
二叉树的深度 查看提交统计提问 总时间限制: 1000ms 内存限制: 65535kB 描述 给定一棵二叉树，求该二叉树的深度 二叉树深度定义：从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的节点个数为树的深度 输入第一行是一个整数n，表示二叉树的结点个数。二叉树结点编号从1到n，根结点为1，n 接下来有n行，依
C++详解 二叉树的三种遍历方式
weixin_43335392的博客
03-28 4814
上一篇文章，讲了二叉树的创建——C++实现 链表存储二叉树 接下来讲解二叉树的三种遍历方式：先序(前序)遍历、中序遍历、后序遍历，三种方式都是DFS(Depth First Search)深度优先搜索，核心思想都是函数的递归(栈)，如果你能理解上面这篇文章中创建二叉树的具体过程，那么遍历就轻而易举 1.先序遍历 Former_Order_Traversel(BinTree_Node* p) { ...
为什么二叉树的前序遍历和中序遍历对应入栈和出栈次序？
星星的博客
10-22 1万+
对一棵树或者子树进行先序或者中序遍历时入栈顺序相同。 都是根节点、左子树、右子树，（注意是入栈） 先序访问后入栈，中序出栈后访问， 则先序序列就是入栈顺序，中序序列就是出栈顺序。 卡特兰数应用之出栈次序： 问题：一个栈的进栈序列为1,2,3，…，n。有多少个不同的出栈序列？ 分析：设f(n) = 序列个数为n的出栈序列种数。设最后出栈的元素为k。即在k进栈之前，元素1,2,…，k-1已经出栈，出栈序列数为f(k-1)。在k进栈后，元素k+1,k+2,…，n已经进栈后全部出栈。所以元素k+1,k+2,…,n出
前序遍历 (preorder traversal) - 中序遍历 (inorder traversal) - 后序遍历 (postorder traversal)
热门推荐
既然选择了远方 便只顾风雨兼程 - 永强
03-24 4万+
前序遍历 (preorder traversal) - 中序遍历 (inorder traversal) - 后序遍历 (postorder traversal) 1. 前序遍历 (preorder traversal) - 中序遍历 (inorder traversal) - 后序遍历 (postorder traversal) 遍历的递归实现。 遍历的非递归实现 - 使用栈的非递归实现。 ...
分治算法例子集锦
zengwh
03-07 2万+
分治算法例子集锦
动态规划（DP）之入门学习-数字三角形
zengwh
05-29 2万+
数字三角形案例题目描述 Description下图给出了一个数字三角形，请编写一个程序，计算从顶至底的某处的一条路径，使该路径所经过的数字的总和最大。 （1）每一步可沿左斜线向下或右斜线向下 （2）1 < 三角形行数 < 100 （3）三角形数字为0，1，…99 输入描述 Input Description有很多个测试案例，对于每一个测试案例， 通过键盘逐行输入，第1行是输入整数（如
二叉树最大深度和最小深度
zengwh
08-12 1万+
二叉树的最大深度给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的距离。如果二叉树为空，则深度为0 如果不为空，分别求左子树的深度和右子树的深度，去最大的再加1，因为根节点深度是1，要加进去。int maxDepth(TreeNode *root) { // write your code (here) if(root == NULL)
散列表-开放地址法和链地址法的实现
zengwh
06-30 9898
基本定义散列技术是在记录的存储位置和它的关键字之间建立一个确定的对应关系 f，使得每个关键字key对应一个存储位置f(key)。这种对应关系f称为散列或哈希函数。采用上述思想将数据存储在一块连续的存储空间中，这块连续的存储空间称为散列或哈希表。关键字对应的存储位置称为散列地址。散列技术最适合的求解问题是查找与给定值相等的记录。 如果碰到两个不同的关键字key1≠key2key_1 \neq key
数组和链表的归并排序算法实现（C语言）
zengwh
03-05 9482
数组和链表的归并排序算法实现（C语言）
后缀表达式的栈实现(C语言）
zengwh
01-21 6956
中缀表达式转为后缀表达式的栈实现以及计算(C语言）
大厂算法岗面试题二叉树
06-08
二叉树是大厂算法岗面试中经常出现的考察内容，以下列举几个常见的二叉树相关的面试题： 1. 实现一个二叉树的前序遍历、中序遍历和后序遍历。 2. 给定一个二叉树，求其最大深度。 3. 判断一个二叉树是否是平衡...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值