常见基础算法整理

算法

按数量级递增排列，常见的时间复杂度有：常数阶O(1),对数阶O(log2n),线性阶O(n), 线性对数阶O(nlog2n),平方阶O(n2)，立方阶O(n3),...， k次方阶O(nk),指数阶O(2n)

当一个算法的空间复杂度为一个常量，即不随被处理数据量n的大小而改变时，可表示为O(1)；当一个算法的空间复杂度与以2为底的n的对数成正比时，可表示为0(10g2n)；当一个算法的空I司复杂度与n成线性比例关系时，可表示为0(n).若形参为数组，则只需要为它分配一个存储由实参传送来的一个地址指针的空间，即一个机器字长空间；若形参为引用方式，则也只需要为其分配存储一个地址的空间，用它来存储对应实参变量的地址，以便由系统自动引用实参变量。

给定一个二叉搜索树(BST)，找到树中第 K 小的节点

在二叉查找树种：

（1）若任意结点的左子树不空，则左子树上所有结点的值均小于它的根结点的值。

（2）任意结点的右子树不空，则右子树上所有结点的值均大于它的根结点的值。

（3）任意结点的左、右子树也分别为二叉查找树。

（4）没有键值相等的结点。

二叉树的遍历次序：

前序顺序是根节点排最先，然后同级先左后右；中序顺序是先左后根最后右；后序顺序是先左后右最后根。

