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

题目描述

在一个 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 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 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 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 list = new ArrayList<>();recursive(head, list);return list.stream().mapToInt(i->i).toArray();}public static void recursive(ListNode cur, List list) {if (cur == null) {return;}recursive(cur.next, list);list.add(cur.val);}