求二叉树中节点的最大距离

最新推荐文章于 2012-02-19 16:53:23 发布
最新推荐文章于 2012-02-19 16:53:23 发布
阅读量306 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： tree null struct 语言 c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/x_xiaoge/article/details/7253648
版权

1、C语言版

#include <stdio.h>

#include <stdlib.h>


struct Node
{
    struct Node * pLeft;
    struct Node * pRight;
    int nMaxLeft;
    int nMaxRight;
    char nValue;
};


int nMaxLen = 0;


//
//初始化树
//
struct Node* initTree()
{
    struct Node* tree[10];


    int i;
    for(i=0;i<10;i++)
    {
        tree[i]=(struct Node*)malloc(sizeof(struct Node));
        tree[i]->nMaxLeft=0;
        tree[i]->nMaxRight=0;
        tree[i]->pLeft=NULL;
        tree[i]->pRight=NULL;
        tree[i]->nValue=(char)i;
    }
    for(i=0;i<=2;i++)
    {
        tree[i]->pLeft=tree[2*i+1];
        tree[i]->pRight=tree[2*i+2];
    }
    tree[3]->pLeft=tree[7];
    tree[5]->pRight=tree[8];
    return tree[0];
}




//中序遍历
void inOrder(struct Node* tree)
{
   if(tree != NULL)
   {
       inOrder(tree->pLeft);
       printf("%d ",tree->nValue);
       inOrder(tree->pRight);
   }
}




//前序遍历
void preOrder(struct Node* tree)
{
    if(tree != NULL)
    {
        printf("%d ",tree->nValue);
        preOrder(tree->pLeft);
        preOrder(tree->pRight);
    }


}




//后续遍历
void postOrder(struct Node* tree)
{
    if(tree != NULL)
    {
        postOrder(tree->pLeft);
        postOrder(tree->pRight);
        printf("%d ",tree->nValue);
    }
}






//寻找树中最长的两段距离
int FindMaxLen(struct Node * pRoot)
{
    //遍历到叶子节点，返回
    if(pRoot == NULL)
    {
        return;
    }
    //如果左子树为空，那么该节点的左边最长距离为0
    if(pRoot -> pLeft == NULL)
    {
        pRoot -> nMaxLeft = 0;
    }


    //如果右子树为空，那么该节点的右边最长距离为0
    if(pRoot -> pRight == NULL)
    {
        pRoot -> nMaxRight = 0;
    }


    //如果左子树不为空，那么递归寻找左子树的最长距离
    if(pRoot -> pLeft != NULL)
    {
        FindMaxLen(pRoot -> pLeft);
    }


    //如果右子树不为空，那么递归寻找右子树的最长距离
    if(pRoot -> pRight != NULL)
    {
        FindMaxLen(pRoot -> pRight);
    }


    //计算左子树的最长距离
    if(pRoot -> pLeft != NULL)
    {
        int nTempMax = 0;
        if(pRoot -> pLeft-> nMaxLeft > pRoot -> pLeft->nMaxRight)
        {
            nTempMax = pRoot -> pLeft -> nMaxRight;
        }
        else
        {
            nTempMax = pRoot -> pLeft -> nMaxRight;
        }


        pRoot -> nMaxLeft = nTempMax + 1;
    }


    //计算右子树的最长距离
    if(pRoot -> pRight != NULL)
    {
        int nTempMax = 0;


        if(pRoot -> pRight -> nMaxLeft > pRoot -> pRight -> nMaxRight)
        {
            nTempMax = pRoot -> pRight -> nMaxLeft;
        }
        else
        {
            nTempMax = pRoot -> pRight -> nMaxRight;
        }
        pRoot -> nMaxRight = nTempMax + 1;
    }


    //更新最长距离
    if(pRoot -> nMaxLeft + pRoot -> nMaxRight > nMaxLen)
    {
        nMaxLen = pRoot -> nMaxLeft + pRoot -> nMaxRight;
    }


    return nMaxLen;
}
int main()
{
    struct Node* treeRootNode = (struct Node*)malloc(sizeof(struct Node));
    treeRootNode = initTree();
    inOrder(initTree());
    printf("\n");
    preOrder(initTree());
    printf("\n");
    postOrder(initTree());
    printf("\n");
    int nMaxLength = 0;
    nMaxLength = FindMaxLen(treeRootNode);
    printf("nMaxLength = %d\n", nMaxLength);
    return 0;

}




