黄哥Python: LeetCode199题 Binary Tree Right Side View

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
# 黄哥Python培训 黄哥所写
class Solution:
    def rightSideView(self, root: TreeNode) -> List[int]:
        if root is None:
            return []
        res = []
        level = 1
        q = [[root,level]]
        used = []
        while q:
            node, currLevel = q.pop(0)
            if currLevel not in used:
                res.append(node.val)
                used.append(currLevel)
            
            if node.right:
                q.append([node.right, currLevel+1])               
            if  node.left:              
                q.append([node.left, currLevel+1])  
           
        return res

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
// 黄哥Python培训 黄哥所写
func rightSideView(root *TreeNode) []int {
    if root == nil {
        return []int{}
    }
    var res []int
    queue := [][]interface{}{{root, 1}}
    var used []int
    
    for len(queue) > 0 {
        temp := queue[0]
        queue = queue[1:]
        nodeInterface, currLevel := temp[0], temp[1]
        n,_ := currLevel.(int)
        node,_ := nodeInterface.(*TreeNode)
        
        if !inSlice(used, n){
            res = append(res, node.Val)
            used = append(used, n)
        }
        if node.Right != nil{
            queue = append(queue, []interface{}{node.Right, n+1})
        }
        if node.Left != nil {
            queue = append(queue, []interface{}{node.Left, n+1})
        }
    }
    return res
    
}

func inSlice(nums []int, n int) bool {
    if len(nums) == 0 {
        return false
    }
    for _, item := range nums {
        if item == n {
            return true
        }
    
    }
    return false
}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
import java.util.LinkedList; 
import java.util.Queue; 
//黄哥Python培训 黄哥所写
class Solution {
    public List<Integer>  rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        List<Integer> used = new ArrayList<>();
    
        Queue<MyParameters> q = new LinkedList<>(); 
        q.add(new MyParameters(root, 1));
            
        if (root == null) {
            return res;
        }
        
        while (q.size() > 0) {
            MyParameters temp = q.poll();
            TreeNode node = temp.node;
            int level = temp.level;
            
            if (!used.contains(level)) {
                res.add(node.val);
                used.add(level);                    
            }
            
            if (node.right != null) {
                q.add(new MyParameters(node.right, level + 1));
            }
            if (node.left != null) {
                q.add(new MyParameters(node.left, level + 1));
            }
        } 
        
        return res;
        
    }
    
    public class MyParameters {
         TreeNode node;
         int level;
          public MyParameters(TreeNode node, int level ) {
           this.node = node;
           this.level = level;
               }


  }


}