//算法5.4 复制二叉树
#include <iostream>
using namespace std;

//二叉树的二叉链表存储表示
typedef struct BiNode
{
    char data;                      //结点数据域
    struct BiNode *lchild, *rchild; //左右孩子指针
} BiTNode, *BiTree;

//用算法5.3建立二叉链表
void CreateBiTree(BiTree &T)
{
    //按先序次序输入二叉树中结点的值（一个字符），创建二叉链表表示的二叉树T
    char ch;
    cin >> ch;
    if (ch == '#')
        T = NULL; //递归结束，建空树
    else
    {
        T = new BiTNode;
        T->data = ch;            //生成根结点
        CreateBiTree(T->lchild); //递归创建左子树
        CreateBiTree(T->rchild); //递归创建右子树
    }                            //else
} //CreateBiTree

void Copy(BiTree T, BiTree &NewT)
{
    if (T == NULL)
    { //如果是空树，递归结束
        NewT = NULL;
        return;
    }
    else
    {
        NewT = new BiTNode;
        NewT->data = T->data;          //复制根结点
        Copy(T->lchild, NewT->lchild); //递归复制左子树
        Copy(T->rchild, NewT->rchild); //递归复制右子树
    }                                  //else
} //CopyBiTree

//用算法5.1 中序遍历的递归算法
void InOrderTraverse(BiTree T)
{
    //中序遍历二叉树T的递归算法
    if (T)
    {
        InOrderTraverse(T->lchild);
        cout << T->data;
        InOrderTraverse(T->rchild);
    }
}
int main()
{
    BiTree tree, new_tree;
    cout << "请输入建立二叉树的序列：\n";
    CreateBiTree(tree);
    Copy(tree, new_tree);
    cout << "复制得到的新树的中序序列：\n";
    InOrderTraverse(new_tree);
    cout << endl;
}


运行结果：

python实现复制二叉树
google笔试题
题目描述:
给定一个二叉树根结点，复制该树，返回新建树的根结点 。
分析与解答:
用给定的二叉树的根结点 root来构造新的二叉树的方法为:首先创建新的结点 dupTree,
然后根据 root 结点来构造 dupTree 结点( dupTree.data=root.data)， 最后分别用 root 的左右子 树来构造 dupTree 的左右子树。 根据这个思路可以实现二叉树的复制，使用递归方式实现的 代码如下:
class BiTNode:     def __init__(self):         self.data=None         self.lchild=None         self.rchild=None def creatDupTree(root):     if root==None:         return None     dupTree=BiTNode()     dupTree.data=root.data     dupTree.lchild=creatDupTree(root.lchild)     dupTree.rchild=creatDupTree(root.rchild)     return dupTree def printreemidorder(root):     if root==None:         return     if root.lchild!=None:         printreemidorder(root.lchild)     print(root.data)     if root.rchild!=None:         printreemidorder(root.rchild) def constructTree():     root=BiTNode()     node1=BiTNode()     node2=BiTNode()     node3=BiTNode()     node4=BiTNode()     root.data=6     node1.data=3     node2.data=-7     node3.data=-1     node4.data=9     root.lchild=node1     root.rchild=node2     node1.lchild=node3     node1.rchild=node4     node2.lchild=node2.rchild=node3.lchild=node3.rchild=     node4.lchild=node4.rchild=None     return root if __name__=='__main__':     root1=constructTree()     root2=creatDupTree(root1)     print('原始二叉树中序遍历')     printreemidorder(root1)     print('n')     print('新的二叉树中序遍历')     printreemidorder(root2)
原始二叉树中序遍历 -1 3 9 6 -7   新的二叉树中序遍历 -1 3 9 6 -7

