1.
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;
}
}
public int kthSmallest(TreeNode root, int k) {
LinkedList<TreeNode> linkedList = new LinkedList<>();
while (true){
while (root != null){
linkedList.add(root);
root = root.left;
}
root = linkedList.removeLast();
k--;
if (k==0){
return root.val;
}
root = root.right;
}
}
2.
HashMap<Integer,TreeNode> parentMap = new HashMap<>();//存储父节点
HashSet<Integer> visitedSet = new HashSet<>();//储存p的父节点
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
if (p == root || q == root){
return root;
}
dfs(root);
while (p != null){
visitedSet.add(p.val);
p = parentMap.get(p.val);
}
while (q != null){
if (visitedSet.contains(q.val)){
return q;
}
q = parentMap.get(q.val);
}
return null;
}
private void dfs(TreeNode root){
if (root.left != null){
parentMap.put(root.left.val,root);
dfs(root.left);
}
if (root.right != null){
parentMap.put(root.right.val,root);
dfs(root.right);
}
}
3.
class Codec {
public StringBuilder serializeDfs(TreeNode root , StringBuilder str){
if (root == null){
str.append("null,");
}else {
str.append(root.val+",");
serializeDfs(root.left, str);
serializeDfs(root.right, str);
}
return str;
}
public String serialize(TreeNode root) {
StringBuilder sb = new StringBuilder();
sb = serializeDfs(root, sb);
return sb.toString();
}
public TreeNode deserializeDfs(List<String> dataList){
if (dataList.get(0).equals("null")){
dataList.remove(0);
return null;
}
TreeNode root = new TreeNode(Integer.valueOf(dataList.get(0)));
dataList.remove(0);
root.left = deserializeDfs(dataList);
root.right = deserializeDfs(dataList);
return root;
}
public TreeNode deserialize(String data) {
String[] strings = data.split(",");
List<String> dataList = new LinkedList<String>(Arrays.asList(strings));
return deserializeDfs(dataList);
}
}
4.
//思路：只考虑每个 building 的左上角和右上角坐标，将所有点按 x 坐标排序，然后开始遍历。
//需要一个优先队列来存储遍历坐标的高度，也就是 y 轴坐标。
//对于左上角坐标和右上角坐标有不同的处理方式。
//遇到左上角坐标，将其 y 坐标加入到优先队列中。
//遇到右上角坐标，将其 y 坐标从优先队列中删除，也就是删除了其对应的左上角坐标的 y 值。
//最后判断优先队列中的最高高度相对于之前是否更新，如果更新了的话，就将当前的 x 以及更新后的最高高度作为一个坐标加入到最终结果中。
public List<List<Integer>> getSkyline(int[][] buildings) {
List<List<Integer>> points = new ArrayList<>();
List<List<Integer>> results = new ArrayList<>();
int n = buildings.length;
//求出将左上角和右上角坐标, 左上角坐标的 y 存负数
for (int[] b : buildings) {
List<Integer> p1 = new ArrayList<>();
p1.add(b[0]);
p1.add(-b[2]);
points.add(p1);
List<Integer> p2 = new ArrayList<>();
p2.add(b[1]);
p2.add(b[2]);
points.add(p2);
}
//将所有坐标排序
Collections.sort(points, new Comparator<List<Integer>>() {
@Override
public int compare(List<Integer> p1, List<Integer> p2) {
int x1 = p1.get(0);
int y1 = p1.get(1);
int x2 = p2.get(0);
int y2 = p2.get(1);
if (x1 != x2) {
return x1 - x2;
} else {
return y1 - y2;
}
}
});
TreeMap<Integer, Integer> treeMap = new TreeMap<>(new Comparator<Integer>() {
@Override
public int compare(Integer i1, Integer i2) {
return i2 - i1;
}
});
treeMap.put(0, 1);
int preMax = 0;
for (List<Integer> p : points) {
int x = p.get(0);
int y = p.get(1);
if (y < 0) {
Integer v = treeMap.get(-y);
if (v == null) {
treeMap.put(-y, 1);
} else {
treeMap.put(-y, v + 1);
}
} else {
Integer v = treeMap.get(y);
if (v == 1) {
treeMap.remove(y);
} else {
treeMap.put(y, v - 1);
}
}
int curMax = treeMap.firstKey();
if (curMax != preMax) {
List<Integer> temp = new ArrayList<>();
temp.add(x);
temp.add(curMax);
results.add(temp);
preMax = curMax;
}
}
return results;
}