java leetcode TreeNode类、ListNode类的实现

本文转载自查看原文 2019-11-27 17:19 1412 java/ leetcode

TreeNode类

  1 package data.structure;
  2 
  3 import java.util.ArrayList;
  4 
  5 public class TreeNode {
  6     public int val;
  7     public TreeNode left;
  8     public TreeNode right;
  9     public TreeNode(int x) { val = x; }
 10 
 11     public static TreeNode makeTree(Integer[] trees) {
 12         if (trees.length == 0)
 13             return null;
 14         TreeNode[] treeNodes = new TreeNode[trees.length + 1];
 15         for (int i = 1; i < treeNodes.length; i++) {
 16             if (trees[i - 1] == null) {
 17                 treeNodes[i] = null;
 18             } else {
 19                 treeNodes[i] = new TreeNode(trees[i - 1]);
 20             }
 21         }
 22 
 23         TreeNode treeNode = null;
 24         //这个只适用于完全二叉树
 25 //        for (int i = 1; i < treeNodes.length; i++) {
 26 //            treeNode = treeNodes[i];
 27 //            if (treeNode == null) continue;
 28 //            if (2 * i < treeNodes.length)
 29 //                treeNode.left = treeNodes[2 * i];
 30 //            if (2 * i + 1 < treeNodes.length)
 31 //                treeNode.right = treeNodes[2 * i + 1];
 32 //        }
 33         for (int i = 1, index = 2; i < treeNodes.length && index < treeNodes.length; i++) {
 34             treeNode = treeNodes[i];
 35             if (treeNode == null) continue;
 36             treeNode.left = treeNodes[index];
 37             if (index + 1 < treeNodes.length)
 38                 treeNode.right = treeNodes[index + 1];
 39             index += 2;
 40         }
 41         return treeNodes[1];
 42     }
 43 
 44     //中序遍历
 45     public static ArrayList<Integer> middleTraverse(TreeNode treeNode) {
 46         ArrayList<Integer> arrayList = new ArrayList<>();
 47         if (treeNode == null) {
 48             arrayList.add(null);
 49         }else if (treeNode.left == null && treeNode.right == null) {
 50             arrayList.add(treeNode.val);
 51         } else {
 52             arrayList.add(treeNode.val);
 53             arrayList.addAll(middleTraverse(treeNode.left));
 54             arrayList.addAll(middleTraverse(treeNode.right));
 55         }
 56         return arrayList;
 57     }
 58 
 59     //前序遍历
 60     public static ArrayList<Integer> beforeTraverse(TreeNode treeNode) {
 61         ArrayList<Integer> arrayList = new ArrayList<>();
 62         if (treeNode == null) {
 63             arrayList.add(null);
 64         }else if (treeNode.left == null && treeNode.right == null) {
 65             arrayList.add(treeNode.val);
 66         } else {
 67             arrayList.addAll(beforeTraverse(treeNode.left));
 68             arrayList.add(treeNode.val);
 69             arrayList.addAll(beforeTraverse(treeNode.right));
 70         }
 71         return arrayList;
 72     }
 73 
 74     //后序遍历
 75     public static ArrayList<Integer> afterTraverse(TreeNode treeNode) {
 76         ArrayList<Integer> arrayList = new ArrayList<>();
 77         if (treeNode == null) {
 78             arrayList.add(null);
 79         }else if (treeNode.left == null && treeNode.right == null) {
 80             arrayList.add(treeNode.val);
 81         } else {
 82             arrayList.addAll(afterTraverse(treeNode.right));
 83             arrayList.add(treeNode.val);
 84             arrayList.addAll(afterTraverse(treeNode.left));
 85         }
 86         return arrayList;
 87     }
 88 
 89     //层序遍历
 90     public static ArrayList<Integer> sequenceTraverse(TreeNode root) {
 91         ArrayList<Integer> arrayList = new ArrayList<>();
 92         ArrayList<TreeNode> treeNodes = new ArrayList<>();
 93         treeNodes.add(root);
 94         arrayList.add(root.val);
 95         while (treeNodes.size() > 0) {
 96             ArrayList<TreeNode> subTreeNodes = new ArrayList<>();
 97             for (TreeNode value : treeNodes) {
 98                 if (value.left != null || value.right != null) {
 99                     if (value.left != null) {
100                         subTreeNodes.add(value.left);
101                         arrayList.add(value.left.val);
102                     } else {
103                         arrayList.add(null);
104                     }
105                     if (value.right != null) {
106                         subTreeNodes.add(value.right);
107                         arrayList.add(value.right.val);
108                     } else {
109                         arrayList.add(null);
110                     }
111                 }
112             }
113             treeNodes = subTreeNodes;
114         }
115         return arrayList;
116     }
117 }

调用makeTree将数组转换为一棵树

1 　　Integer[] integers = {1, 2, null, 8};
2 　　TreeNode treeNode = TreeNode.makeTree(integers);
3 　　//遍历打印
4 　　System.out.println(TreeNode.middleTraverse(treeNode));

ListNode类

package data.structure;

import java.util.ArrayList;

public class ListNode {
    public int val;
    public ListNode next;
    public ListNode(int x) {
        val = x;
        next = null;
    }

    //创建单链表
    public static ListNode makeNode(int[] nums) {
        if (nums.length == 0) return null;
        ListNode listNode = new ListNode(nums[0]);
        ListNode head = listNode;
        for (int i = 1; i < nums.length; i++) {
            ListNode node = new ListNode(nums[i]);
            listNode.next = node;
            listNode = node;
        }
        return head;
    }

    //创建循环链表
    public static ListNode makeNode(int[] nums, int pos) {
        if (nums.length == 0) return null;
        ListNode[] listNodes = new ListNode[nums.length];
        for (int i = 0; i < nums.length; i++) {
            listNodes[i] = new ListNode(nums[i]);
        }

        ListNode listNode = listNodes[0];
        for (int i = 1; i < listNodes.length; i++) {
            listNode.next = listNodes[i];
            listNode = listNodes[i];
        }
        if (pos >= 0 && pos < nums.length) {
            listNode.next = listNodes[pos];
        }
        return listNodes[0];
    }

    //创建两条相交链表
    public static ListNode[] makeIntersectNode(int[] listA, int skipA, int[] listB, int skipB) {
        if (listA.length == 0 || listB.length == 0) return null;
        ListNode[] nodesA = new ListNode[listA.length];
        for (int i = 0; i < nodesA.length; i++) {
            nodesA[i] = new ListNode(listA[i]);
        }
        ListNode nodeA = nodesA[0];
        for (int i = 1; i < nodesA.length; i++) {
            nodeA.next = nodesA[i];
            nodeA = nodesA[i];
        }

        ListNode[] nodesB = new ListNode[listB.length];
        for (int i = 0; i < nodesB.length; i++) {
            nodesB[i] = new ListNode(listB[i]);
        }
        ListNode nodeB = nodesB[0];
        for (int i = 1; i < nodesB.length; i++) {
            nodeB.next = nodesB[i];
            nodeB = nodesB[i];
        }

        if (skipA < listA.length && skipB < listB.length && listA[skipA] == listB[skipB]) {
            nodesB[skipB].next = nodesA[skipA];
        }

        ListNode[] nodes = new ListNode[2];
        nodes[0] = nodesA[0];
        nodes[1] = nodesB[0];
        return nodes;
    }

    //遍历链表
    public static ArrayList<Integer> traverse(ListNode head) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        while (head != null) {
            arrayList.add(head.val);
            head = head.next;
        }
        return arrayList;
    }
}

免责声明！

本站转载的文章为个人学习借鉴使用，本站对版权不负任何法律责任。如果侵犯了您的隐私权益，请联系本站邮箱yoyou2525@163.com删除。

猜您在找 【LeetCode】TreeNode类实现解析（java实现） Java HashMap类源码解析(续)-TreeNode Java list的实现类 Java实现Bag类 java Map及其实现类 java类为什么是单继承。类的继承，实现接口。 ListNode的python 实现 java类为什么要实现Serializable接口 Java 动态代理类的实现 Java中Queue类实现