算法（2）

二叉树

镜像二叉树

树轴对称

第一个节点的左子树与第二个节点的右子树同步递归对比，第一个节点的右子树与第二个节点的左子树同步递归比较。

二叉树序列化、反序列化

当然你也可以根据满二叉树结点位置的标号规律来序列化，还可以根据先序遍历和中序遍历的结果来序列化。不对序列化之后的字符串进行约束，所以欢迎各种奇思妙想。

思路：序列化树，递归前序遍历，反序列化同。序列化为字符串 1!#22! ，用！分割灭一个数值，#区分空节点。

import java.util.*;
public class Solution {
    //序列的下标
    public int index = 0;
    //处理序列化的功能函数（递归）
    private void SerializeFunction(TreeNode root, StringBuilder str) {
        //如果节点为空，表示左子节点或右子节点为空，用#表示
        if (root == null) {
            str.append('#');
            return;
        }
        //根节点
        str.append(root.val).append('!');
        //左子树
        SerializeFunction(root.left, str);
        //右子树
        SerializeFunction(root.right, str);
    }

    public String Serialize(TreeNode root) {
        //处理空树
        if (root == null)
            return "#";
        StringBuilder res = new StringBuilder();
        SerializeFunction(root, res);
        //把str转换成char
        return res.toString();
    }
    //处理反序列化的功能函数（递归）
    private TreeNode DeserializeFunction(String str) {
        //到达叶节点时，构建完毕，返回继续构建父节点
        //空节点
        if (str.charAt(index) == '#') {
            index++;
            return null;
        }
        //数字转换
        int val = 0;
        //遇到分隔符或者结尾
        while (str.charAt(index) != '!' && index != str.length()) {
            val = val * 10 + ((str.charAt(index)) - '0');
            index++;
        }
        TreeNode root = new TreeNode(val);
        //序列到底了，构建完成
        if (index == str.length())
            return root;
        else
            index++;
        //反序列化与序列化一致，都是前序
        root.left = DeserializeFunction(str);
        root.right = DeserializeFunction(str);
        return root;
    }

    public TreeNode Deserialize(String str) {
        //空序列对应空树
        if (str == "#")
            return null;
        TreeNode res = DeserializeFunction(str);
        return res;
    }
}

二叉搜索树第k节点

中序遍历返回遍历的第k个节点。

返回二叉搜索树两个节点的最近公共祖先

思路1：返回当前节点到p和q的距离之和，能获得最小的距离就是根节点。递归，可以适用于（非有序的），题目中给定有序，那就只要判断当前节点是不是 root.val >=p&&q>=root.val 或者root.val <= p&& q>= root.val的那个节点即可。

import java.util.*;
public class Solution {

    public int lowestCommonAncestor (TreeNode root, int p, int q) {
        if (root == null) return -1;
        if (root.val >= p && root.val <= q) {
            return root.val;
        } else if (root.val <= p && root.val >= q) {
            return root.val;
        } else {
            if (root.val < p) {
                return lowestCommonAncestor(root.right, p, q);
            } else {
                return lowestCommonAncestor(root.left, p, q);
            }
        }
    }
}

思路2：题目给定二叉搜索树，有序的，那就可以分别判断两个节点p、q在当前节点的左子树还是右子树。然后再遍历的过程中记录到达p或者q遍历过的元素路径，最后比较两个路径，最后一个相同的元素即是要求节点。

import java.util.*;
public class Solution {
    //求得根节点到目标节点的路径
    public ArrayList<Integer> getPath(TreeNode root, int target) {
        ArrayList<Integer> path = new ArrayList<Integer>();
        TreeNode node = root;
        //节点值都不同，可以直接用值比较
        while(node.val != target){ 
            path.add(node.val);
            //小的在左子树
            if(target < node.val) 
                node = node.left;
            //大的在右子树
            else 
                node = node.right;
        }
        path.add(node.val);
        return path;
    }
    public int lowestCommonAncestor (TreeNode root, int p, int q) {
        //求根节点到两个节点的路径
        ArrayList<Integer> path_p = getPath(root, p); 
        ArrayList<Integer> path_q = getPath(root, q);
        int res = 0;
        //比较两个路径，找到第一个不同的点
        for(int i = 0; i < path_p.size() && i < path_q.size(); i++){ 
            int x = path_p.get(i);
            int y = path_q.get(i);
            //最后一个相同的节点就是最近公共祖先
            if(x == y) 
                res = path_p.get(i);
            else
                break;
        }
        return res;
    }
}

返回二叉树中两个节点的最近公共祖先