2、C++版

#include <stdlib.h>
#include <stack>
using namespace std;
//*************************************
//题目：
//     求一棵二叉树中距离相差最远的两个结点之间的距离。
//
//
//思路：注意指针声明了一定要赋值，否则会报错。
//        方法一：递归法
//距离相差最远的两个结点，共有以下两种情况：
// (1)路径经过根结点，所以两个结点在根结点的不同分支上
// (2)路径不经过根结点，所以两个结点应该是次根结点中相聚最远的两个结点。(递归思想)
// 递归本质上还是采用了后续遍历的方法。由于是从叶子结点开始的所以每次处理都是第一种情况。
//        方法二：非递归法
//采用后序遍历二叉树的同时对二叉树的结点进行更新，每次更新都要更新最大距离。
//
//*************************************




//
//定义结点结构
//
struct NODE
{
    NODE* pLeft;
    NODE* pRight;
    int nMaxLeft;
    int nMaxRight;
    char nValue;
};
int tMaxLength=0;    //最大距离


stack<NODE*> s;


//
//求最大距离(方法一)
//
void findMaxLength1(NODE* root)
{
    //递归结束
    if(root==NULL)    return;


    //
    //左树为空
    //
    if(root->pLeft==NULL)
        root->nMaxLeft=0;


    //
    //右树为空
    //
    if(root->pRight==NULL)
        root->pRight=0;


    //
    //左树不为空
    //
    if(root->pLeft!=NULL)
    {
        findMaxLength1(root->pLeft);
    }


    //
    //右树不为空
    //
    if(root->pRight!=NULL)
    {
        findMaxLength1(root->pRight);
    }


    //
    //求左子树最大距离
    //
    if(root->pLeft!=NULL)
    {
        int nTempMax=0;
        if(root->pLeft->nMaxLeft>root->pLeft->nMaxRight)
            nTempMax=root->pLeft->nMaxLeft;
        else
            nTempMax=root->pLeft->nMaxRight;
        root->nMaxLeft=nTempMax+1;
    }


    //
    //求右子树最大距离
    //
    if(root->pRight!=NULL)
    {
        int nTempMax=0;
        if(root->pRight->nMaxLeft>root->pRight->nMaxRight)
            nTempMax=root->pRight->nMaxLeft;
        else
            nTempMax=root->pRight->nMaxRight;
        root->nMaxRight=nTempMax+1;
    }


    //
    //更新最大距离
    //
    if((root->nMaxLeft+root->nMaxRight)>tMaxLength)
        tMaxLength=root->nMaxLeft+root->nMaxRight;
}


//
//求最大距离(方法二)
//
void findMaxLength2(NODE* root)
{
    NODE *p=root;
    NODE *have_visited=NULL; //记录上次访问的结点，主要是用在：判定根结点是       //否能访问。如果根结点的右孩子是刚访问的，那么就能访问根结点了。
    while(p!=NULL||!s.empty())
    {
        //
        //把最左分支压入栈，类似于中序遍历
        //


        while(p!=NULL)
        {
            s.push(p);
            p=p->pLeft;
        }
        p=s.top();


        //
        //如果右子树是空，那么后序遍历就是中序遍历
        //如果如果上次访问的是右结点，那么可以访问根结点
        //


        if(p->pRight==NULL||have_visited==p->pRight)
        {
            //
            //以下是求最大距离的代码，不属于后序遍历
            //


            if(p->pLeft!=NULL)
            {
                p->nMaxLeft=p->pLeft->nMaxLeft+1;
                if(p->pLeft->nMaxRight+1>p->nMaxLeft)
                    p->nMaxLeft=p->pLeft->nMaxRight+1;
            }
            if(p->pRight!=NULL)
            {
                p->nMaxRight=p->pRight->nMaxRight+1;
                if(p->pRight->nMaxLeft+1>p->nMaxRight)
                    p->nMaxRight=p->pRight->nMaxLeft+1;
            }
            if((root->nMaxLeft+root->nMaxRight)>tMaxLength)
                tMaxLength=root->nMaxLeft+root->nMaxRight;
            //*************************************结束


            s.pop();
            have_visited=p;
            p=NULL;
        }
        else
        {
            p=p->pRight; //指向右子树，为下次循环，压栈做准备。


        }
    }
}


