DFS算法之无序列表转换为平衡二叉搜索树

题目简介：给定一个单链表，其中的元素不是有序排列的，将其转换为高度平衡的BST（二叉搜索树）。

思路：我的思路就是一次遍历单链表，每遍历一个元素，就将其插入树中。在插入的过程中，先找到应该插入的位置，然后在判断树的高度看是否应该进行调整树使其依然保持平衡二叉树的特性，一次进行下去，最终的树就是一个平衡二叉搜索树。

源码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
 	//链表节点转换为平衡二叉树
	public TreeNode sortedListToBST(ListNode head)
	{
		TreeNode root=null;
		
		while(head!=null)
		{
			if(root!=null)
				System.out.print("head.val:"+head.val+"  "+"root.val:"+root.val);
			root=insertNode(root,head.val);
			
			head=head.next;
		}
		
		if(root==null)
		{
			System.out.println("root is null");
		}
		return root;
	}
	
	
	//向二叉树中插入节点，这个过程要判断是否要进行调整树
	public TreeNode insertNode(TreeNode root,int val)
	{
		System.out.println();
		if(root==null)
		{
			root=new TreeNode(val);
			return root;
		}
		TreeNode node=root;
		System.out.println(node.val);
		while(root!=null)
		{
			if(root.val>val)
			{
				if(root.left==null)
				{
					root.left=new TreeNode(val);
					root=null;
				}
				else
					root=root.left;
			}
				
			else 
			{
				if(root.right==null)
				{
					root.right=new TreeNode(val);
					root=null;
				}
				else
					root=root.right;
			}
				
		}
		
		
		///判断该树是否需要进行调整高度
		int leftHigh=0;
		int rightHigh=0;
		leftHigh=high(node.left);
		rightHigh=high(node.right);
		System.out.println("leftHigh:"+leftHigh+" rightHigh:"+rightHigh);
		//左调
		if(leftHigh>rightHigh+1)
		{
			root=node.left;
			node.left=root.right;
			root.right=node;
			return root;
		}
		//右调
		else if(leftHigh+1<rightHigh)
		{
			root=node.right;
			node.right=root.left;
			root.left=node;
			System.out.println("root:"+root.val);
			return root;
		}
		return node;
	}
	
	public int high(TreeNode node)
	{
		if(node==null)
		{
			return 0;
		}
		
		int max=0;
		max=Math.max(1+high(node.left), 1+high(node.right));
		return max;
	}
	
	
	
}