Question

我已经提到了很多帖子和答案，但仍然无法获得有效的代码。下面是java中BST的排序链表的代码。包括链表的所有辅助函数。

我得到的输出不是预期的，例如root：4，root.left是2，root.right再次是4。我想输出应该是root：4，root.left是2而root.right是6

class LNode {
    public int data;
    public LNode next;

    LNode(int newData) {
        this.data = newData;
    }
}

class Node {

    int data;
    Node left;
    Node right;
    public Node prev;

    Node(int d) {
        data = d;
        left = right = null;
    }
}

class LinkedList {
    LNode first;
    LNode head;
    LNode newNode;

    public LinkedList() {
        first = null;
    }

    public void insertAtBeginning(int x) {
        newNode = new LNode(x);
        if (first != null) {
            newNode.next = first;
            first = newNode;
            head = first;
        } else {
            first = newNode;
            head = first;
        }
    }

    public void printList()

    {
        head = first;
        while (first != null) {
            System.out.print(first.data + " --> ");
            first = first.next;
        }
        System.out.println("null");
        first = head;

    }
}

public class LLtoBST {
    public static Node root;
    //public static LNode first;

    public static Node sortedListToBST(LNode first, int end) {

        return sortedListToBST(first, 0, end);
    }

    public static Node sortedListToBST(LNode first, int start, int end) {

        if (start > end)
            return null;
        if (first != null) {
            int mid = start + (end - start) / 2;

            Node lnode = sortedListToBST(first, start, mid - 1);

            root = new Node(first.data);

            first = first.next;
            Node rnode = sortedListToBST(first, mid + 1, end);

            root.left = lnode;
            root.right = rnode;

        }
        return root;

    }

    public static void main(String... args) {
        LinkedList list = new LinkedList();
        int n = 0;
        list.insertAtBeginning(7);
        list.insertAtBeginning(6);
        list.insertAtBeginning(5);
        list.insertAtBeginning(4);
        list.insertAtBeginning(3);
        list.insertAtBeginning(2);
        list.insertAtBeginning(1);
        list.printList();

        first = list.head;

        while (first != null) {
            n++;
            first = first.next;
        }

        first = list.head;

        Node curr = sortedListToBST(first, n);
        System.out.println(curr.data);
        System.out.println(curr.left.data);
        System.out.println(curr.right.data);

    } 

}

Output :
1 --> 2 --> 3 --> 4 --> 5 --> 6 --> 7 --> null
4
2
4

非常感谢任何帮助。

Answer 1

请在函数 sortedListToBST（LNode first，int start，int end）中进行以下更改

请注意，下面的代码打印2作为4的右孩子，6作为4的右孩子。另外，我已经测试了2和6作为根的代码。它打印1作为2的左孩子和3作为2的右孩子。另外，5作为6的左孩子和7作为6的右孩子。

另请注意，您需要更改测试客户端，以便在左子项和/或右子项为空时处理用例。我希望下面的代码是有用的。

以下算法适用于树的有序遍历原理。

遍历左子树。
访问root。

遍历正确的子树。

public static Node sortedListToBST(LNode first, int start, int end) {

if (start > end)
    return null;

int mid = (start + end) / 2;
Node leftNode = sortedListToBST(first, start, mid - 1);
Node root = new Node(first.data);
root.left = leftNode;
if (first.next != null) {
    first.data = first.next.data;
    first.next = first.next.next;
}

root.right = sortedListToBST(first, mid + 1, end);
return root;

}

Answer 2

您未指定需要平衡 BST。如果您对BST不平衡感到满意，可以采取以下措施：

 public static Node sortedListToUnbalancedBST(LNode lNode) {
     if (lNode.next != null) {
         Node node = new Node(lNode.data);
         node.right = sortedListToUnbalancedBST(lNode.next);
         return node;
     } else {
        return null;
     }
 }

Answer 3

大家好，问题是将bst转换为Java中排序的单链接列表

df['order_id'] -= (df['order_id'] > 100) * 100

将单个链接列表排序到BST到位

3 个答案: