update top_freq_algorithm

Author: quchao161

algotithm/top_freq_question.md

@@ -2,6 +2,7 @@
 
 import java.util.PriorityQueue;
 
+
 /**
  * 题目描述：给你一个链表数组，每个链表都已经按升序排列。
  * 请你将所有链表合并到一个升序链表中，返回合并后的链表。

data_struct_study/.idea/workspace.xml

@@ -1,8 +1,8 @@
 package LinkedList_problem;
 
-
 import java.util.Stack;
 
+
 /**
  * 题目描述：给你两个 非空 链表来代表两个非负整数。数字最高位位于链表开始位置。
  * 它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。
@@ -11,7 +11,6 @@
  * 进阶：如果输入链表不能修改该如何处理？换句话说，你不能对列表中的节点进行翻转。
  *
  * 示例：
- *
  * 输入：(7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
  * 输出：7 -> 8 -> 0 -> 7
  *

data_struct_study/src/LinkedList_problem/Solution23.java

@@ -1,5 +1,6 @@
 package LinkedList_problem;
 
+
 /**
  * 单链表的选择排序：
  *

data_struct_study/src/LinkedList_problem/Solution445.java

@@ -43,30 +43,4 @@ public ListNode findKthToTail(ListNode head, int k) {
         return P2;
     }
 
-    public ListNode findKthToEnd(ListNode head, int k) {
-        // 1、异常处理：如果head==null，则直接返回
-        if (head == null) {
-            return null;
-        }
-
-        // 2、初始化P1，然后移动P1 k步
-        ListNode P1 = head;
-        while (P1 != null && k-- > 0) {
-            P1 = P1.next;
-        }
-
-        // 3、异常处理：如果k步没有走完，直接返回null
-        if (k > 0) {
-            return null;
-        }
-
-        // 4、初始化P2，然后同时移动P1、P2，当P1走到null时，P2就是倒数第k个节点
-        ListNode P2 = head;
-        while (P1 != null) {
-            P1 = P1.next;
-            P2 = P2.next;
-        }
-
-        return P2;
-    }
 }

data_struct_study/src/LinkedList_problem/Solution_2.java

@@ -1,10 +1,10 @@
 package LinkedList_problem;
 
 
-import java.security.PublicKey;
-
-// 快慢指针:
-// 时间复杂度：O(n), 空间复杂度：O(1)
+/**
+ * 快慢指针:
+ * 时间复杂度：O(n), 空间复杂度：O(1)
+ */
 public class Solution_4_4 {
 
     // 4、快慢指针解法：先使用快慢指针找到前半个链表的尾节点，然后翻转后半个部分链表，

data_struct_study/src/LinkedList_problem/Solution_3.java

@@ -5,6 +5,7 @@
  * 100 万的数据量只需零点几秒。
  * 注意搜索开闭区间的设定，例如 [0, n - 1] 或 [0, n)。
  * 1962 才意识到的 bug：mid = (l + r) / 2 可能会产生整形溢出，推荐使用减法：l + (r-l)/2。
+ *
  * 如何写出正确的程序？
  *      1、明确变量的含义。
  *      2、循环不变量。

data_struct_study/src/LinkedList_problem/Solution_4_4.java

@@ -1,30 +1,21 @@
 package array_problem;
-//https://leetcode-cn.com/problems/container-with-most-water/:盛最多水的容器
+
 
 /**
  * 给你 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。
  * 在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。
  * 找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
  *
  * 说明：你不能倾斜容器，且 n 的值至少为 2。
- *
- *  
- *
- *
- *
- * 图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
- *
- *  
+ * 图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，
+ * 容器能够容纳水（表示为蓝色部分）的最大值为 49。
  *
  * 示例：
- *
  * 输入：[1,8,6,2,5,4,8,3,7]
  * 输出：49
- *
  */
 public class Solution11 {
 
-
     public int maxArea(int[] height) {
 
         // 1、初始化记录窗口左右边界的位置 & 最大面积

data_struct_study/src/array_problem/BinarySearch2.java

@@ -1,15 +1,13 @@
 package array_problem;
-//https://leetcode-cn.com/problems/two-sum-ii-input-array-is-sorted/:两数之和 II - 输入有序数组
 
 import java.util.Arrays;
 
+
 /**
  * 给定一个已按照升序排列 的有序数组，找到两个数使得它们相加之和等于目标数。
- *
  * 函数应该返回这两个下标值 index1 和 index2，其中 index1 必须小于 index2。
  *
  * 说明:
- *
  * 返回的下标值（index1 和 index2）不是从零开始的。
  * 你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。
  * 示例:

data_struct_study/src/array_problem/Solution11.java

@@ -1,10 +1,10 @@
 package array_problem;
 
 /**
- * 在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
+ * 在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后
+ * 的第 k 个最大的元素，而不是第 k 个不同的元素。
  *
  * 示例 1:
- *
  * 输入: [3,2,1,5,6,4] 和 k = 2
  * 输出: 5
  * 示例 2:

data_struct_study/src/array_problem/Solution167.java

@@ -1,23 +1,18 @@
 package array_problem;
-//https://leetcode-cn.com/problems/reverse-string/:反转字符串
+
 
 /**
  * 编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
- *
  * 不要创建另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
- *
  * 你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。
  *
  * 示例 1：
- *
  * 输入：["h","e","l","l","o"]
  * 输出：["o","l","l","e","h"]
- * 示例 2：
  *
+ * 示例 2：
  * 输入：["H","a","n","n","a","h"]
  * 输出：["h","a","n","n","a","H"]
- *
- *
  */
 public class Solution344 {
 

data_struct_study/src/array_problem/Solution215.java

@@ -41,7 +41,6 @@ public int lengthOfLongestSubstring(String s) {
     }
 
     public static void main(String[] args) {
-
         System.out.println((new Solution3_2()).lengthOfLongestSubstring( "abcabcbb" ));
     }
 

data_struct_study/src/array_problem/Solution344.java

@@ -1,7 +1,5 @@
 package array_problem;
 
-import array.Array;
-
 import java.util.Arrays;
 
 /**

data_struct_study/src/array_problem/Solution3_2.java

@@ -48,5 +48,4 @@ public int[][] merge(int[][] intervals) {
         return list.toArray(new int[0][]);
     }
 
-
 }

data_struct_study/src/array_problem/Solution3_4.java

@@ -1,20 +1,16 @@
 package array_problem;
-//https://leetcode-cn.com/problems/merge-sorted-array/:合并两个有序数组
+
 
 /**
  * 给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。
- *
  * 说明: 初始化 nums1 和 nums2 的元素数量分别为 m 和 n。
  * 你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。
  *  
  * 示例:
- *
  * 输入:
  * nums1 = [1,2,3,0,0,0], m = 3
  * nums2 = [2,5,6],       n = 3
- *
  * 输出: [1,2,2,3,5,6]
- *
  */
 public class Solution88 {
 

data_struct_study/src/array_problem/Solution56.java

@@ -6,7 +6,6 @@
  */
 public class Solution_1 {
 
-
     // 1、哈希法：遍历数组，用map记录所有元素出现的次数，然后再遍历数组，找出只出现一次的数。
     // 时间复杂度：O(n), 空间复杂度：O(n)
     // 2、位运算：两个不相等的元素在位级表示上必定会有一位存在不同，将数组的所有元素异或得到的结果

data_struct_study/src/array_problem/Solution88.java

@@ -3,6 +3,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
+
 /**
  * 排列问题
  * 时间复杂度：O(n*n!)

data_struct_study/src/array_problem/Solution_1.java

@@ -1,10 +1,10 @@
 package backstracking_problem;
 
-
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
+
 /**
  * 排列问题
  * 时间复杂度：O(n*n!)

data_struct_study/src/backstracking_problem/Solution46.java

@@ -4,11 +4,13 @@
 import java.util.LinkedList;
 import java.util.List;
 
+
 /**
  * 递归与回溯
  *
  * 题目描述：给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。
- * 有效的 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。
+ * 有效的 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），
+ * 整数之间用 '.' 分隔。
  *
  * 时间复杂度：O(3 ^ SEG_COUNT * ∣s∣)
  * 空间复杂度：O(SEG_COUNT)

data_struct_study/src/backstracking_problem/Solution47.java

@@ -1,8 +1,8 @@
 package binary_search_tree_problem;
 
+
 /**
  * 二叉树根节点到所有叶子节点的路径之和：
- *
  * 先序遍历的思想(根左右)+数字求和(每一层都比上层和*10+当前根节点的值)
  * 时间复杂度：O(n)
  * 空间复杂度：O(n)

data_struct_study/src/backstracking_problem/Solution93.java

@@ -2,6 +2,7 @@
 
 import java.util.*;
 
+
 /**
  * 题目描述：请实现一个函数按照之字形打印二叉树，即第一行按照
  * 从左到右的顺序打印，第二层按照从右至左的顺序打印，

data_struct_study/src/binary_search_tree_problem/Solution_1.java

@@ -2,6 +2,7 @@
 
 import java.util.Arrays;
 
+
 /**
  * 题目描述：给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。
  * 一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的

data_struct_study/src/binary_search_tree_problem/Solution_2.java

@@ -1,5 +1,6 @@
 package dynamic_problem;
 
+
 /**
  * 2、记忆化数组 + DP（自下而上）：躲避边界条件
  * 时间复杂度：O((len(s1) * len(s2))

data_struct_study/src/dynamic_problem/Solution1143.java

@@ -1,5 +1,6 @@
 package dynamic_problem;
 
+
 /**
  * 题目描述：
  * 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。