二叉树，递归遍历每个节点，要求当前节点往左or右能够到达p，且往右or左能够到达q。否则往子树递归遍历。

    public int lowestCommonAncestor(TreeNode root, int o1, int o2) {
        return helper(root, o1, o2).val;
    }

    public TreeNode helper(TreeNode root, int o1, int o2) {
        if (root == null || root.val == o1 || root.val == o2)
            return root;
        TreeNode left = helper(root.left, o1, o2);
        TreeNode right = helper(root.right, o1, o2);
        //如果left为空，说明这两个节点在root结点的右子树上，我们只需要返回右子树查找的结果即可
        if (left == null)
            return right;
        //同上
        if (right == null)
            return left;
        //如果left和right都不为空，说明这两个节点一个在root的左子树上一个在root的右子树上，
        //我们只需要返回cur结点即可。
        return root;
    }

返回二叉树和为t的路径

回溯

import java.util.*;
import java.util.ArrayList;
/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root, int expectNumber) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        if(root==null) return res;
        ArrayList<Integer> temp = new ArrayList<> ();
        _find(res, temp, expectNumber, root);
        return res;
    }

    static void _find(ArrayList<ArrayList<Integer>> res, ArrayList<Integer> list,
                      int t, TreeNode root) {
        if (root.left == null && root.right == null) {
            if (root.val == t) {
                list.add(root.val);
                ArrayList<Integer> ls = new ArrayList<>(list);
                list.remove(list.size() - 1);
                res.add(ls);
                return ;
            }
            else return ;
        }
        if (root.left == null) {
            list.add(root.val);
            _find(res, list, t - root.val, root.right);
            list.remove(list.size() - 1);
            return ;
        }
        if (root.right == null) {
            list.add(root.val);
            _find(res, list, t - root.val, root.left);
            list.remove(list.size() - 1);
            return ;
        }

        list.add(root.val);
        _find(res, list, t - root.val, root.left);
        _find(res, list, t - root.val, root.right);
        list.remove(list.size() - 1);
    }
}

平衡二叉树判断

递归的判断左右子树是否平衡，平衡继续判断当前节点的左子树和右子树的高度差是否满足小于2要求。满足返回true，否则返回false。

public class Solution {
    public boolean IsBalanced_Solution(TreeNode root) {
        if (root == null) return true;
        //判断左子树和右子树是否符合规则，且深度不能超过2
        //先递归判断左子树 右子树 是否符合规则，否则判断当前节点的的左子树和右子树的高度差是否小于2
        return IsBalanced_Solution(root.left) && IsBalanced_Solution(root.right) && Math.abs(deep(root.left) - deep(root.right)) < 2;
    }
    
    //判断二叉树深度
    public int deep(TreeNode root) {
        if (root == null) return 0;
        return Math.max(deep(root.left), deep(root.right)) + 1;
    }
}

链表

复杂链表深拷贝

import java.util.*;
/*
public class RandomListNode {
    int label;
    RandomListNode next = null;
    RandomListNode random = null;

    RandomListNode(int label) {
        this.label = label;
    }
}
*/
public class Solution {
    public RandomListNode Clone(RandomListNode pHead) {
        if (pHead == null) return null;
        RandomListNode node =  pHead;
        RandomListNode head = null;
        RandomListNode temp = null;
        HashMap<RandomListNode, RandomListNode> map = new HashMap<>();
        while (node != null) {
            if (head == null) {
                RandomListNode rn = new RandomListNode(node.label);
                head = rn;
                temp = rn;
                map.put(node, temp);
            } else {
                temp.next = new RandomListNode(node.label);
                map.put(node, temp.next);
                temp = temp.next;
            }
            node = node.next;
        }

        while (pHead != null) {
            if (pHead.random != null)
                map.get(pHead).random = map.get(pHead.random);
            pHead = pHead .next;
        }
        return head;
    }

}

递归回溯

n皇后

找到对角线数组与行、列号的关系。

import java.util.*;


public class Solution {
    /**
     *
     * @param n int整型 the n
     * @return int整型
     */
    static int count = 0;
    public int Nqueen (int n) {
        // write code here
        //记录行列 斜对角线是否摆放过
        boolean r [] = new boolean [n];
        boolean l [] = new boolean [n];

        //正对角线 n-j-1+i
        boolean tx[] = new boolean [2 * n - 1];
        //斜对角线 i+j
        boolean rx[] = new boolean [2 * n - 1];

        //放第一个
//         for (int i = 0; i < n; i++) 
            dfs(r, l, rx, tx, 0);
//         }
//         System.out.println(count);
        return count;
    }

    static void dfs(boolean r[], boolean l[], boolean rx[], boolean tx[],
                    int index) {
        if (index == r.length) {
            count++;
            return ;
        }

        int n = r.length;
        //试探第j列
        for (int j = 0; j < n; j++) {
            if (!r[index] && !l[j] && !tx[n - j - 1 + index] && !rx[index + j]) {
                r[index] = true;
                l[j] = true;
                tx[n - j - 1 + index] = true;
                rx[index + j] = true;
                
                dfs(r, l, rx, tx, index + 1);
                
                r[index] = false;
                l[j] = false;
                tx[n - j - 1 + index] = false;
                rx[index + j] = false;
            }
        }
    }

}

矩阵最长路径问题