//
//中序遍历
//
void inOrderTraverse(NODE* root)
{


    s.push(root);
    while(!s.empty())
    {
        while(s.top()!=NULL)
        {
            NODE* t=s.top()->pLeft;
            s.push(t);
        }
        s.pop();
        if(!s.empty())
        {
            NODE* top=s.top();
            s.pop();
            printf("%d ",top->nValue);
            s.push(top->pRight);
        }
    }




}


//
//后序遍历
//
void postOrderTraverse(NODE* root)
{
    NODE *p=root;
    NODE *have_visited=NULL; //记录上次访问的结点，主要是用在：判定根结点是                 //否能访问如果根结点的右孩子是刚访问的，那么就能访问根结点了。
    while(p!=NULL||!s.empty())
    {
        //
        //把最左分支压入栈，类似于中序遍历
        //


        while(p!=NULL)
        {
            s.push(p);
            p=p->pLeft;
        }
        p=s.top();
        //
        //如果右子树是空，那么后序遍历就是中序遍历
        //如果如果上次访问的是右结点，那么可以访问根结点
        //


        if(p->pRight==NULL||have_visited==p->pRight)
        {
            printf("%d ",p->nValue);
            s.pop();
            have_visited=p;
            p=NULL;
        }
        else
        {
            p=p->pRight; //指向右子树，为下次循环，压栈做准备。


        }
    }
}


//
//初始化树
//
NODE* initTree()
{
    NODE* tree[10];


    for(int i=0;i<10;i++)
    {
        tree[i]=(NODE*)malloc(sizeof(NODE));
        tree[i]->nMaxLeft=0;
        tree[i]->nMaxRight=0;
        tree[i]->pLeft=NULL;
        tree[i]->pRight=NULL;
        tree[i]->nValue=(char)i;
    }
    for(int i=0;i<=2;i++)
    {
        tree[i]->pLeft=tree[2*i+1];
        tree[i]->pRight=tree[2*i+2];
    }
    tree[3]->pLeft=tree[7];
    tree[5]->pRight=tree[8];
    return tree[0];
}
int main()
{
    printf("后序遍历：");
    postOrderTraverse(initTree());
    printf("\n");
    printf("中序遍历：");
    inOrderTraverse(initTree());
    printf("\n");
    findMaxLength2(initTree());
    printf("非递归:%d\n",tMaxLength);
    findMaxLength1(initTree());
    printf("递归法:%d\n",tMaxLength);
    return 0;
}

