leetcode_987. 二叉树的垂序遍历--二叉树垂序遍历+自定义排序

题目描述

给你二叉树的根结点 root ，请你设计算法计算二叉树的 垂序遍历 序列。

对位于 (row, col) 的每个结点而言，其左右子结点分别位于 (row + 1, col - 1) 和 (row + 1, col + 1) 。树的根结点位于 (0, 0) 。

二叉树的 垂序遍历 从最左边的列开始直到最右边的列结束，按列索引每一列上的所有结点，形成一个按出现位置从上到下排序的有序列表。如果同行同列上有多个结点，则按结点的值从小到大进行排序。

返回二叉树的 垂序遍历 序列。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[9],[3,15],[20],[7]]

解释：

列 -1 ：只有结点 9 在此列中。
列 0 ：只有结点 3 和 15 在此列中，按从上到下顺序。
列 1 ：只有结点 20在此列中。
列 2 ：只有结点 7 在此列中。

示例 2：

输入：root = [1,2,3,4,5,6,7]
输出：[[4],[2],[1,5,6],[3],[7]]

解释：

列 -2 ：只有结点 4 在此列中。
列 -1 ：只有结点 2 在此列中。
列 0 ：结点 1 、5 和 6 都在此列中。1 在上面，所以它出现在前面。 5 和 6 位置都是 (2, 0) ，所以按值从小到大排序，5 在 6 的前面。
列 1 ：只有结点 3 在此列中。
列 2 ：只有结点 7 在此列中。

示例 3：

输入：root = [1,2,3,4,6,5,7]
输出：[[4],[2],[1,5,6],[3],[7]]

解释：

这个示例实际上与示例 2 完全相同，只是结点 5 和 6 在树中的位置发生了交换。 因为 5 和 6
的位置仍然相同，所以答案保持不变，仍然按值从小到大排序。

提示：

树中结点数目总数在范围 [1, 1000] 内
0 <= Node.val <= 1000

来源：力扣（LeetCode）

题目大意

将一颗二叉树进行垂序遍历，顺序为从列方向上左到右，行方向上从右到左，如果由行和列都相同的几个节点，从大到小
输入：一棵二叉树
输出：排列好的二叉树List<List<Integer’>>

思路描述

首先应该将所有的节点座标和数值记录下来，然后将每一个节点以y座标->x座标->val值进行排序，将排好序的节点记录到List中
可得步骤：

1. 创建一个类myNode，将row，col，val值记录下来
2. 以先序遍历所有的节点值记录成为myNode值
3. 创建一个ArrayList<myNode’> myNodeList将所有的myNode值存入
4. 创建自定义排序，让排序的过程以y座标->x座标->val值的优先级顺序排列，小的在前面
5. 将list以自定义排序的方式排序
6. 将myNodeList的值以**List<List<Integer’>>**存入到rlist中
7. 输出rlist

代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
		  	List<List<Integer>> rlist=new LinkedList<List<Integer>>();
		  	
		  	ArrayList<myNode> myNodeList=new ArrayList<>();
		  	
		    public List<List<Integer>> verticalTraversal(TreeNode root) {
		    	dfs(0,0,root);

				// 4. 创建自定义排序，让排序的过程以y座标->x座标->val值的优先级顺序排列，小的在前面
		    	//自定义排序方法
		    	Collections.sort(myNodeList,new Comparator<myNode>(){
					
					// 5. 将list以自定义排序的方式排序
					@Override
					public int compare(myNode o1, myNode o2) {
						// TODO Auto-generated method stub
						if(o1.y!=o2.y){
							return o1.y-o2.y;
						}
						else if(o1.x!=o2.x){
							return o1.x-o2.x;
						}
						else{
                            return o1.val-o2.val;
                        }
						
					}
		    		
		    	});
		    	
               
		    	
		    	//6. 将myNodeList的值以List<List<Integer'>>存入到rlist中
		    	//这里将值先存入list中是因为需要使用LinkedList中的 getLast()方法
		    	LinkedList<LinkedList<Integer>> list=new LinkedList<>();
		    	list.add(new LinkedList<Integer>());
		    	
		    	//初始化 将排序好的ArrayList第一个值赋值给currentY
		    	int currentY=myNodeList.get(0).y;
		    	
		    	for(myNode i:myNodeList){
		    		//因为已经排序好了，
		    		//如果列数相等那么 就在 当前列上 添加值
		    		//如果不相等说明已经过了这一行，那么 再创建新的一行
		    		if(currentY!=i.y){
		    			list.add(new LinkedList<Integer>());
		    			currentY=i.y;
		    		}
		    		list.getLast().add(i.val);
		    	}
		    	//7. 输出rlist
		    	rlist.addAll(list);
		    	return rlist;

		    }
		    
		    
		    //2. 以先序遍历所有的节点值记录成为myNode值
		    //3. 创建一个ArrayList<myNode'> myNodeList将所有的myNode值存入
		    public void dfs(int row,int col,TreeNode node){
               
                if(node!=null){
                    myNodeList.add(new myNode(row,col,node.val));
		    	    dfs(row+1,col-1,node.left);
		    	    dfs(row+1,col+1,node.right);
                }
		    	
		    }

			// 1. 创建一个类myNode，将row，col，val值记录下来
            class myNode{
		        int x,y;
		        int val;
		        public myNode(int x,int y,int val){
			       this.x=x;
			       this.y=y;
			       this.val=val;
		    }
	  }
	  }
	  

写在最后

如果感觉写的还不错的话不妨分享给其他人，以求共同进步！

文章如有错误之处请指出，我会听取并改正！