java实现二叉搜索树转双向链表

/**
 * 输入一棵二叉搜索树,将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点,只能调整树中结点指针的指向。
 * 
 * @author pomay
 *
 */
class Solution_treetolist
{

	public TreeNode Convert(TreeNode pRootOfTree)
	{
		TreeNode lastNodeOfList = null;// LastNodeOfList指向已经转换好的链表的最后一个结点
		// 返回头结点
		TreeNode headNodeOfList = ConvertNode(pRootOfTree, lastNodeOfList);
		// 一直倒退到头结点
		while (headNodeOfList != null && headNodeOfList.left != null)
			headNodeOfList = headNodeOfList.left;

		return headNodeOfList;
	}

	// 把二叉树转换成链表,获得链表最后结点(即最大结点)
	TreeNode ConvertNode(TreeNode pNode, TreeNode LastNodeOfList)
	{
		if (pNode == null)
			return null;
		TreeNode current = pNode;

		if (current.left != null)
			// 把左子树转成链表
			LastNodeOfList = ConvertNode(current.left, LastNodeOfList);
		// 当前结点的左边就是左子树构成的链表的最后一个结点
		current.left = LastNodeOfList;

		if (LastNodeOfList != null)
			// 把转换好的链表后面连接当前结点
			LastNodeOfList.right = current;
		// 此时根转换好的链表最后一个结点就是当前结点
		LastNodeOfList = current;
		// 同理 把右子树转成链表
		if (current.right != null)
			LastNodeOfList = ConvertNode(current.right, LastNodeOfList);
		return LastNodeOfList;
	}

	public static void main(String[] args)
	{
		TreeNode pRootOfTree = new TreeNode(10);
		pRootOfTree.left = new TreeNode(6);
		pRootOfTree.right = new TreeNode(14);
		pRootOfTree.left.left = new TreeNode(4);
		pRootOfTree.left.right = new TreeNode(8);
		pRootOfTree.right.left = new TreeNode(12);
		pRootOfTree.right.right = new TreeNode(16);

		Solution_treetolist treetolist = new Solution_treetolist();
		TreeNode result = treetolist.Convert(pRootOfTree);
		System.out.print(result.val + " " + result.right.val + " " + result.right.right.val + " "
				+ result.right.right.right.val + " " + result.right.right.right.right.val + " "
				+ result.right.right.right.right.right.val + " " + result.right.right.right.right.right.right.val);

	}
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 可以使用递归的方法来实现,将二叉搜索树的左右子树分别换成排序的循环双向链表,然后将左右链表连接起来,最后将根节点插入到链表中即可。具体代码如下: public Node convert(Node root) { if (root == null) return null; // 将左子树换成排序的循环双向链表 Node left = convert(root.left); // 将右子树换成排序的循环双向链表 Node right = convert(root.right); // 将左右链表连接起来 Node leftTail = left == null ? null : left.left; if (leftTail != null) { leftTail.right = root; root.left = leftTail; } Node rightTail = right == null ? null : right.left; if (rightTail != null) { rightTail.right = left == null ? root : left; (left == null ? root : left).left = rightTail; } // 将根节点插入到链表中 root.right = right == null ? left : right; (right == null ? left : right).left = root; return left == null ? root : left; } ### 回答2: 要将二叉搜索树换成排序的循环双向链表,可以使用中序遍历的方式来实现。 首先,我们需要定义一个类来表示二叉树的节点,其中包含节点的值、左孩子节点、右孩子节点。 然后,我们可以通过中序遍历来将二叉树换成排序的链表。具体步骤如下: 1. 创建一个指向头节点的指针,初始时指向空。 2. 定义一个指向当前节点的指针 curr 和一个指向前一个节点的指针 pre,初始时都指向空。 3. 中序遍历二叉树,遍历顺序为左子树、根节点、右子树。 4. 在中序遍历的过程中,将当前节点的左孩子指针指向前一个节点,前一个节点的右孩子指针指向当前节点,更新 pre 指针为当前节点,并将 curr 指针指向当前节点的右孩子。 5. 遍历完所有节点后,最后将头节点的左孩子指针指向双向链表的最后一个节点,最后一个节点的右孩子指针指向头节点,形成循环链表。 6. 返回头节点。 以下是在 Java实现上述算法的代码片段: ```java class Node { public int val; public Node left; public Node right; public Node(int val) { this.val = val; this.left = null; this.right = null; } } public class Solution { private Node head; private Node pre; public Node treeToDoublyList(Node root) { if (root == null) return null; inorder(root); pre.right = head; head.left = pre; return head; } private void inorder(Node curr) { if (curr == null) return; inorder(curr.left); if (pre != null) { pre.right = curr; } else { head = curr; } curr.left = pre; pre = curr; inorder(curr.right); } } ``` 该算法的时间复杂度为 O(n),其中 n 是二叉树中的节点个数。算法中使用了递归来中序遍历二叉树,因此空间复杂度取决于函数的调用栈,最坏情况下为 O(n)。 ### 回答3: 首先,我们需要定义一个辅助函数来将二叉搜索树换为双向链表。 对于每个节点,我们需要把它的左子树换为一个双向链表,将它的右子树也换为一个双向链表。然后我们需要找到它的中序遍历的前一个节点和后一个节点,分别是左子树换后链表的最后一个节点和右子树换后链表的第一个节点。我们将当前节点的左指针指向左子树换后链表的最后一个节点,将最后一个节点的右指针指向当前节点,将当前节点的右指针指向右子树换后链表的第一个节点,将第一个节点的左指针指向当前节点。 接下来,我们递归地处理当前节点的左子树和右子树,然后将左子树换后的链表的最后一个节点和当前节点相连,将右子树换后的链表的第一个节点和当前节点相连。 最后我们需要将双向链表的头节点和尾节点相连,形成循环链表。 以下是Java代码实现: ```java class Solution { public TreeNode treeToDoublyList(TreeNode root) { if (root == null) return null; // 定义辅助函数 TreeNode[] nodes = convertNode(root); // 头节点和尾节点相连 nodes[0].left = nodes[1]; nodes[1].right = nodes[0]; return nodes[0]; } // 辅助函数,将二叉搜索树换为双向链表 private TreeNode[] convertNode(TreeNode root) { if (root == null) return new TreeNode[]{null, null}; TreeNode[] left = convertNode(root.left); TreeNode[] right = convertNode(root.right); // 将当前节点的左指针指向左子树换后链表的最后一个节点 if (left[1] != null) { left[1].right = root; root.left = left[1]; } // 将当前节点的右指针指向右子树换后链表的第一个节点 if (right[0] != null) { right[0].left = root; root.right = right[0]; } // 返回当前节点的左子树换后链表的第一个节点和右子树换后链表的最后一个节点 // 分别用于和当前节点相连 return new TreeNode[]{left[0] == null ? root : left[0], right[1] == null ? root : right[1]}; } } ``` 在此代码中,首先定义了一个辅助函数convertNode,用于将二叉搜索树换为双向链表。然后在treeToDoublyList函数中,调用该辅助函数,将双向链表的头节点和尾节点相连,形成循环链表。 值得注意的是,题目要求不能创建任何新的节点,因此我们不能通过创建新的节点来构建新的链表。而是通过调整原二叉搜索树中节点指针的指向来实现链表的构建。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值