Cannot instantiate the type TreeNode

Question

package com.cnu.ds.tree;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class Tree {
    public static void main(String[] args) {
        TreeNode treeNode = new TreeNode();
        treeNode.t = 1;
        treeNode.left = new TreeNode();
        treeNode.left.t = 2;
        treeNode.right = new TreeNode();
        treeNode.right.t = 3;
        treeNode.left.left = new TreeNode();
        treeNode.left.left.t = 4;
        treeNode.left.right = new TreeNode();
        treeNode.left.right.t = 5;
        treeNode.right.left = new TreeNode();
        treeNode.right.left.t = 6;
        treeNode.right.right = new TreeNode();
        treeNode.right.right.t = 7;
        // //////////////////////
        treeNode.left.left.left = new TreeNode();
        treeNode.left.left.left.t = 8;
        treeNode.left.left.right = new TreeNode();
        treeNode.left.left.right.t = 9;

        treeNode.left.right.left = new TreeNode();
        treeNode.left.right.left.t = 10;

        treeNode.left.right.right = new TreeNode();
        treeNode.left.right.right.t = 11;

        treeNode.right.left.left = new TreeNode();
        treeNode.right.left.left.t = 12;
        treeNode.right.left.right = new TreeNode();
        treeNode.right.left.right.t = 13;

        treeNode.right.right.left = new TreeNode();
        treeNode.right.right.left.t = 14;

        treeNode.right.right.right = new TreeNode();
        treeNode.right.right.right.t = 15;

        levelOrder(treeNode);
        levelOrderReverse(treeNode);
    }

    public static void levelOrderReverse(TreeNode root) {
        Queue<TreeNode> treeNodes = new LinkedList<>();
        TreeNode newRoot = root;
        treeNodes.add(root);
        treeNodes.add(null);
        Stack<Integer> stack = new Stack<>();
        Queue<TreeNode> queue = new LinkedList<>();
        boolean flip = false;
        while (!treeNodes.isEmpty()) {
            root = treeNodes.remove();
            if (root == null) {
                if (flip) {
                    while (!queue.isEmpty()) {
                        root = queue.remove();
                        int r = stack.pop();
                        int l = stack.pop();
                        root.left.t = r;
                        root.right.t = l;
                    }
                }
                flip = !flip;
                if (treeNodes.isEmpty()) {
                    break;
                }
                System.out.println();
                treeNodes.add(null);
            } else {
                if (root.left != null) {
                    treeNodes.add(root.left);
                }
                if (null != root.right) {
                    treeNodes.add(root.right);
                }
                if (flip) {
                    stack.push(root.t);
                } else {
                    queue.add(root);
                }
            }
        }
        System.out.println();
        levelOrder(newRoot);
    }

    public static void levelOrder(TreeNode root) {
        Queue<TreeNode> treeNodes = new LinkedList<>();
        treeNodes.add(root);
        treeNodes.add(null);
        Queue<TreeNode> queue = new LinkedList<>();
        while (!treeNodes.isEmpty()) {
            root = treeNodes.remove();
            if (root == null) {
                if (treeNodes.isEmpty()) {
                    break;
                }
                System.out.println();
                treeNodes.add(null);
            } else {
                if (root.left != null) {
                    treeNodes.add(root.left);
                }
                if (null != root.right) {
                    treeNodes.add(root.right);
                }
                queue.add(root);
                System.out.print(root.t + " ");
            }
        }
    }
}

Output: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

1 3 2 4 5 6 7 15 14 13 12 11 10 9 8

the above is part of code snippet for the below problem suggested in the site. Reverse the alternate level nodes of the binary tree. a / \ b c / \ / \ d e f g / \ / \ / \ / \ h i j k l m n o

Modified tree: a / \ c b / \ / \ d e f g / \ / \ / \ / \ o n m l k j i h

initially i got error as "TreeNode cannot be resolved as a type" Then i imported java.swing after that am getting error as "Cannot instantiate the type TreeNode"

Please suggest

Martin Dinov · Answer 1 · 2014-07-19T09:25:05.440

0

You can't instantiate a TreeNode with new because TreeNode is an interface. You can however say:

TreeNode node = new SomeClass();

where SomeClass is a class that implements the TreeNode interface.

edited Jul 19 '14 at 09:25

answered Jul 19 '14 at 09:12

Martin Dinov

8,757
3
29
41

This code snippet is taken from the below link [Click Here](http://www.careercup.com/question?id=5068704572243968) they have published output even. Got confused – user3855506 Jul 19 '14 at 09:24

score 0 · Answer 2 · answered Jul 19 '14 at 09:44

0

TreeNode is an interface and interface can never be instantiated using the new operator or keyword. You can use the TreeNode as the object reference or handle but you will have to use some implementing class with new keyword for instance creation. Visit here to know more about TreeNode and its implementing classes.

answered Jul 19 '14 at 09:44

Niru

732
5
9

i understand its a interface,but how the above program successfully returns the mentioned output?/Am i missing anything here. – user3855506 Jul 19 '14 at 11:51

score 0 · Answer 3 · answered Jul 19 '14 at 10:15

0

You cann't instantiate an interface.TreeNode is an interface which can only be implemented or referenced to any class implementing TreeNode.

answered Jul 19 '14 at 10:15

Devavrata

1,785
17
30

score 0 · Answer 4 · answered Jul 29 '20 at 16:37

0

Try org.primefaces.model.DefaultTreeNode like this:

TreeNode root = new DefaultTreeNode("SomeID", null);

answered Jul 29 '20 at 16:37

Guilherme

877
9
16

Cannot instantiate the type TreeNode

4 Answers4