常见数据结构面试题目（一）

1、输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。

要求不能创建任何新的结点，只调整指针的指向。

   10

 / \

 6 14

 / \ / \

4 8 12 16

 转换成双向链表

4=6=8=10=12=14=16。

 

 首先我们定义的二元查找树 节点的数据结构如下：

 struct BSTreeNode

{

 int m_nValue; // value of node

 BSTreeNode *m_pLeft; // left child of node

 BSTreeNode *m_pRight; // right child of node

};
解决思路：先搭建一棵二元查找树，每次取出上面最小的节点，即最左侧节点，并从树上删除该节点。以此将取到的最小节点添加到双向链表的末端。
源代码如下：

public class DataStruct {
          //插入二元查找树
          public static Node insertNode(Node nds ,Node nd){
			
			Node start = nds;
			Node pr = null;
			boolean isRight = false;;
			while(nds != null){
				if(nds.getValue() > nd.getValue()){
					pr = nds;
					nds = nds.getLeft();
					isRight = false;
				}else{
					pr = nds;
					nds = nds.getRight();
					isRight = true;
				}
			}			
			if(!isRight){
				pr.setLeft(nd);
			}else{
				pr.setRight(nd);
			}
		return start;		
	}
	//删除二叉查找树上的最小节点
	public static List<Node> deleteMin(Node nds){
		
		List<Node> list = new ArrayList<Node>();
		if(nds.getLeft() == null){
			Node min = nds;
			nds = nds.getRight();
			list.add(nds);
			list.add(min);
			return list;
		}else{
			
			Node minP = getMinP(nds);
			Node min = minP.getLeft();
			minP.setLeft(null);
			
			list.add(nds);
			list.add(min);
			return list;
		}
	}
	//获得最大节点的父节点
	public static Node getMaxP(Node nds){
		
		Node p = null;
		while(nds.getRight() != null){
			p = nds;
			nds = nds.getRight();
		}
		return p;	
	}
	//获得最小节点的父节点
	public static Node getMinP(Node nds){
		
		Node p = null;
		while(nds.getLeft() != null){
			p = nds;
			nds = nds.getLeft();
		}
		return p;
	}	
	public static void printMiddle(Node nds){
		
        if(nds.getLeft() == null){
            System.out.print(nds.getValue() + "   ");
        }else{
            Node left = nds.getLeft();
            Node right = nds.getRight();
            printMiddle(left);
            System.out.print(nds.getValue() + "   ");
            if(right != null){
                printMiddle(right);
            }
        }     		
	}
	
	
	
	public static void main(String[] args){
		
            Node start = new Node(10);
            Node n2 = new Node(14);
            Node n3 = new Node(6);
            Node n4 = new Node(4);
            Node n5 = new Node(8);

            Node n6 = new Node(12);
            Node n7 = new Node(16);
        
            insertNode(start, n2);
            insertNode(start, n3);
            insertNode(start, n4);
            insertNode(start, n5);
            insertNode(start, n6);
            insertNode(start, n7);
            //输出二元树的顺序排列
            printMiddle(start);    
       
            Node nodeStart = null;
            Node node = null;
            while(start != null){
            
                List<Node> list = deleteMin(start);
                start = list.get(0);
                Node min = list.get(1);
                System.out.println(min.getValue());

                if(nodeStart == null){
                    nodeStart = min;
                    node = nodeStart;
                }else{
                    node.setRight(min);
                    min.setLeft(node);
                    node = min;
                }
            }
	}
}