贤小哥
关注
专栏目录
求二叉树节点的最大距离
04-07
在计算机科学中，二叉树是一种非常重要的数据结构，而求二叉树节点的最大距离是二叉树中一个经典的问题。问题的定义是这样的：在二叉树中，计算任意两个节点之间的最大路径长度，路径长度是指路径上的边数。解决这个...
（算法）二叉树两个结点的最远距离
weixin_34239169的博客
08-02 220
题目： 求二叉树两个结点的最远距离。 二叉树定义如下： class TreeNode{ public: int val; TreeNode* left; TreeNode* right; TreeNode(int x):val(x),left(NULL),right(NULL){} }; 思路： 遍历每个节点，找出以当前节点为根的最长路...
二叉树中的两节点中的最大距离
04-20
在二叉树问题中，"二叉树中的两节点中的最大距离"是一个常见的算法问题，主要涉及图论和数据结构的领域。这个问题的目标是找到二叉树中任意两个节点之间的最长路径，其中路径的长度定义为节点之间的边的数量。解决这...
树中具有最大距离的两个节点
03-28
c语言实现寻找一个二叉树中距离最大的两个节点
Java实现 LeetCode 662 二叉树最大宽度（递归）
12-21
这道题的目标是计算树的所有层中最大的宽度，宽度定义为同一层中最左和最右非空节点之间的距离，包括中间的空节点。 **问题定义：** - 输入：一个二叉树的根节点 `root`。 - 输出：二叉树的最大宽度。答案需在32位...
寻找发帖水王
x_xiaoge的专栏
02-19 6038
#include #include int Find(int *ID, int N) {     int candidate = 0;     int nTimes, i;     for(i = nTimes = 0; i     {         if(nTimes == 0)         {             int tt = ID[i];
创建链表和显示链表
x_xiaoge的专栏
01-14 861
#include #include struct Stud {     int no;     int score;     struct Stud *next; }; //创建链表 struct Stud *create() {     struct Stud *head, *p, *q;     int n, s;     head = (struct Stud
树中两个节点的最低公共祖先
x_xiaoge的专栏
02-18 652
哈哈
RLE压缩和解压算法以及链表翻转
x_xiaoge的专栏
01-14 617
#include #include struct RleNode {     int count;     char ch;     struct RleNode * next; }; //压缩字符串 struct RleNode* encode(char *str) {     char *ptr = str;     int num = 1;     int i
用"%20" 替换字符串中的空格
x_xiaoge的专栏
01-12 598
#include #include void  ReplaceBlank(char string[]); int main() {     char string[] = "you are very happy";     printf("source string is: %s\n", string);     ReplaceBlank(string);     printf
从无头单链表中删除节点
x_xiaoge的专栏
02-18 494
#include #include struct Node {     int nValue;     struct Node* next; }; void DeleteRandomNode(struct Node* pCurrent) {     if(pCurrent == NULL)     {         exit(0);     }     struct
一个整数阶乘N!末尾有多少个0
x_xiaoge的专栏
02-19 481
#include #include int Count0(int N) {     int ret = 0, i, j;     for(i = 1; i     {         j = i;         while(j % 5 == 0)         {             ret++;             j /= 5;
与树有关的一些名词
x_xiaoge的专栏
01-14 472
求数组的子数组之和的最大值
x_xiaoge的专栏
02-19 416
#include #include int MaxSum(int *A, int n) {     int maximum = -32566;     int sum, i, j, k;     for(i = 0; i     {         for(j = i; j         {             for(k = i; k
队列中取最大值操作问题
x_xiaoge的专栏
02-17 407
#include using namespace std; #include #include class stack { private:     int stackItem[1000];     int stackTop;     int link2NextMaxItem[1000];     int maxStackItemIndex; public:
求数组中最长递增子序列
x_xiaoge的专栏
02-19 393
#include #include #define MAXLENGTH 10 int LIS(int array[], int line[], int len) {     int i, j, k;     int LIS[MAXLENGTH];     int path[MAXLENGTH];     //1, -1, 2, -3, 4, -5, 6, -7
计算字符串的相似度
x_xiaoge的专栏
02-18 391
#include #include int minValue(int a, int b, int c) {     int min = ((a     return min; } int CalculateStringDistance(char* strA, int pABegin, int pAEnd, char* strB, int pBBegin, int pBEnd)
二元查找树的后序遍历结果
x_xiaoge的专栏
01-15 381
题目：输入一个整数数组，判断该数组是不是某二元查找树的后序遍历的结果。如果是返回true，否则返回false。 例如输入5、7、6、9、11、10、8，由于这一整数序列是如下树的后序遍历结果：          8        /  \       6    10     / \    / \    5   7   9  11 因此返回true。 如果输入7、4、6、5，没有
二叉树中节点的最大距离算法
求二叉树中节点的最大距离算法 二叉树是一种常见的数据结构，它广泛应用于计算机科学和信息技术领域。二叉树中节点的最大距离是指在二叉树中，两个节点之间的最长路径长度。这个问题是一个经典的算法问题，旨在找到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值