精华内容
下载资源
问答
  • 算法思想步骤(整体的代码会和二叉树先序遍历算法相似) 若二叉树不空,首先复制根节点,类似于先序遍历访问根节点的语句 递归复制左子树 递归复制右子树 void CopyTree(BiTree T,BiTree NewT) { if(T==NULL)...

    算法思想步骤(整体的代码会和二叉树先序遍历算法相似)

    若二叉树不空,首先复制根节点,类似于先序遍历访问根节点的语句

    递归复制左子树

    递归复制右子树

    void CopyTree(BiTree T,BiTree NewT)
    {
        if(T==NULL)
        {
            NewT = NULL;
        }
        else
        {
            BiTree NewT = BiTree malloc(sizeof(BiNode));
            NewT->data = T->data;
            CopyTree(T->lchild,NewT->lchild);
            CopyTree(T->lchild,NewT->lchild);
        }
    }

    欢迎留言交流,若有错误或者疑问,欢迎指出

    展开全文
  • 文章目录思路Java 实现 思路 Java 对象满足深拷贝,直接赋值不就行了,为什么要复制呢? 确实,Java 的对象赋值满足深拷贝,类似 C 中的地址赋值,那这样直接 a=b 不...如何复制二叉树呢? 其实就是写一遍遍历而已 ...

    文章目录

    思路

    Java 对象满足深拷贝,直接赋值不就行了,为什么要复制呢?

    确实,Java 的对象赋值满足深拷贝,类似 C 中的地址赋值,那这样直接 a=b 不就行了,干嘛还要写复制的一个算法呢?因为我们的这个复制希望 a 的操作不会影响 b 这颗二叉树,但是 a 和 b 这两颗二叉树中保存到的数据值都是一样的,这就是我们复制的目的

    如何复制二叉树呢?

    其实就是写一遍遍历而已

    注意

    我们传参传被拷贝的结点 r 和一个拷贝到的结点 n,如果 r 结点本身就是 null,那如果我们传的 n 结点不为 null,在我们不写else n=null;时返回的 n 就不是空了,但我们期望它是空,这是一个小细节点,需要注意下,虽然不懈也不会影响代码逻辑,但是加上会显得代码更加严谨

    Java 实现

    // 结点
    class Node {
        int data;
        Node left = null;
        Node right = null;
    }
    
    // 二叉树
    public class BinaryTree {
        // 根结点
        private Node root;
        // 输入的数组
        private int[] arr_in;
        // 输出的数组
        private int[] arr_out;
        // 记录数组下标
        private static int index;
        
        // 初始化
        public BinaryTree(int[] arr) {
            root = new Node();
            this.arr_in = arr;
            arr_out = new int[arr.length];
            index = 0;
        }
    
        // 先序复制二叉树(递归)根→左→右
        public Node preorderCopyRecursion(Node r, Node n) {
            if (r) {
                n = new Node();
                n = r.data;
                preorderCopyRecursion(r.left, n.left);
                preorderCopyRecursion(r.right, n.right);
            }
            else
                n = null;
            return n;
        }
        
        // 中序复制二叉树(递归)左→根→右
        public Node inorderCopyRecursion(Node r, Node n) {
            if (r) {
                inorderCopyRecursion(r.left, n.left);
                n = new Node();
                n = r.data;
                inorderCopyRecursion(r.right, n.right);
            }
            else
                n = null;
            return n;
        }
    
        // 后序复制二叉树(递归)左→右→根
        public Node postorderCopyRecursion(Node r, Node n) {
            if (r) {
                postorderCopyRecursion(r.left, n.left);
                postorderCopyRecursion(r.right, n.right);
                n = new Node();
                n = r.data;
            }
            else
                n = null;
            return n;
        }
    }
    
    展开全文
  • 遍历二叉树的非递归算法用到一个栈,而复制的话用到两个栈,一个存被复制二叉树,一个存复制到的二叉树。新的二叉树永远跟着已经存在的二叉树的节奏走,已经存在的那颗二叉树找左结点,新的二叉树也找左结点,已经...

    文章目录

    思路

    怎么写呢?

    就是二叉树遍历的非递归算法,前几篇博文有讲

    后序遍历值得的注意点

    数据结构-二叉树(遍历二叉树的非递归算法)中有讲

    复制的非递归与遍历的非递归的区别

    遍历二叉树的非递归算法用到一个栈,而复制的话用到两个栈,一个存被复制的二叉树,一个存复制到的二叉树。新的二叉树永远跟着已经存在的二叉树的节奏走,已经存在的那颗二叉树找左结点,新的二叉树也找左结点,已经存在的二叉树入栈,新的二叉树也入栈。每次到根结点的时候就进行二叉树结点值的拷贝

    方法的返回

    拷贝方法返回新二叉树的根结点,我们需要在方法最开始把新二叉树的根结点赋值给一个新 Node,因为循环中用的是这个新 Node(存在 Node = Node->left 这样的操作),这样就不会影响最初的那个形参的值,我们最后也就可以大方的return n

    Java 实现

    // 结点
    class Node {
        int data;
        Node left = null;
        Node right = null;
    }
    
    // 二叉树
    public class BinaryTree {
        // 根结点
        private Node root;
        // 输入的数组
        private int[] arr_in;
        // 输出的数组
        private int[] arr_out;
        // 记录数组下标
        private static int index;
        
        // 初始化
        public BinaryTree(int[] arr) {
            root = new Node();
            this.arr_in = arr;
            arr_out = new int[arr.length];
            index = 0;
        }
        
        // 先序复制二叉树(非递归)根→左→右
        public Node preorderCopy(Node r, Node n) {
            Stack rStack = new Stack();
            Stack nStack = new Stack();
            Node rNode = r;
            Node nNode = n;
            while (rNode || !rStack.empty()) {
                if (rNode) {
                    rStack.push(rNode);
                    nNode = new Node();
                    nStack.push(nNode);
                    // 根
                    nNode.data = rNode.data;
                    // 左
                    rNode = rNode.left;
                    nNode = nNode.left;
                }
                else {
                    Node rTop = rStack.pop();
                    Node nTop = nStack.pop();
                    // 右
                    rNode = rTop.right;
                    nNode = nTop.right;
                }
            }
            return n;
        }
    
        // 中序复制二叉树(非递归)左→根→右
        public Node inorderCopy(Node r, Node n) {
            Stack rStack = new Stack();
            Stack nStack = new Stack();
            Node rNode = r;
            Node nNode = n;
            while (rNode || !rStack.empty()) {
                if (rNode) {
                    rStack.push(rNode);
                    nNode = new Node();
                    nStack.push(nNode);
                    // 左
                    rNode = rNode.left;
                    nNode = nNode.left;
                }
                else {
                    Node rTop = rStack.pop();
                    Node nTop = nStack.pop();
                    // 根
                    nTop.data = rTop.data;
                    // 右
                    rNode = rNode.right;
                    nNode = nNode.right;
                }
            }
            return n;
        }
        
        // 后序复制二叉树(非递归)左→右→根
        public Node postorderCopy(Node r, Node n) {
            Stack rStack = new Stack();
            Stack nStack = new Stack();
            Node rNode = r;
            Node nNode = n;
            Node rTop;
            Node nTop;
            while (rNode || !rStack.empty()) {
                if (rNode) {
                    rStack.push(rNode);
                    rNode = new Node();
                    rStack.push(rNode);
                    // 左
                    rNode = rNode.left;
                    nNode = nNode.left;
                }
                else {
                    if (rStack.peek().right != null && rStack.peek().right != rTop) {
                        // 右
                        rNode = rNode.right;
                        nNode = nNode.right;
                    }
                    else {
                        rTop = rStack.pop();
                        nTop = nStack.pop();
                        // 根
                        nTop.data = rTop.data;
                        rNode = rStack.peek();
                        nNode = nStack.peek();
                    }
                }
            }
            return n;
        }
    }
    
    展开全文
  • 二叉树采用二叉链表存储,试写出复制一棵二叉树算法。 话不多说上代码: #include #include typedef struct BiTnode {  int data;  struct BiTnode* Lchild,*Rchild; }BiTnode,*...

    二叉树采用二叉链表存储,试写出复制一棵二叉树的算法。

    话不多说上代码:

    #include<stdio.h>

    #include<stdlib.h>

    typedef struct BiTnode  

    {  

            int data;  

            struct BiTnode* Lchild,*Rchild;   

    }BiTnode,*BiTree;  

      

    void create(BiTree &S)  

    {  

            char ch;  

            char temp;  

            scanf("%c",&ch);  

            temp=getchar();  

            if(ch=='#')  

            {  

                    S=NULL;  

            }  

            else  

            {  

                    S=(BiTree)malloc(sizeof(BiTnode) );  

                    if(!S)  

                    {  

                        exit(0);  

                    }  

                    else  

                    {  

                            S->data=ch;  

                             

                            create(S->Lchild);  

                            

                            create(S->Rchild);  

                    }  

      

            }  

            return;  

      

    }

     void Traverse(BiTree T)  

    {  

            if(NULL==T)  

            {  

                    return;  

            }  

            else  

            {  

                printf("%c ",T->data);  

                Traverse(T->Lchild);  

                Traverse(T->Rchild);  

            }  

      

    }  

      

     

    void CopyTree(BiTree S,BiTree &T){

    BiTree lptr,rptr;

        if (!S) T=NULL;

        else{

            CopyTree(S->Lchild,lptr);        CopyTree(S->Rchild,rptr);  

              

                T=(BiTree)malloc(sizeof(BiTnode) );

            T->data=S->data;

            T->Lchild=lptr;T->Rchild=rptr;

        }

    }

    int main()

    {  

         BiTree T;BiTree S;

     printf("创建一个树\n");        

         create(S);

         printf("遍历该树\n");

     Traverse(S);     

         printf("\n");

         printf("拷贝该树\n");

         CopyTree(S,T);

         Traverse(T);

         return 0;

     } 

    展开全文
  • 用递归算法复制二叉树

    千次阅读 多人点赞 2019-04-16 20:58:27
    最近做了一个简单的小问题如何复制一棵二叉树,自己在网上看了一些技术大佬写的总感觉写的有些复杂,所以自己尝试了一下。以想到关于二叉树算法问题,我觉得我们就应该去思考用递归的思想去试一下。所以经过思考...
  • 复制二叉树

    2020-08-01 18:35:39
    //算法5.4 复制二叉树 #include <iostream> using namespace std; //二叉树的二叉链表存储表示 typedef struct BiNode { char data; //结点数据域 struct BiNode *lchild, *rchild; //左右孩子指针 } ...
  • 二叉树算法系列文章 算法知识梳理(11) - 二叉树相关算法第一部分 算法知识梳理(12) - 二叉树相关算法第二部分 算法知识梳理(13) - 二叉树相关算法第三部分 一、概述 二叉树算法第二部分内容包括以下几个主题: 获得...
  • 复制一颗二叉树,先复制其根结点,再复制左子树,最后复制右子树,从而复制完成; 实现代码: # -*- coding:utf-8 -*- class BiTNode(): def __init__(self): self.data = None self.lchild = Non...
  • 二叉树算法系列文章 算法知识梳理(11) - 二叉树相关算法第一部分 算法知识梳理(12) - 二叉树相关算法第二部分 算法知识梳理(13) - 二叉树相关算法第三部分 一、概述 二叉树算法第三部分内容包括以下几个主题: 将...
  • 二叉树的定义 二叉树的主要性质 使用Javascript实现二叉查找树 二叉查找树的遍历 1. 中序遍历 2. 先序遍历 3. 后序遍历 查找结点 查找最大值和最小值结点 删除结点 写在前面 树是计算机科学中经常用到的...
  • 重建二叉树算法题Java实现题目描述问题分析代码及讲解总结 题目描述 题目描述 输入某二叉树的前序遍历和中序遍历的结果,请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序...
  • 下面使用JavaScript语言实现二叉树的三种遍历算法。  首先构造一个排序二叉树(即满足左子节点比父节点小,右子节点比父节点大的二叉树),然后对其分别进行中序、前序、后序遍历。 排序二叉树结构图如下...
  • 内容衔接上一章 数据结构与算法:常见排序算法 内容提要 什么是树  - 为什么使用树 二叉树 二叉查找树 红黑树 B、B+树 堆 伸展树 树 可以点击链接感受下笔者用d3.js画的tree https://codepen.io/AlexZ33/pe... ...
  • 编写复制一棵二叉树的非递归算法编写复制一棵二叉树的非递归算法编写复制一棵二叉树的非递归算法编写复制一棵二叉树的非递归算法编写复制一棵二叉树的非递归算法编写复制一棵二叉树的非递归算法编写复制一棵二叉树的...
  • Python程序员面试算法宝典---解题总结: 第三章 二叉树 3.9 如何复制二叉树 题目: 给定一个二叉树根结点,复制该树,返回新建树的根结点 分析: 可以先复制根节点,然后复制左子树,复制右子树; 对于左子树,对左...
  • 二叉树 在计算机科学中,二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”(left subtree)和“右子树”(right subtree)。二叉树常被用于实现二叉查找树和二叉堆。 一棵深度为k,且有2^k-1个...
  • 所有函数用到的树节点定义均如下: typedef struct node { char data; struct node *lchild;...二叉树的递归遍历 前序递归遍历 void preorder(NODE *root) { if(root != ...
  • javascript数据结构及实现二叉树算法

    千次阅读 2017-09-08 21:53:15
    javascript数据结构及实现二叉树算法 今天学了慕课网coding迪斯尼 老师的Javascript实现二叉树算法课程,感觉很有意思,既加深了对js的了解,也理解了二叉树算法原理,实在受益匪浅,特将学习过程整理成一篇学习...
  • Node节点的定义 /** * Definition for a binary tree node.*/...模拟先序遍历,一个一个复制, 从根节点开始 错误版本: // 错误,js里面不存在传递地址引用 var copyBinaryTree = (node, newTree = null) => {
  • 二叉树基本算法

    2018-04-04 23:08:43
    附上代码://二叉树的存储和遍历,创建二叉树,后序的直接加上函数和算法 #include usingnamespace std; typedefstruct Node{   char data;   struct Node *lchild,*rchild; }*Bitree; //创建二叉
  • 待我学有所成,结发与蕊可好。... 一、算法程序组建目录结构如下: 第一部分:头文件 1. c1.h 2. c3-3.h 3. c6-1.h 4. c6-2.h 5. c6-3.h 6. c6-4.h 7. c6-5.h 8. c6-7.h 第二部分:主程序入口文
  • 二叉树 在计算机科学中,二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”(left subtree)和“右子树”(right subtree)。二叉树常被用于实现二叉查找树和二叉堆。 一棵深度为k,且有2^k-1个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,720
精华内容 13,488
关键字:

复制二叉树的算法