使用Java如何实现树的同构？

2021-06-22 16:24:53 浏览数 (2161)
今天给大家带来的是如何使用Java如何实现树的同构，希望能够给你们提供一些思路。
给定两棵树r1、r2，如果r1可以通过若干次的左子树和右子树互换，使之与r2完全相同，这说明两者同构。

举例


树的构造

树可以由数组或链表来构造：举例：上图左上角的树通过数组可表示为

0 1 2 3 4 5 6 7 8 9 10 11 12
A B C D E G - - - F - H -

该方式浪费了部分空间，但适合表示完全二叉树

链表方式则比较直观

除上述两种方式外，还可以采用“类数组”的方式

  1. public static class Node{
  2.         String data;
  3.         int left;
  4.         int right;
  5.          }

举例：上图左上角的树可表示为

数组索引 data left right
0 A 1 2
1 B 3 4
2 C 6 -
3 D - -
4 E 5 -
5 F - -
6 G 7 -
7 H - -

本文的树结构使用了第三种方式

终端输入：

A,1,2B,3,-C,-,-D,-,-A,2,1B,3,-C,-,-D,-,-
  1. public class TongGou {
  2.     private Scanner scanner;
  3.     public TongGou(){
  4.         scanner = new Scanner(System.in);
  5.     }
  6.     //树结构
  7.     public static class Node{
  8.         String data;
  9.         int left;
  10.         int right;
  11.     }
  12.     /**
  13.      * 创建树
  14.      * @param nodes
  15.      * @return
  16.      */
  17.     public int createTree(Node[] nodes){
  18.         int N = nodes.length;
  19.         int root = -1;
  20.         int[] check = new int[N];
  21.         Arrays.fill(check,0);  //初始化为0
  22.         for (int i=0;i<N;i++){
  23.             //输入格式  data,left,right
  24.             String next = scanner.next();
  25.             String[] inputList = next!=null?next.split(","):null;
  26.             if(inputList!=null&&inputList.length==3){
  27.                 nodes[i] = new Node();
  28.                 int  left = "-".equals(inputList[1])?-1:Integer.parseInt(inputList[1]);
  29.                 int  right = "-".equals(inputList[2])?-1:Integer.parseInt(inputList[2]);
  30.                 nodes[i].data = inputList[0];
  31.                 nodes[i].left = left;
  32.                 nodes[i].right = right;
  33.                 if(left>0) {
  34.                     check[left] = 1;
  35.                 }
  36.                 if(right>0){
  37.                     check[right] = 1;
  38.                 }
  39.             }
  40.         }
  41.         for(int i=0;i<check.length;i++){
  42.             if(check[i]==0&&nodes[i].data!=null){
  43.                 root = i;
  44.                 break;
  45.             }
  46.         }
  47.         return root;
  48.     }
  49.     /**
  50.      * 判断同构
  51.      * @param r1
  52.      * @param r2
  53.      * @return
  54.      */
  55.     public boolean isomorphic(int r1,int r2,Node[] t1,Node[] t2){
  56.         //须注意不要漏掉逻辑！
  57.         //两个根节点均为null，必同构
  58.         if ((r1 == -1) && (r2 == -1)) {
  59.             return true;
  60.         }
  61.         //一个非空 另一个空，必不同构
  62.         if(((r1==-1)&&(r2!=-1))||((r1!=-1)&&(r2==-1))){
  63.             return false;
  64.         }
  65.         //两个节点非空 但值不同，必不同构
  66.         if(!t1[r1].data.equals(t2[r2].data)){
  67.             return false;
  68.         }
  69.         //两根节点的左孩子为空条件下，则须判断两根节点的右子树是否同构
  70.         if(t1[r1].left==-1&&t2[r2].left==-1){
  71.             return isomorphic(t1[r1].right,t2[r2].right,t1,t2);
  72.         }
  73.         //两根节点的左孩子不为空且左孩子的值也相同，须判断两根节点的左子树是否同构以及两根节点的右子树是否同构
  74.         //如果左右子树均同构，则整棵树同构
  75.         if((t1[r1].left!=-1&&t2[r2].left!=-1)&&(t1[t1[r1].left].data.equals(t2[t2[r2].left].data))){
  76.             return isomorphic(t1[r1].left,t2[r2].left,t1,t2)&&isomorphic(t1[r1].right,t2[r2].right,t1,t2);
  77.         }else{
  78.             //分两种情况解释：
  79.             //1、两根节点的左孩子不为空，但左孩子的值不同
  80.             //例如：t1[r1.left].data!=t2[r2.left].data。但有t1[r1.left].data==t2[r2.right].data、t1[r1.right].data==t2[r2.left].data
  81.             //即有可能r1的左子树与r2的右子树同构、r1的右子树与r2的左子树同构
  82.             //故须判断r1的左子树是否与r2的右子树同构,以及r1的右子树是否与r2的左子树同构
  83.             //2、两根节点的左孩子一个为空，一个不为空
  84.             //例如：r1.left==-1、r2.left!=-1，如果r2.right==-1,显然r1的左子树与r2的右子树同构，此时则有可能r1的右子树与r2的左子树同构
  85.             //故须判断r1的左子树是否与r2的右子树同构,以及r1的右子树是否与r2的左子树同构
  86.             return isomorphic(t1[r1].left,t2[r2].right,t1,t2)&&isomorphic(t1[r1].right,t2[r2].left,t1,t2);
  87.         }
  88.     }
  89.     public static void main(String[] args) {
  90.         TongGou tongGou = new TongGou();
  91.         Node[] nodes = new Node[4];
  92.         Node[] nodes1 = new Node[4];
  93.         int tree1 = tongGou.createTree(nodes);
  94.         System.out.println();
  95.         int tree2 = tongGou.createTree(nodes1);
  96.         boolean isomorphic = tongGou.isomorphic(tree1, tree2, nodes, nodes1);
  97.         System.out.println(isomorphic);
  98.     }
  99. }

到此这篇关于Java如何实现树的同构?的文章就介绍到这了。