今日算法：二维数组中的查找+替换空格+从尾到头打印链表

目录

算法题一：二维数组中的查找

题目描述

解题思路

算法题二：替换空格

题目描述

解题思路

 算法题三：从尾到头打印链表

题目描述

解题思路

方法1：集合反转

方法2：栈

方法3：两次遍历，向前填充数组

方法4：双端队列

方法5：递归

---

算法题一：二维数组中的查找

题目描述

在一个 n * m 的二维数组中，每一行都按照从左到右 非递减 的顺序排序，每一列都按照从上到下 非递减 的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

示例:

现有矩阵 matrix 如下：

[
  [1,   4,  7, 11, 15],
  [2,   5,  8, 12, 19],
  [3,   6,  9, 16, 22],
  [10, 13, 14, 17, 24],
  [18, 21, 23, 26, 30]
]
给定 target = 5，返回 true。

给定 target = 20，返回 false。

解题思路

这是一道力扣中等题，如果使用暴力法显然不是合理的方法。我们利用二维数组中数字的规律进行解题，因为每一行和每一列都是依次递增的（非递减），所以我们可以从数组的一个角出发以缩小查找的范围，例如，从右上角出发（也可从左下角出发，但不可是另外两个角，可以思考为什么），如果当前值小于目标值，则继续向下查找，因为左边的数会更小；同理，如果当前值大于目标值，则继续向左查找，因为下边的数会更大；当找到目标值时返回true，超出边界时说明不存在目标值，返回false。算法的时间复杂度为O(M+N)，最多循环M+N次。

/**
     * 右上角法
     *
     * 利用数组的规律，从右上角出发：
     * 如果当前值小于目标值，则需要在当前值下方找，因为左边的值会更小；
     * 如果当前值大于目标值，则需要在当前值左边找，因为下方的值会更大；
     * 如果找到目标值，则返回true；
     * 如果超出左边界和下边界，则说明不存在目标值，返回false。
     *
     * @param matrix 二维数组
     * @param target 目标数字
     * @return
     */
    public boolean findNumberIn2DArray(int[][] matrix, int target) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return false;
        }
        int m = matrix.length;
        int n = matrix[0].length;
        int i = 0, j = n - 1;
        while (i < m && j >= 0) {
            int val = matrix[i][j];
            if (val == target) {
                return true;
            }
            if (val < target) {
                i++;
            } else {
                j--;
            }
        }
        return false;
    }

算法题二：替换空格

题目描述

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

输入：s = "We are happy."
输出："We%20are%20happy."

解题思路

Java中采用可变字符串StringBuilder完成字符串的拼接，当遇到空格时，用“%20”代替即可，注意，当输入的字符串为空字符串或者长度为0时，原样输出即可。算法的时间复杂度为O(N)。

/**
     * 可变字符串
     *
     * Java 中采用可变字符串StringBuilder实现接口
     * 有一点需要注意：当输入的字符串为空字符串或者长度为0时，原样输出即可
     *
     * @param s 输入的字符串
     * @return
     */
    public String replaceSpace(String s) {
        if (s == null || s.length() == 0) {
            return s;
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == ' ') {
                sb.append("%20");
            }else {
                sb.append(s.charAt(i));
            }
        }
        return sb.toString();
    }

 算法题三：从尾到头打印链表

题目描述

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

输入：head = [1,3,2]
输出：[2,3,1]

解题思路

方法1：集合反转

正向输出到集合list中，反转后转化为数组。时间复杂度较高，浪费在集合反转上。

/**
     * 集合反转
     *
     * 正向添加到集合中，将集合反转后输出数组，时间复杂度O(n)
     * @param head
     * @return
     */
    public int[] reversePrint(ListNode head) {
        if (head == null) {
            return new int[0];
        }
        List<Integer> list = new ArrayList<>();
        ListNode cur = head;
        while (cur != null) {
            list.add(cur.val);
            cur = cur.next;
        }
        Collections.reverse(list);
        return list.stream().mapToInt(i -> i).toArray();
    }

方法2：栈

利用栈后进先出的特点，将数值添加进栈后，可以直接从栈中取出结果，时间复杂度优于方法1。

public int[] reversePrint(ListNode head) {
        if (head == null) {
            return new int[0];
        }
        Stack<Integer> stack = new Stack<>();
        ListNode cur = head;
        while (cur != null) {
            stack.push(cur.val);
            cur = cur.next;
        }
        int n = stack.size();
        int[] ret = new int[n];
        for (int i = 0; i < n; ++i) {
            ret[i] = stack.pop();
        }
        return ret;
    }

方法3：两次遍历，向前填充数组

第一次遍历：计算链表长度，然后初始化数组；第二次遍历：从头往后遍历链表，但从后往前填充数组。时间复杂度为O(n)。

/**
     * 两次遍历，向前填充数组
     *
     * @param head
     * @return
     */
    public int[] reversePrint(ListNode head) {
        if (head == null) {
            return new int[0];
        }
        int count = 0;
        ListNode cur = head;
        while (cur != null) {
            count++;
            cur = cur.next;
        }
        int[] ret = new int[count];
        cur = head;
        int i = count-1;
        while (cur != null) {
            ret[i] = cur.val;
            i--;
            cur = cur.next;
        }
        return ret;
    }

方法4：双端队列

定义一个双端队列，遍历链表的时候从后往前添加元素，然后转化为数组输出。

public int[] reversePrint4(ListNode head) {
        if (head == null) {
            return new int[0];
        }
        LinkedList<Integer> list = new LinkedList<>();
        ListNode cur = head;
        while (cur != null) {
            list.addFirst(cur.val);
            cur = cur.next;
        }
        return list.stream().mapToInt(i->i).toArray();
    }

方法5：递归

思想很简单，递归的过程中一直往后找元素，递归结束的标志是找到最后一个空的节点，然后依次添加节点值。只要用栈可以实现的算法，都可以用递归实现。

public int[] reversePrint5(ListNode head) {
        if (head == null) {
            return new int[0];
        }
        List<Integer> list = new ArrayList<>();
        recursive(head, list);
        return list.stream().mapToInt(i->i).toArray();
    }

    public static void recursive(ListNode cur, List<Integer> list) {
        if (cur == null) {
            return;
        }
        recursive(cur.next, list);
        list.add(cur.val);
    }

总结：本题的推荐解法为：（1）两次遍历，向前填充数组；（2）双端队列；（3）栈。