用递归法把二叉树的叶子结点按从左到右的顺序连成一个单链表

一、例子

1.png

上图中的二叉树的叶子结点,按从左到右的顺序连成的单链表如下图所示:

2.png

二、定义数据结构

typedef struct tree
{
    int data;
    struct tree *left;
    struct tree *right;
}node, *pnode;

pnode firstLeaf;    // 记录叶子链表的第一个叶子结点
pnode pcur;     // 记录叶子链表的当前结点

三、核心算法

void leafLink(pnode root)
{
    if(!root)
    {
        return;
    }

    if(NULL == root->left && NULL == root->right)
    {
        if(NULL == firstLeaf)
        {
            firstLeaf = root; // 保存找到的第一个叶子结点(k指针)
            pcur = firstLeaf;
        }
        else
        {
            // 链接时用叶子结点的rchild域存放指针
            pcur->right = root;
            pcur = pcur->right;
        }
    }

    if(root->left)
    {
        leafLink(root->left);
    }

    if(root->right)
    {
        leafLink(root->right);
    }
}

四、完整代码

#include <stdio.h>
#include <malloc.h>

typedef struct tree
{
    int data;
    struct tree *left;
    struct tree *right;
}node, *pnode;

pnode firstLeaf;
pnode pcur;

pnode createTreeNode(int data)
{
    pnode n=(pnode)malloc(sizeof(pnode));
    n->data = data;
    n->left = NULL;
    n->right = NULL;

    return n;
}

void inorder(pnode p)
{
    if (NULL == p)
    {
        return;
    }
    inorder(p->left);
    printf("%d  ", p->data);
    inorder(p->right);
}

void leafLink(pnode root)
{
    if(!root)
    {
        return;
    }

    if(NULL == root->left && NULL == root->right)
    {
        if(NULL == firstLeaf)
        {
            firstLeaf = root; // 保存找到的第一个叶子结点(k指针)
            pcur = firstLeaf;
        }
        else
        {
            // 链接时用叶子结点的rchild域存放指针
            pcur->right = root;
            pcur = pcur->right;
        }
    }

    if(root->left)
    {
        leafLink(root->left);
    }

    if(root->right)
    {
        leafLink(root->right);
    }
}

int main()
{
    pnode p1 = createTreeNode(7);
    pnode p2 = createTreeNode(1);
    pnode p3 = createTreeNode(9);
    pnode p4 = createTreeNode(5);
    pnode p5 = createTreeNode(8);
    pnode p6 = createTreeNode(3);
    pnode p7 = createTreeNode(6);
    pnode p8 = createTreeNode(2);
    pnode p9 = createTreeNode(4);

    p1->left = p2;
    p1->right = p3;

    p2->right = p4;

    p3->left = p5;

    p4->left = p6;
    p4->right = p7;

    p6->left = p8;
    p6->right = p9;

    printf("The inorder traversal sequence: ");
    inorder(p1);
    printf("\n");

    leafLink(p1);
    printf("The leaves linked list sequence: ");
    while(firstLeaf)
    {
        if(firstLeaf->right)
        {
            printf("%d-->",firstLeaf->data);
        }
        else
        {
            printf("%d",firstLeaf->data);
        }
        firstLeaf=firstLeaf->right;
    }
    printf("\n");

    return 0;
}

运行结果

The inorder traversal sequence: 1 2 3 4 5 6 7 8 9
The leaves linked list sequence: 2-->4-->6-->8


TopCoder & Codeforces & AtCoder交流QQ群:648202993
更多内容请关注微信公众号
wechat_public.jpg

  • 6
    点赞
  • 49
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 将二叉树的叶节点按从左到右顺序连接成一个单链表,可以采用深度优先搜索的方,先遍历左子树,再遍历右子树,最后将叶节点连接成链表。 具体步骤如下: 1. 如果当前节点为空,则返回。 2. 如果当前节点是叶节点,则将其加入链表中。 3. 递归遍历左子树。 4. 递归遍历右子树。 5. 返回链表的头节点。 代码实现如下: ``` class Solution { public: TreeNode* pre = NULL; TreeNode* head = NULL; TreeNode* convert(TreeNode* root) { if (root == NULL) return NULL; if (root->left == NULL && root->right == NULL) { if (pre == NULL) head = root; else pre->right = root; pre = root; return NULL; } root->left = convert(root->left); root->right = convert(root->right); return head; } }; ``` 其中,pre表示当前链表的尾节点,head表示链表的头节点。在遍历到叶节点时,将其加入链表中,并更新pre指针。最后返回head指针即可。 ### 回答2: 将二叉树的叶结点按从左到右顺序连成一个单链表,需要按照以下步骤: 1. 判断二叉树根节点是否为空,若为空则直接返回空链表; 2. 判断根节点的左右子树是否为空,若左右子树都为空,则将根节点作为叶节点加入到链表中; 3. 若左子树为空,递归处理右子树; 4. 若右子树为空,递归处理左子树; 5. 若左右子树都不为空,则递归处理左右子树,将左子树的叶节点和右子树的叶节点分别按照顺序连接到一起,并将根节点从链表中删除,返回新的链表头节点。 代码实现如下: ``` struct TreeNode { int val; TreeNode *left, *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; ListNode* leafList(TreeNode* root) { if (!root) return NULL; if (!root->left && !root->right) return new ListNode(root->val); ListNode *leftList = leafList(root->left); ListNode *rightList = leafList(root->right); if (!leftList) return rightList; if (!rightList) return leftList; ListNode *cur = leftList; while (cur->next) cur = cur->next; cur->next = rightList; delete root; return leftList; } ``` 该函数传入二叉树的根节点,返回链表的头节点。时间复杂度为O(n),空间复杂度为O(logn)。 ### 回答3: 首先,需要了解什么是二叉树单链表二叉树是一种树形结构,其中每个节点最多有两个子节点,即左子树和右子树。而单链表是一种线性结构,每个节点都只有一个后继节点。 将二叉树的叶结点按照从左到右顺序连成一个单链表,可以通过递归遍历二叉树实现。 首先,判断当前节点是否为叶结点,如果是,则将该节点加入到单链表中。如果不是叶结点,则递归遍历其左子树和右子树。 为了将左右子树的叶结点按照从左到右顺序加入到单链表中,可以采用一个辅助函数,该函数的作用是将两个单链表合并成一个单链表。合并时,需要遍历第一个单链表,找到其最后一个节点,然后将第二个单链表接在其后面。 最后,递归返回时,返回合并后的单链表即可。 具体实现可以参考以下代码: ``` struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; ListNode* mergeLists(ListNode* head1, ListNode* head2) { if (!head1 || !head2) { return head1 ? head1 : head2; } ListNode* cur = head1; while (cur->next) { cur = cur->next; } cur->next = head2; return head1; } ListNode* convert(TreeNode* root) { if (!root) { return NULL; } if (!root->left && !root->right) { return new ListNode(root->val); } ListNode* leftList = convert(root->left); ListNode* rightList = convert(root->right); return mergeLists(leftList, rightList); } ``` 以上代码中,convert函数用于将二叉树的叶结点转换成单链表,mergeLists函数用于合并两个单链表。使用时,只需要调用convert(root)即可。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值