算法-题目汇总-6

1. 某个数是否存在于二维数组中

public boolean search(int[][] m, int target) {
        if (m.length == 0 || m[0].length == 0) {
            return false;
        }
        int l = 0;
        int r = m.length * m[0].length - 1;
        int col = m[0].length;
        while (l <= r) {
            int mid = l + ((r - l) >> 1);
            // mid/col 求出在哪行
            // mid%col 求出在哪列
            int val = m[mid / col][mid % col];
            if (val == target) {
                return true;
            } else if (val < target) {
                l = mid + 1;
            } else {
                r = mid - 1;
            }
        }
        return false;
    }

 2. 前序中序转树

 

public TreeNode getTree(int[] pre, int[] mid) {
        return process(pre, 0, pre.length - 1, mid, 0, mid.length - 1);
    }

    public TreeNode process(int[] pre, int pl, int pr, int[] mid, int ml, int mr) {
        if (pl > pr || ml > mr) {
            return null;
        }
        int value = pre[pl];
        int help = ml;
        while (help < mr &&  mid[help] != value) {
            help++;
        }
        TreeNode treeNode = new TreeNode(value);
        treeNode.left = process(pre, pl + 1, pl + help - ml, mid, ml,help - 1);
        treeNode.right = process(pre, pl + help - ml + 1, pr, mid, help + 1, mr);
        return treeNode;
    }

3. 可循环的数组找最小值

public int search(int[] arr) {
        if (arr.length == 0) {
            return -1;
        }
        int l = 0;
        int r = arr.length - 1;
        if (arr[r] > arr[0] || arr[r] == arr[0]) {
            return arr[0];
        }
        while (l <= r) {
            int mid = l + ((r - l) >> 1);
            // 可以举例得出结论
            if (arr[mid] > arr[mid + 1]) {
                return arr[mid + 1];
            }
            if (arr[mid - 1] > arr[mid]) {
                return arr[mid];
            }
            // 中间值大于0位置的值 说明
            if (arr[mid] > arr[0]) {
                l = mid + 1;
            } else {
                r = mid - 1;
            }
        }
        return -1;
    }

4. 统计整数 二进制形式有多少个1 (n-1)&n 可以将最右边的1设置为0

　　

 public int count(int n) {
        int count = 0;
        if (n == 0) {
            return count;
        }
        while (n != 0) {
            count++;
            n = (n - 1) & n;
        }
        return count;
    }

 5. 获取链表的倒数第k个节点