树相关的题目，第一眼就想到递归求解，左右子树分别遍历。联想到二叉搜索树的性质，root 大于左子树，小于右子树，如果左子树的节点数目等于 K-1，那么 root 就是结果，否则如果左子树节点数目小于 K-1，那么结果必然在右子树，否则就在左子树。因此在搜索的时候同时返回节点数目，跟 K 做对比，就能得出结果了。 public class TreeNode {       int val;       TreeNode left;       TreeNode right;      TreeNode(int x) { val = x; }}  class Solution {       private class ResultType {                  boolean found;  // 是否找到                   int val;  // 节点数目             ResultType(boolean found, int val) {                   this.found = found;                 this.val = val;          }      }      public int kthSmallest(TreeNode root, int k) {          return kthSmallestHelper(root, k).val;    }      private ResultType kthSmallestHelper(TreeNode root, int k) {           if (root == null) {                 return new ResultType(false, 0);           }           ResultType left = kthSmallestHelper(root.left, k);         // 左子树找到，直接返回           if (left.found) {                 return new ResultType(true, left.val);          } // 左子树的节点数目 = K-1，结果为 root 的值         if (k - left.val == 1) {                return new ResultType(true, root.val);          }  // 右子树寻找          ResultType right = kthSmallestHelper(root.right, k - left.val - 1);          if (right.found) {                return new ResultType(true, right.val);           } // 没找到，返回节点总数          return new ResultType(false, left.val + 1 + right.val);     } }

给定一个链表，删除链表的倒数第 N 个节点，并且返回链表的头结点

public class Num19 {     public static void main(String[] args) {         int[] arr = {3, 2, 5, 8, 4, 7, 6, 9};         ListNode head = new ListNode(arr);         head = removeNthFromEnd(head, 8);         System.out.println(head.toString());     }     public static ListNode removeNthFromEnd(ListNode head, int n) {         //当链表为空或者要删除的节点小于等于0的时候，直接返回head         if (head == null || n <= 0)             return head;         //建立一个虚拟的表头结点，因为需要删除的节点有可能是头结点，         // 所以建立虚拟头结点可以不用分是否是头结点两种情况         ListNode tempHead = new ListNode(0);         tempHead.next = head;         ListNode p = tempHead, q = tempHead;         //p指针比q指针先跑n次         for (int i = 0; i < n; i++) {             //如果p为空的时候，说明这个节点的长度不足n，返回head             if (p == null )                 return head;             else {                 p = p.next;             }         }         //p，q一起往前跑，直到p的next为空，         // q所指向的下一个结点就是要删除的元素的位置         while (p.next != null) {             p = p.next;             q = q.next;         }         //删除q指向的节点的下一个元素         q.next = q.next.next;         //删除虚拟头结点         return tempHead.next;     }     static class ListNode {         int val;         ListNode next;         ListNode(int x) {             val = x;         }         public ListNode(int[] arr) {             if (arr == null || arr.length == 0)                 throw new IllegalArgumentException("arr can to be empty");             this.val = arr[0];             ListNode cur = this;             for (int i = 1; i < arr.length; i++) {                 cur.next = new ListNode(arr[i]);                 cur = cur.next;             }         }         @Override         public String toString() {             StringBuilder res = new StringBuilder();             ListNode cur = this;             while (cur != null) {                 res.append(cur.val + "->");                 cur = cur.next;             }             res.append("NULL");             return res.toString();         }     } }

反转链表按k，最长重复子串

 

给定一个整数数组和一个整数，返回两个数组的索引，这两个索引指向的数字

的加和等于指定的整数。需要最优的算法，分析算法的空间和时间复杂度

public int[] twoSum(int[] nums, int target) {     if(nums==null || nums.length<2)        return new int[]{0,0};      HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();    for(int i=0; i<nums.length; i++){         if(map.containsKey(nums[i])){             return new int[]{map.get(nums[i]), i};         }else{             map.put(target-nums[i], i);             }    }       return new int[]{0,0};} 分析：空间复杂度和时间复杂度均为 O(n)

已知 sqrt (2)约等于 1.414，要求不用数学库，求 sqrt (2)精确到小数点后 10 位。

public class Main {     public static void main(String[] args) {         double l = 1.41;         double r = 1.42;         double mid = (r+l)/2;         double flag = 0.0000000001;                 while(r-l > flag){             mid = (r+l)/2;             if(mid*mid < 2)                 l = mid;             else                 r = mid;         }                 System.out.println(mid);     }     }

如何实现一个高效的单向链表逆序输出？

 直接递归（简单，但O(n)空间复杂度不支持大数据量）

// 直接递归实现核心代码片段 public void reverse(head){ // 递归终止条件 if(head.next == null){ print(head); return; } // 下一层需要做的事儿 reverse(head.next); // 本层需要做的事儿 print(head); }

JAVA算法：最长重复子串问题（JAVA解题）

package com.bean.algorithm.basic; public class LongestRepeatingSubstring { // Returns the longest repeating non-overlapping // substring in str static String longestRepeatedSubstring(String str) { int n = str.length(); int LCSRe[][] = new int[n + 1][n + 1]; String res = ""; // To store result int res_length = 0; // To store length of result // building table in bottom-up manner int i, index = 0; for (i = 1; i <= n; i++) { for (int j = i + 1; j <= n; j++) { // (j-i) > LCSRe[i-1][j-1] to remove // overlapping if (str.charAt(i - 1) == str.charAt(j - 1) && LCSRe[i - 1][j - 1] < (j - i)) { LCSRe[i][j] = LCSRe[i - 1][j - 1] + 1; // updating maximum length of the // substring and updating the finishing // index of the suffix if (LCSRe[i][j] > res_length) { res_length = LCSRe[i][j]; index = Math.max(i, index); } } else { LCSRe[i][j] = 0; } } } // If we have non-empty result, then insert all // characters from first character to last // character of String if (res_length > 0) { for (i = index - res_length + 1; i <= index; i++) { res += str.charAt(i - 1); } } return res; } // Driver program to test the above function public static void main(String[] args) { String str = "aabaabaaba"; System.out.println(longestRepeatedSubstring(str)); } }

给一个数组，找出出现次数大于数组长度一半的那个数。（我直接无脑用哈希表，面试官皱着眉头说能优化不，我想了半天没想出来）。

package test; public class Search {     public static void main(String[] args) {     //System.out.println("Hello World!");         Integer []a={4,5,5,2,3,5,2,5,5,5};         Integer len= a.length;         Integer result = search(a,len);         System.out.println(result);     }     public static Integer search(Integer A[],Integer len){         if(A==null || len<=0)         {             return -1;         }         Integer k=null, j=0;         for(Integer i=0;i<len;++i)         {             if(j==0)             {                 k=A[i];             }             if(k==A[i])             {                 ++j;             }else             {                 --j;             }         }         return k;     } }

给一个链表1->2->3->4->5->6->7 和 一个数字n每n个反转一次链表。如 n = 2时,2->1->4->3->6->5->7;n = 3时,3->2->1>6->5->4->7

 

罗马数字转整数 leetcode13

class Solution {     public int romanToInt(String s) {          Map<Character,Integer> map = new HashMap<>();         map.put('I',1);         map.put('V',5);         map.put('X',10);         map.put('L',50);         map.put('C',100);         map.put('D',500);         map.put('M',1000);         //用map结构来存储字母与带表的值         char[] temp = s.toCharArray();//将其转化为数组会索引时会更快         int length = temp.length;//现记录长度，避免循环的时候每次都要去计算         int sum = 0;//原来保存最后的值         for(int i=0;i<length-1;i++){//只循环到倒数第二个，因为最后一个肯定是被加上的数             int curTemp = map.get(temp[i]);//获取当前字母的值             int nextTemp = map.get(temp[i+1]);//获取相邻字母的值             sum += curTemp < nextTemp ? -curTemp : curTemp;//比较，如果当前值小于右边，就应该减，否则加         }         return sum+ map.get(temp[length-1]);//之前循环的时候并没有循环最后一个，因为最后一个无论如何都是会被加上的，所以此时加上     } }

反转链表，删除排好序数组中重复元素

/** * 单链表相关操作 * * @author yinhr * */ public class LinkedListUtil { /** * 反转链表(3指针pre head headNext) * * @param head * @return */ ListNode reverse(ListNode head) { ListNode pre = null; ListNode headNext; while (head != null) { headNext = head.next; head.next = pre; pre = head; head = headNext; } return pre; } /** * 删除有序链表中重复值，重复值不保留(头结点+三指针pre head end) * * @param head * @return */ ListNode deleteRepeat(ListNode head) { // 创建头节点用于返回链表 ListNode headNode = new ListNode(0, head); ListNode pre = headNode; // 用于寻找第一个不同值节点 ListNode end; while (head != null && head.next != null) { // 当前值和它的下个值不等则移动两指针 if (head.value != head.next.value) { pre = head; head = head.next; } else { end = head.next.next; while (end != null && end.value == head.value) { end = end.next; } pre.next = end; head = end; } } return headNode.next; } /** * 删除有序链表中重复值，重复值保留一个(1)两指针listHead head，相邻两个相等删除后一个(2)三指针listHead head end * * @param head * @return */ ListNode deleteRepeatKeepOne(ListNode head) { // 用于返回链表 ListNode listHead = head; // （1）用于寻找第一个不同值节点 ListNode end; while (head != null && head.next != null) { // 当前值和它的下个值不等则移动指针 if (head.value != head.next.value) { head = head.next; } else { // （2）也可只用list.next = list.next.next; end = head.next.next; while (end != null && end.value == head.value) { end = end.next; } head.next = end; head = end; } } return listHead; } }

数据库

大数据

阿里巴巴

 

146. LRU缓存机制	中等	2021-06-17	15
1. 两数之和	容易	2021-08-04	13
206. 反转链表	容易	2021-08-12	10
3. 无重复字符的最长子串	中等	2021-08-05	10
215. 数组中的第K个最大元素	中等	2021-06-06	10
102. 二叉树的层序遍历	中等	2021-04-16	9
165. 比较版本号	中等	2021-06-16	8
94. 二叉树的中序遍历	容易	2021-04-09	8
15. 三数之和	中等	2021-06-16	7
141. 环形链表	容易	2021-07-25	5
20. 有效的括号	容易	2021-07-05	5
23. 合并K个排序链表	困难	2021-06-28	5
169. 多数元素	容易	2021-06-06	5
46. 全排列	中等	2021-05-10	5
415. 字符串相加	容易	2021-03-22	5
53. 最大子序和	容易	2021-08-02	4
144. 二叉树的前序遍历	容易	2021-05-09	4
121. 买卖股票的最佳时机	容易	2021-05-08	4
232. 用栈实现队列	容易	2021-04-25	4
5. 最长回文子串	中等	2021-04-15	4
补充题4. 手撕快速排序	中等	2021-04-14	4
剑指 Offer 22. 链表中倒数第k个节点	容易	2021-04-09	4
145. 二叉树的后序遍历	中等	2020-07-07	4
226. 翻转二叉树	容易	2021-07-05	3
42. 接雨水	困难	2021-06-16	3
92. 反转链表 II	中等	2021-06-09	3
88. 合并两个有序数组	容易	2021-05-28	3
200. 岛屿数量	中等	2021-05-25	3
105. 从前序与中序遍历序列构造二叉树	中等	2021-05-08	3
70. 爬楼梯	容易	2021-04-12	3
151. 翻转字符串里的单词	中等	2021-04-11	3
236. 二叉树的最近公共祖先	中等	2021-04-09	3
704. 二分查找	容易	2021-04-03	3
1143. 最长公共子序列	中等	2021-03-09	3
72. 编辑距离	困难	2021-02-22	3
剑指 Offer 09. 用两个栈实现队列	容易	2020-12-14	3
73. 矩阵置零	中等	2021-08-09	2
62. 不同路径	中等	2021-08-07	2
695. 岛屿的最大面积	中等	2021-08-03	2
33. 搜索旋转排序数组	中等	2021-07-26
剑指 Offer 27. 二叉树的镜像	容易	2021-06-05	2
155. 最小栈	容易	2021-05-24	2
300. 最长上升子序列	中等	2021-05-20	2
443. 压缩字符串	中等	2021-04-16	2
剑指 Offer 39. 数组中出现次数超过一半的数字	容易	2021-04-15	2
225. 用队列实现栈	容易	2021-04-15	2
718. 最长重复子数组	中等	2021-04-06	2
160. 相交链表	容易	2021-04-02	2
34. 在排序数组中查找元素的第一个和最后一个位置	中等	2021-03-30	2
43. 字符串相乘	中等	2021-03-29	2
179. 最大数	中等	2021-03-29	2
39. 组合总和	中等	2021-03-22	2
31. 下一个排列	中等	2021-03-19	2
25. K 个一组翻转链表	困难	2021-03-18	2
剑指 Offer 40. 最小的k个数	容易	2021-03-18	2
349. 两个数组的交集	容易	2021-03-11	2
836. 矩形重叠	容易	2021-03-09	2
815. 公交路线	困难	2021-03-07	2
1411. 给 N x 3 网格图涂色的方案数	困难	2021-03-07	2
142. 环形链表 II	中等	2021-03-06
64. 最小路径和	中等	2021-03-05	2
剑指 Offer 21. 调整数组顺序使奇数位于偶数前面	容易	2021-02-27	2
543. 二叉树的直径	容易	2020-07-07	2
557. 反转字符串中的单词 III	容易	2020-07-07	2
剑指 Offer 24. 反转链表	容易	2020-07-07	2
238. 除自身以外数组的乘积	中等	2021-08-10	1
127. 单词接龙	困难	2021-08-07	1
1277. 统计全为 1 的正方形子矩阵	中等	2021-08-03	1
8. 字符串转换整数 (atoi)	中等	2021-07-30	1
296. 最佳的碰头地点	困难	2021-07-24	1
140. 单词拆分 II	困难	2021-07-23	1
1047. 删除字符串中的所有相邻重复项	容易	2021-07-12	1
135. 分发糖果	困难	2021-07-08	1
162. 寻找峰值	中等	2021-07-06	1
386. 字典序排数	中等	2021-06-24	1
41. 缺失的第一个正数	困难	2021-06-21	1
剑指 Offer 28. 对称的二叉树	容易	2021-06-10	1
106. 从中序与后序遍历序列构造二叉树	中等	2021-06-05	1
478. 在圆内随机生成点	中等	2021-05-25	1
19. 删除链表的倒数第N个节点	中等	2021-05-20
498. 对角线遍历	中等	2021-05-14	1
97. 交错字符串	中等	2021-05-11	1
103. 二叉树的锯齿形层次遍历	中等	2021-05-11	1
222. 完全二叉树的节点个数	中等	2021-04-27	1
572. 另一个树的子树	容易	2021-04-27	1
208. 实现 Trie (前缀树)	中等	2021-04-25	1
759. 员工空闲时间	困难	2021-04-23	1
503. 下一个更大元素 II	中等	2021-04-23	1
505. 迷宫 II	中等	2021-04-22	1
316. 去除重复字母	中等	2021-04-15	1
剑指 Offer 36. 二叉搜索树与双向链表	中等	2021-04-15	1
1306. 跳跃游戏 III	中等	2021-04-13	1
剑指 Offer 62. 圆圈中最后剩下的数字	容易	2021-04-12	1
93. 复原IP地址	中等	2021-04-12	1
392. 判断子序列	容易	2021-04-11	1
700. 二叉搜索树中的搜索	容易	2021-04-11	1
63. 不同路径 II	中等	2021-04-10	1
384. 打乱数组	中等	2021-04-09	1
24. 两两交换链表中的节点	中等	2021-04-07	1
153. 寻找旋转排序数组中的最小值	中等	2021-04-03

 

字节

3. 无重复字符的最长子串	中等	2021-08-13	134
215. 数组中的第K个最大元素	中等	2021-08-13	104
206. 反转链表	容易	2021-08-14	98
146. LRU缓存机制	中等	2021-08-10	98
25. K 个一组翻转链表	困难	2021-08-04	94
103. 二叉树的锯齿形层次遍历	中等	2021-08-12	84
121. 买卖股票的最佳时机	容易	2021-08-13	72
15. 三数之和	中等	2021-07-27	72
160. 相交链表	容易	2021-08-01	70
1. 两数之和	容易	2021-08-10	61
236. 二叉树的最近公共祖先	中等	2021-08-13	56
42. 接雨水	困难	2021-08-12	53
53. 最大子序和	容易	2021-08-10	48
33. 搜索旋转排序数组	中等	2021-08-11	47
54. 螺旋矩阵	中等	2021-08-06	46
21. 合并两个有序链表	容易	2021-08-05	46
415. 字符串相加	容易	2021-08-10	45
200. 岛屿数量	中等	2021-08-09	45
300. 最长上升子序列	中等	2021-08-10	43
88. 合并两个有序数组	容易	2021-08-09	43
199. 二叉树的右视图	中等	2021-08-12	41
143. 重排链表	中等	2021-08-11	40
141. 环形链表	容易	2021-08-12	39
31. 下一个排列	中等	2021-08-02	39
46. 全排列	中等	2021-08-09	38
102. 二叉树的层序遍历	中等	2021-07-28	38
20. 有效的括号	容易	2021-08-10	37
5. 最长回文子串	中等	2021-08-11	36
23. 合并K个排序链表	困难	2021-08-13	35
41. 缺失的第一个正数	困难	2021-08-12	35
69. x 的平方根	容易	2021-08-11	34
105. 从前序与中序遍历序列构造二叉树	中等	2021-08-05	34
101. 对称二叉树	容易	2021-07-24	34
56. 合并区间	中等	2021-08-11	33
129. 求根到叶子节点数字之和	中等	2021-08-11	33
92. 反转链表 II	中等	2021-08-08	33
113. 路径总和 II	中等	2021-08-11	32
112. 路径总和	容易	2021-08-02	31
94. 二叉树的中序遍历	容易	2021-08-10	29
76. 最小覆盖子串	困难	2021-08-07
124. 二叉树中的最大路径和	困难	2021-07-26	29
98. 验证二叉搜索树	中等	2021-08-09	28
142. 环形链表 II	中等	2021-08-07	28
232. 用栈实现队列	容易	2021-07-22	27
32. 最长有效括号	困难	2021-08-11	26
221. 最大正方形	中等	2021-08-08	26
958. 二叉树的完全性检验	中等	2021-08-11	25
82. 删除排序链表中的重复元素 II	中等	2021-08-13	24
70. 爬楼梯	容易	2021-08-09	24
补充题1. 排序奇升偶降链表	中等	2021-07-22	24
165. 比较版本号	中等	2021-08-12	23
155. 最小栈	容易	2021-08-07	23
93. 复原IP地址	中等	2021-08-12	22
39. 组合总和	中等	2021-08-12	22
322. 零钱兑换	中等	2021-08-11	22
470. 用 Rand7() 实现 Rand10()	中等	2021-08-03	22
剑指 Offer 22. 链表中倒数第k个节点	容易	2021-06-17	22
48. 旋转图像	中等	2021-08-13	21
148. 排序链表	中等	2021-08-10	21
162. 寻找峰值	中等	2021-08-10
补充题4. 手撕快速排序	中等	2021-08-09	21
122. 买卖股票的最佳时机 II	容易	2021-08-04	21
19. 删除链表的倒数第N个节点	中等	2021-07-28	21
2. 两数相加	中等	2021-06-10	21
78. 子集	中等	2021-08-13	20
64. 最小路径和	中等	2021-08-09	20
240. 搜索二维矩阵 II	中等	2021-08-05	20
209. 长度最小的子数组	中等	2021-07-30	20
72. 编辑距离	困难	2021-08-06	19
79. 单词搜索	中等	2021-08-05	19
718. 最长重复子数组	中等	2021-08-03	18
518. 零钱兑换 II	中等	2021-07-30	18
543. 二叉树的直径	容易	2021-06-17	18
169. 多数元素	容易	2021-04-16	18
补充题2. 圆环回原点问题	中等	2021-08-12	17
234. 回文链表	容易	2021-08-09	17
22. 括号生成	中等	2021-08-06	17
104. 二叉树的最大深度	容易	2021-08-04	17
198. 打家劫舍	中等	2021-08-01	17
226. 翻转二叉树	容易	2021-07-27
83. 删除排序链表中的重复元素	容易	2021-07-26	17
1143. 最长公共子序列	中等	2021-08-06	16
8. 字符串转换整数 (atoi)	中等	2021-08-04	16
110. 平衡二叉树	容易	2021-08-03	16
695. 岛屿的最大面积	中等	2021-07-28	16
剑指 Offer 09. 用两个栈实现队列	容易	2021-07-28	16
239. 滑动窗口最大值	困难	2021-07-27	16
4. 寻找两个正序数组的中位数	困难	2021-08-10	15
128. 最长连续序列	中等	2021-08-08	15
704. 二分查找	容易	2021-08-03	15
151. 翻转字符串里的单词	中等	2021-08-02	15
补充题9. 36进制加法	中等	2021-07-26	15
62. 不同路径	中等	2021-07-16	15
394. 字符串解码	中等	2021-08-11	14
468. 验证IP地址	中等	2021-08-12	13
402. 移掉K位数字	中等	2021-08-12	13
179. 最大数	中等	2021-08-04	13
114. 二叉树展开为链表	中等	2021-07-21	13
144. 二叉树的前序遍历	容易	2021-07-15	13
230. 二叉搜索树中第K小的元素	中等	2021-04-23