给定矩阵求最长递增序列长度。起点终点不限，智能上下左右。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PYvX44xs-1690389890287)(https://s2.loli.net/2022/07/15/vkDchA2qdfSGeIK.png)]

递归

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 递增路径的最大长度
     * @param matrix int整型二维数组 描述矩阵的每个数
     * @return int整型
     */
    public int solve (int[][] matrix) {
        // write code here
        //深度优先搜索
        int dis = 0;
        boolean maze[][] = new boolean [matrix.length][matrix[0].length];
        int m = 0;
        int r = matrix.length;
        int l = matrix[0].length;

        for (int i = 0; i < r; i++) {
            for (int j = 0; j < l; j++) {
                m = Math.max(_dfs(i, j, maze, matrix) + 1, m);
            }
        }
        return m;
    }

    static int _dfs(int x, int y, boolean [][]maze, int matrix[][]) {
        int r = maze.length;
        int l = maze[0].length;
        int max = 0;
        maze[x][y] = true;
        int v = matrix[x][y];
        //右
        if (y < l - 1 && !maze[x][y + 1] && matrix[x][y + 1] > v) {
            max = Math.max(_dfs(x, y + 1, maze,matrix) + 1, max);
        }
        //下
        if (x < r - 1 && !maze[x + 1][y] && matrix[x + 1][y] > v) {
            max = Math.max(_dfs(x + 1, y, maze,matrix) + 1, max);
        }

        if (x > 0 && !maze[x - 1][y] && matrix[x - 1][y] > v) {
            max = Math.max(_dfs(x - 1, y, maze,matrix) + 1, max);
        }
        if (y > 0 && !maze[x][y - 1] && matrix[x][y - 1] > v) {
            max = Math.max(_dfs(x, y - 1, maze,matrix) + 1, max);
        }
        maze[x][y] = false;
        return max;
    }
}

dp优化,dp[x][y]表示从x，y开始所能拓展到的最长递增序列长度。当后面再次遍历到x,y节点可以直接返回。同时maze不需要，因为每一步都是也只能往高处走，不会往回走的情况。

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 递增路径的最大长度
     * @param matrix int整型二维数组 描述矩阵的每个数
     * @return int整型
     */
    public int solve (int[][] matrix) {
        // write code here
        //深度优先搜索
        //矩阵不为空
        if (matrix.length == 0 || matrix[0].length == 0)
            return 0;

//         boolean maze[][] = new boolean [matrix.length][matrix[0].length];
        int m = 0;
        int r = matrix.length;
        int l = matrix[0].length;
        int dp [][] = new int[r][l];

        for (int i = 0; i < r; i++) {
            for (int j = 0; j < l; j++) {
                m = Math.max(_dfs(i, j, matrix, dp), m);
            }
        }
        return m;
    }

    static int _dfs(int x, int y,  int matrix[][], int dp[][]) {
        //优化 减少递归
        if (dp[x][y] != 0) return dp[x][y];

        int r = matrix.length;
        int l = matrix[0].length;

        int max = 1;
        

        int v = matrix[x][y];
        //右
        if (y < l - 1 && matrix[x][y + 1] > v) {
            max = Math.max(_dfs(x, y + 1, matrix, dp) + 1, max);
        }
        //下
        if (x < r - 1  && matrix[x + 1][y] > v) {
            max = Math.max(_dfs(x + 1, y, matrix, dp) + 1, max);
        }

        if (x > 0  && matrix[x - 1][y] > v) {
            max = Math.max(_dfs(x - 1, y, matrix, dp) + 1, max);
        }
        if (y > 0  && matrix[x][y - 1] > v) {
            max = Math.max(_dfs(x, y - 1, matrix, dp) + 1, max);
        }
        //表示从dp[x][y] 拓展的最长递增子序列长度
        dp[x][y] = max;

        return max;
    }
}

贪心

活动安排

给定各个活动的开始结束时间，要求最大活动数量。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;


public class Main {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        //创建一个集合存储数据
        List<Node> xD = new ArrayList<Node>();

        Node node;

        for (int i = 0; i < n; i++) {
            //数据类型的起始值
            int a = scanner.nextInt();
            int b = scanner.nextInt();
            node = new Node(a, b);
            //将活动对应的起始和结束时间加入集合
            xD.add(node);
        }

        //对活动时间进行排序，按照末尾时间从小到大的标准
        Collections.sort(xD, (o1, o2)-> {
            return o1.end - o2.end;
        });

        int begin = 0, count = 0;
        for (int i = 0; i < n; i++) {
            //当当前的起始值大于上一个活动的结束值时，符合要求
            if (xD.get(i).start >= begin) {
                //更新begin的值
                begin = xD.get(i).end;
                count++;
            }
        }
        System.out.println(count);
    }

}


//节点类
class Node {
    //该数据类型包含一个起始值，一个结束值，一个标记，
    int start;
    int end;
    public Node(int start, int end) {
        // TODO Auto-generated constructor stub
        this.start = start;
        this.end = end;
    }
}