我正在尝试使用预遍历遍历来复制二叉树，但是我被卡住了。
由于我没有将任何值放入新树中，因此它们显然无法正确复制...
public class Node{
int key;
String name;
Node leftChild;
Node rightChild;
Node(int key, String name){
this.key = key;
this.name = name;
}
public class BinaryTree{
public Node root;
public void copyTree(Node focusNode){
if(focusNode != null){
Node copyNode = new Node(focusNode.key, focusNode.name);
//System.out.println(copyNode);
copyTree(focusNode.leftChild);
copyTree(focusNode.rightChild);
}
}
}
参考方案
这是一个解决方案。为了演示目的，我在toString()类中添加了Node方法。
class Node {
int key;
String name;
Node leftChild;
Node rightChild;
Node(int key, String name) {
this.key = key;
this.name = name;
}
public String toString() {
return "[" + key + "," + name + "]";
}
}
BinaryTree也作了轻微修改：
class BinaryTree {
public Node root;
public BinaryTree copyTree(Node focusNode) {
BinaryTree bt = new BinaryTree();
bt.root = preOrderCopy(focusNode);
return bt;
}
public static void preOrderPrint(BinaryTree t) {
preOrderPrint(t.root);
}
public static void preOrderPrint(Node n) {
if (n == null) {
// base case
return;
}
System.out.println(n);
preOrderPrint(n.leftChild);
preOrderPrint(n.rightChild);
}
private Node preOrderCopy(Node focusNode) {
if (focusNode == null) {
// base case
return null;
}
Node copy = new Node(focusNode.key, focusNode.name);
copy.leftChild = preOrderCopy(focusNode.leftChild);
copy.rightChild = preOrderCopy(focusNode.rightChild);
return copy;
}
}
为了测试代码，我根据Wikipedia page for Tree Traversal上显示的内容创建了一个BinaryTree。这是此示例中使用的树的图片：
此示例的正确预购遍历为：F, B, A, D, C, E, G, I, H。您可以使用以下代码来测试此实现：
public class NodeTest {
public static void main(String[] args) {
BinaryTree bt = new BinaryTree();
Node a = new Node(1, "A");
Node b = new Node(2, "B");
Node c = new Node(3, "C");
Node d = new Node(4, "D");
Node e = new Node(5, "E");
Node f = new Node(6, "F");
Node g = new Node(7, "G");
Node h = new Node(8, "H");
Node i = new Node(9, "I");
f.leftChild = b;
b.leftChild = a;
b.rightChild = d;
d.leftChild = c;
d.rightChild = e;
f.rightChild = g;
g.rightChild = i;
i.leftChild = h;
bt.root = f;
System.out.println("Print full tree:");
BinaryTree.preOrderPrint(bt.copyTree(f));
System.out.println("Only print f's left sub-tree:");
BinaryTree.preOrderPrint(bt.copyTree(f.leftChild));
}
}
运行上面的代码将产生以下输出：
Print full tree:
[6,F]
[2,B]
[1,A]
[4,D]
[3,C]
[5,E]
[7,G]
[9,I]
[8,H]
Only print f's left sub-tree:
[2,B]
[1,A]
[4,D]
[3,C]
[5,E]
Java-同步无助于互斥 - java
我有一个程序，其中Main类将创建几个Node类资源，其中包含一个可运行线程，该线程在创建Node类资源时执行。我有一个Receive类使用的共享资源Node类。但是当几个Node资源从Resource类到达同步方法rcv()时，程序没有考虑互斥，并且输出是来自不同Node类不同部分的汞合金public class Main { //field //meth…Java Double与BigDecimal - java
我正在查看一些使用双精度变量来存储(360-359.9998779296875)结果为0.0001220703125的代码。 double变量将其存储为-1.220703125E-4。当我使用BigDecimal时，其存储为0.0001220703125。为什么将它双重存储为-1.220703125E-4？ 参考方案 我不会在这里提及精度问题，而只会提及数字…java:继承 - java
有哪些替代继承的方法？ java大神给出的解决方案 有效的Java：偏重于继承而不是继承。 (这实际上也来自“四人帮”)。他提出的理由是，如果扩展类未明确设计为继承，则继承会引起很多不正常的副作用。例如，对super.someMethod()的任何调用都可以引导您通过未知代码的意外路径。取而代之的是，持有对本来应该扩展的类的引用，然后委托给它。这是与Eric…Java:BigInteger，如何通过OutputStream编写它 - java
我想将BigInteger写入文件。做这个的最好方式是什么。当然，我想从输入流中读取(使用程序，而不是人工)。我必须使用ObjectOutputStream还是有更好的方法？目的是使用尽可能少的字节。谢谢马丁 参考方案 Java序列化(ObjectOutputStream / ObjectInputStream)是将对象序列化为八位字节序列的一种通用方法。但…Java-如何将此字符串转换为日期？ - java
我从服务器收到此消息，我不明白T和Z的含义，2012-08-24T09:59:59Z将此字符串转换为Date对象的正确SimpleDateFormat模式是什么？ java大神给出的解决方案 这是ISO 8601标准。您可以使用SimpleDateFormat simpleFormat = new SimpleDateFormat("yyyy-MM…

python实现复制二叉树
google笔试题

题目描述:

给定一个二叉树根结点，复制该树，返回新建树的根结点 。

分析与解答:

用给定的二叉树的根结点 root来构造新的二叉树的方法为:首先创建新的结点 dupTree,

然后根据 root 结点来构造 dupTree 结点( dupTree.data=root.data)， 最后分别用 root 的左右子 树来构造 dupTree 的左右子树。 根据这个思路可以实现二叉树的复制，使用递归方式实现的 代码如下:
class BiTNode:
    def __init__(self):
        self.data=None
        self.lchild=None
        self.rchild=None
def creatDupTree(root):
    if root==None:
        return None
    dupTree=BiTNode()
    dupTree.data=root.data
    dupTree.lchild=creatDupTree(root.lchild)
    dupTree.rchild=creatDupTree(root.rchild)
    return dupTree
def printreemidorder(root):
    if root==None:
        return
    if root.lchild!=None:
        printreemidorder(root.lchild)
    print(root.data)
    if root.rchild!=None:
        printreemidorder(root.rchild)
def constructTree():
    root=BiTNode()
    node1=BiTNode()
    node2=BiTNode()
    node3=BiTNode()
    node4=BiTNode()
    root.data=6
    node1.data=3
    node2.data=-7
    node3.data=-1
    node4.data=9
    root.lchild=node1
    root.rchild=node2
    node1.lchild=node3
    node1.rchild=node4
    node2.lchild=node2.rchild=node3.lchild=node3.rchild=\
    node4.lchild=node4.rchild=None
    return root
if __name__=='__main__':
    root1=constructTree()
    root2=creatDupTree(root1)
    print('原始二叉树中序遍历')
    printreemidorder(root1)
    print('\n')
    print('新的二叉树中序遍历')
    printreemidorder(root2)

原始二叉树中序遍历
-1
3
9
6
-7


新的二叉树中序遍历
-1
3
9
6
-7