public ListNode getLastKNode(ListNode head, int k) {
        if (head == null || k < 1) {
            return null;
        }
        ListNode fast = head;
        ListNode slow = head;
　　　　　　// 注意k-- 要大于1 才能获取到最后一个node
        while (k-- > 1) {
            if (fast.next == null) {
                return null;
            }
            fast = fast.next;
        }
        while (fast.next != null) {
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }

6. 子树判断

public boolean checkSubTree(TreeNode t1, TreeNode t2) {
        if (t1 == null) {
            return false;
        }
        if (t2 == null) {
            return true;
        }
        return isSame(t1, t2) || checkSubTree(t1.left, t2) || checkSubTree(t2.right, t2);
    }

    public boolean isSame(TreeNode t1, TreeNode t2) {
        if (t1 == t2) {
            return true;
        }
        if (t1 == null || t2 == null) {
            return false;
        }

        return t1.val == t2.val && isSame(t1.left, t2.left) && isSame(t1.right, t2.right);
    }

 

class Solution {
    public boolean checkSubTree(TreeNode t1, TreeNode t2) {
        
        if(t1 == null){
            if(t2 == null){
                return true;
            }else{
                return false;
            }
        }
        //判断当前节点是否符合，递归先序左孩子，递归先序右孩子
        return recur(t1, t2) || checkSubTree(t1.left, t2) || checkSubTree(t1.right, t2);
    }

    //递归判断两颗树是否完全相同
    boolean recur(TreeNode root1, TreeNode root2){

        if(root1 == null && root2 == null){
            return true;
        }

        if(root1 == null || root2 == null){
            return false;
        }

        if(root1.val != root2.val){
            return false;
        }

        return recur(root1.left, root2.left) && recur(root1.right, root2.right);

    }
}

 

7. 给你一个数组 判断数组的序列是否是搜索二叉树的后续序列

 数组的最后一个数肯定是root节点,小于root值的数是左子树,大于root值的是右子树

　　找到左右子树的范围再递归判断

public boolean judgeBst(int[] arr) {
        return isBst(arr, 0, arr.length - 1);
    }

    public boolean isBst(int[] arr, int l, int r) {
        if (l >= r) {
            return true;
        }
        int i = l;
        while (arr[i] < arr[r]) {
            i++;
        }
        for (int j = i; j <= r; j++) {
            if (arr[j] < arr[r]) {
                return false;
            }
        }
        return isBst(arr, l, i - 1) &&
                isBst(arr, i, l - 1);
    }

8. 二叉树 返回指定数值的节点路径 必须是到叶子节点才能算一条路径

public class FindPath {
    private ArrayList<Integer> list = new ArrayList<>();
    private ArrayList<ArrayList<Integer>> res = new ArrayList<>();

    public ArrayList<ArrayList<Integer>> findPath(TreeNode head, int k) {
        process(head, k);
        return res;
    }

    public void process(TreeNode head, int rest) {
        if (head == null) {
            return;
        }
        list.add(head.val);
        rest -= head.val;
        if (rest == 0 && head.left == null && head.right == null) {
            res.add(new ArrayList<>(list));
        }
        process(head.left, rest);
        process(head.right, rest);
　　　　　　// 返回父节点的时候删除子节点的值
        list.remove(list.size() - 1);
    }
}

 9.复杂链表复制

　　思路1: 先根据next复制在复制过程中 用hashmap记录随机的node值 组成next链表之后再遍历设置随机node

　　思路2: 遍历链表 复制node A-B-C 复制成A-A`-B-B`-C-C` 然后遍历链表A`的随机node 是Anode的随机node+1  然后再把链表分成两个链表

　　

public ListNode copy(ListNode head) {
        cloneNodes(head);
        connectSiblingNodes(head);
        return split(head);
    }

    public void cloneNodes(ListNode head) {
        ListNode p = head;
        while (p != null) {
            ListNode newNode = new ListNode(p.val);
            newNode.next = p.next;
            p.next = newNode;
            p = newNode.next;
        }
    }

    public void connectSiblingNodes(ListNode head) {
        ListNode p = head;
        while (p != null) {
            ListNode pclone = p.next;
            ListNode rNext = p.rNext;
            if (rNext != null) {
                pclone.rNext = rNext.next;
            }
            p = pclone.next;
        }
    }

    public ListNode split(ListNode head) {
        ListNode node = head;
        ListNode cloneHead = null;
        ListNode cloneNode = null;
        if (head != null) {
            cloneHead = cloneNode = node.next;
            node.next = cloneNode.next;
            node = node.next;
        }
        while (node != null) {
            cloneNode.next = node.next;
            cloneNode = cloneNode.next;

            node.next = cloneNode.next;
            node = node.next;
        }
        return cloneHead;
    }

10. 求第n个丑数/ 判断这个数是否是丑数

　　丑数先被2除 然后被5除 然后被3除 等于1是丑数

　　n%2==0 n/2

　　n%5 ==0 n/5

　　n%3 == 0 n/3

     求第n个丑数,第一个丑数是1 第二个丑数是前一个丑数*234的最小值,每次计算出丑数之后 更新p2 p3 p5的值会增加效率 指针要知道刚好等于或小于最后一个丑数的位置

　　

public int get(int n) {
        if (n < 1) {
            return -1;
        }
　　　　　　　　// 小于7的丑数就是自己
        if (n < 7) {
            return n;
        }
        int p2 = 0, p3 = 0, p5 = 0;
        int[] help = new int[n];
        help[0] = 1;
        for (int i = 1; i < n; i++) {
            help[i] = Math.min(Math.min(help[p2] * 2, help[p3] * 3), help[p5] * 5);
            while (help[p2] * 2 <= help[i]) {
                p2++;
                if (p2 > n) {
                    break;
                }
            }
            while (help[p3] * 3 <= help[i]) {
                p3++;
                if (p3 > n) {
                    break;
                }
            }
            while (help[p5] * 5 <= help[i]) {
                p5++;
                if (p5 > n) {
                    break;
                }
            }
        }
        return help[n - 1];
    }

 

public int getKthMagicNumber(int k) {
        int p3 = 0;
        int p5 = 0;
        int p7 = 0;
        int[] ugly = new int[k + 1];
        ugly[0] = 1;
        for (int i = 1; i < k; i++) {
            ugly[i] = Math.min(3 * ugly[p3], Math.min(5 * ugly[p5],7 * ugly[p7]));
            if (ugly[i] == 3 * ugly[p3]) {
                p3++;
            }
            if (ugly[i] == 5 * ugly[p5]) {
                p5++;
            }
            if (ugly[i] == 7 * ugly[p7]) {
                p7++;
            }
        }
        return ugly[k-1];
    }