1 严格定义函数名称，出入参
我们在一开始拿到算法题，读懂题之后，就需要根据题意定义我们的函数名称，以及入参，函数的返回类型。日常的企业项目开发也是一样，我们在拿到需求之后，需要去定义接口，入参，出参。
我们一定要给处理函数起一个能够明确表达函数功能的名字比如：排序sort，搜索search，统一用英文表示（入参也是如此）。
leetcode技巧： 变量名称定义简单，可以提高算法执行速度，这也是在好多人在刷leetcode参数定义不那么规范的原因，往往在周赛或者一些比赛中一点点优势，就能助我们取得胜利。
2 严进宽出，边界判断
严进宽出就是说我们要对算法的入参进行严格的验证，比如我们经常要对数组、字符串进行非空校验，还有一些需要对边界值进行校验。
对于不符合规范的直接返回，很好的把控边界也可提升我们的算法效率。
笔试小技巧： 优雅严格的边界值判断，往往能给面试官留下很好的印象。
// 入参校验
if (nums == null || nums.length == 0) {
return -1;
}
// 边界值（不相等时，我们让左边指针移动到二分处，并且+1就很细节，因为中间点已经不符合，所以我们+1可以少循环一次）
while (l <= r) {
mid = l + (r - l) / 2;
if (nums[mid] == target) {
return mid;
} else if (nums[mid] < target) {
l = mid + 1;
} else if (nums[mid] > target) {
r = mid - 1;
}
}
AI 代码解读
3 暴力解法
没有经过算法训练的同学，一般在解决算法问题时，只能想到暴力解法，常常就是多层嵌套函数，定义额外的空间。
往往时间复杂度都是O(N)、O(N²) 虽然也能解决算法问题，但是往往因为算法的执行效率过低，代码不够优雅让Offer与我们失之交臂。
不过暴力解法虽然效率不高，但是是我们必须掌握的，写出来永远比什么都写不出来要强的多，暴力解法就要求我们灵活应用每种数据结构的遍历，并加入条件判断逻辑。
以下几个技巧则可以帮助我们优化算法，提供算法的执行效率。
4 双指针（Two Pointers）
双指针是一种算法小套路，我们在好多地方可以见到双指针的妙用，比如二分查找，确定链表是否成环等，接下来我们就来一起探究一下双指针的妙用。
双指针一般有以下几种形式。
普通双指针
两个指针往同一个方向移动
/** * 冒泡排序 * @param nums */ public static void sort(int [] nums) { if (nums == null || nums.length == 0) { return; } int temp = 0; for (int i = 0; i < nums.length - 1; i++) { for (int j = i + 1; j < nums.length; j++) { if (nums[i] > nums[j]) { temp = nums[i]; nums[i] = nums[j]; nums[j] = temp; } } } }AI 代码解读对撞双指针
两个指针从两端向对方移动
/** * 力扣704 二分查找 * 二分查找算法是借助二分的思想，结合双指针来实现的一种搜索算法 * @author zhj */ public class Test704 { public static void main(String[] args) { int[] nums = {-1, 0, 3, 5, 9, 12}; int index = search(nums, 5); System.out.println(index); } private static int search(int[] nums, int target) { if (nums == null || nums.length == 0) { return -1; } int l = 0; int r = nums.length - 1; int mid; while (l <= r) { mid = l + (r - l) / 2; if (nums[mid] == target) { return mid; } else if (nums[mid] < target) { l = mid + 1; } else if (nums[mid] > target) { r = mid - 1; } } return -1; } }AI 代码解读快慢双指针
慢指针+快指针 解决环形链表问题
/** * 力扣 141 环形链表 * 给定一个链表，判断链表中是否有环 * @author zhj */ public class Test141 { public static void main(String[] args) { ListNode node = new ListNode(1); ListNode node1 = new ListNode(2); ListNode node2 = new ListNode(3); ListNode node3 = new ListNode(4); ListNode node4 = new ListNode(5); node.next = node1; node1.next = node2; node2.next = node3; node3.next = node4; node4.next = node2; System.out.println(isRing(node)); } private static boolean isRing(ListNode node) { if (node == null || node.next == null) { return false; } ListNode s = node; ListNode f = node; while (f != null && f.next != null) { s = s.next; f = f.next.next; if (s == f) { return true; } } return false; } }AI 代码解读
5 滑动窗口
滑动窗口也是一种算法小技巧，可以极大的减少重叠部分计算量，尤其是当重叠部分比较大的时候，效果格外明显。滑动窗口主要解决的是连续定长子数组的问题，但是有一些非定长的也可以通过滑动窗口的思想来解决。
当我们移动窗口时只需要排除移除的一个数据，在加入移入的一个数据，窗口内其它数据是不需要做出改变的。
非定长一般需要通过加入内层循环来解决。
/**
* 力扣209 长度最小的子数组
* @author zhj
*/
public class Test209 {
public static void main(String[] args) {
int[] nums = {2,3,1,2,4,3};
System.out.println(mumsLength(nums, 7));
}
private static int mumsLength(int[] nums, int sum) {
if (nums == null || nums.length == 0) {
return 0;
}
int res = nums.length + 1;
int total = 0;
int i = 0;
int j = 0;
while (j < nums.length) {
total = total + nums[j];
j++;
while (total >= sum) {
res = res < j-i ? res : j-i;
total = total - nums[i];
i = i + 1;
}
}
if (res == nums.length + 1) {
return 0;
}
return res;
}
}
AI 代码解读
6 递归
一些复杂的问题，我们往往可以通过递归去简化。
特点：自己调自己，根据特点条件可以返回，不会陷入死循环。
递归的四个要素：
- 参数
- 返回值
- 终止条件
- 递归拆解
经典问题斐波那契数列
0，1，1，2，3，5... f(0) = 0 f(1) = 1 f(n) = f(n-1) + f(n-2)
int recursion(int n) {
if (n < 2) {
return n == 1 ? 1 : 0;
}
return recursion(n-1) + recursion(n-2);
}
AI 代码解读
7 高阶算法
除了上边一些简单的小技巧之外，还有许多高阶的算法，比如由递归引发的分治法、回溯法；还有树和图的遍历方法，深度优先遍历，广度优先遍历；还有经典的算法贪心算法、动态规划等等，本文将不做讲解，后续会单独更新在算法这一专栏中，希望大家持续关注。
