网易互娱面筋

class Interval {
    int start, end;

    Interval(int start, int end) {
        this.start = start;
        this.end = end;
    }
}

/**
 * @author wangyifan
 */
public class Main {
    public static List<Interval> merge(List<Interval> intervals) {
        List<Interval> ans = new ArrayList<>();
        if (intervals.size() == 0) {
            return intervals;
        }

        //思路1：先将左半边的数据进行从小到大，排序。
        for (int i = 0; i < intervals.size(); i++) {
            for (int j = i + 1; j < intervals.size(); j++) {
                if (intervals.get(i).start > intervals.get(j).start) {
                    Interval tem = intervals.get(i);
                    intervals.set(i, intervals.get(j));
                    intervals.set(j, tem);
                }
            }
        }

        //从小到大遍历，从最前面开始
        int min = intervals.get(0).start;
        int max = intervals.get(0).end;
        for (int i = 1; i < intervals.size(); i++) {
            //intervals.get(i).start <= max，就进行区间，重叠即合并区间
            if (intervals.get(i).start <= max) {
                //取大
                max = Math.max(intervals.get(i).end, max);
            } else {
                //否则标识此区间结束，新建立一个区间
                ans.add(new Interval(min, max));
                min = intervals.get(i).start;
                max = intervals.get(i).end;
            }
        }
        ans.add(new Interval(min, max));
        return ans;
    }
}

public class SingleTon {
    volatile private static SingleTon singleTon = null;
    private SingleTon(){
        System.out.println("实例化1次");
    }

    public static SingleTon getInstance(){
        /**
         *解释：当A与B同时调用getSingleton时，判断第一个if都为空，这时A拿到锁，进行第二层if判断，条件成立new了一个对象；

         B在外层等待，A创建完成，释放锁，B拿到锁，进行第二层if判断，条件不成立，结束释放锁。C调用getSingleton时第一层判断不成立，直接拿到singleton对象返回，避免进入锁，减少性能开销。
         ————————————————
         版权声明：本文为CSDN博主「小韩同志」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
         原文链接：https://blog.csdn.net/jlnu0812407/article/details/102836187
        */
        if (singleTon == null){
            synchronized (SingleTon.class){
                if (singleTon == null) {
                    singleTon = new SingleTon();
                }
            }
        }
        return singleTon;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                SingleTon.getInstance();
            }, String.valueOf(i)).start();
        }
    }
}

import java.util.Stack;

/**
 * @Description: 非递归压栈，实现深度优先遍历
*/
public class Soultion2 {
    public static void dfsWithStack(Node root){
        if (root == null) {
            return;
        }
        Stack<Node> stack = new Stack<>();

        stack.push(root);
        while (!stack.isEmpty()){
            Node treeNode = stack.pop();
            /**
             * @Description: 处理当前节点
            */
            System.out.println(treeNode.value);
            if (treeNode.right != null) {
                stack.push(treeNode.right);
            }
            if (treeNode.left != null) {
                stack.push(treeNode.left);
            }
        }
    }
}