30分钟解决8道算法题

import org.w3c.dom.NodeList;

import java.math.BigInteger;
import java.util.*;

public class test_04_24 {
    static class TreeNode{
        int val;
        TreeNode left;
        TreeNode right;
        public TreeNode(int val){
            this.val = val;
        }
    }

    static class ListNode {
        int val;
        ListNode next;
        ListNode() {}
        ListNode(int val) { this.val = val; }
        ListNode(int val, ListNode next) { this.val = val; this.next = next; }
    }
    public static List> zigzagLevelOrder(TreeNode root) {
        List> res = new ArrayList<>();
        LinkedList linkedList = new LinkedList<>();
        linkedList.offerLast(root);
        boolean flag = true;
        while (!linkedList.isEmpty()){
            List ls = new ArrayList<>();
            int m = linkedList.size();
            //从左往右
            if (flag){
                for (int i=0;i spiralOrder(int[][] matrix){
        int n = matrix.length;
        int m = matrix[0].length;
        boolean[][] visited = new boolean[n][m];
        List res = new ArrayList<>();
        visited[0][0]=true;
        res.add(matrix[0][0]);
        dfs(matrix, 0, 0,visited,res);
        return res;
    }

    private static void dfs(int[][] matrix, int posX, int posY, boolean[][] visited, List res) {
        int n = matrix.length;
        int m = matrix[0].length;
        //上右下左
        int[] x = new int[]{-1,0,1,0};
        int[] y = new int[]{0,1,0,-1};
        //四个方向
        for (int i=0;i<4;i++){
            int newX = posX+x[i];
            int newY = posY+y[i];
            if (newX<0||newX>=n){
                continue;
            }
            if (newY<0||newY>=m){
                continue;
            }
            if (visited[newX][newY]){
                continue;
            }
            visited[newX][newY]=true;
            res.add(matrix[newX][newY]);
            dfs(matrix,newX,newY,visited,res);
        }
    }

    public static List spiralOrder2(int[][] matrix){
        int n=matrix.length;
        int m = matrix[0].length;
        int min = Math.min(n,m);
        int level = (min&1)==1?min/2+1:min/2;
        List res = new ArrayList<>();
        //向右
        for (int k=0;k=k){
                res.add(matrix[i][j--]);
            }
            if (size==res.size()){
                break;
            }
            j++;
            i--;
            while (i>k){
                res.add(matrix[i--][j]);
            }
        }
        return res;
    }

    //最长上升子序列
    //[1,3,6,7,9,4,10,5,6]
    public static int lengthOfLIS(int[] nums){
        int n = nums.length;
        int[] dp = new int[n];
        Arrays.fill(dp,1);

        for (int i=1;i=0;j--){
                if (nums[i]>nums[j]){
                    dp[i]=Math.max(dp[j]+1,dp[i]);
                }
            }
        }
        return Arrays.stream(dp).max().getAsInt();
    }

    //合并k个排序链表
    public ListNode mergeKLists(ListNode[] lists) {
        int n = lists.length;
        ListNode newHead = new ListNode(-1);
        ListNode p = newHead;
        while (true){
            //找出初始
            int index=-1;
            for (int i=0;i=0&&j>=0){
            int res = num1.charAt(i)+num2.charAt(j)-48-48+k;
            k = res/10;
            stringBuilder.append(res%10);
            i--;
            j--;
        }
        while (i>=0){
            int res = num1.charAt(i)-48+k;
            k = res/10;
            stringBuilder.append(res%10);
            i--;
        }
        while (j>=0){
            int res = num2.charAt(j)-48+k;
            k=res/10;
            stringBuilder.append(res%10);
            j--;
        }
        if (k!=0){
            stringBuilder.append(k);
        }
        return stringBuilder.reverse().toString();
    }

    static void printList(ListNode head){
        while (head!=null){
            System.out.print(head.val+" ");
            head=head.next;
        }
        System.out.println();
    }

    //合并区间
    public static int[][] merge(int[][] intervals) {
        Arrays.sort(intervals, (a, b) -> a[0] - b[0]);
        List res = new ArrayList<>();

        for (int[] interval : intervals) {
            if (res.isEmpty() || res.get(res.size() - 1)[1] < interval[0]) {
                res.add(interval); // 不重叠，直接添加
            } else {
                // 重叠，合并
                int[] last = res.get(res.size() - 1);
                last[1] = Math.max(last[1], interval[1]);
            }
        }

        return res.toArray(new int[0][]);
    }


    public static void main(String[] args) {
        int[][] input = {
                {1,4},{2,3}
        };
        int[][] merge = merge(input);
        System.out.println(Arrays.deepToString(merge));
    }
}