增加算法难点题目总结

Author: hello-java-maker

docs/dataStructures-algorithms/高频算法题目总结.md

@@ -1,6 +1,50 @@
 Ctrl+Shift+P（MacOS：cmd+shift+p）呼出命令面板，输入Markdown Preview Enhanced: Create Toc会生成一段类似，保存生成目录。
 
 
+<!-- @import "[TOC]" {cmd="toc" depthFrom=1 depthTo=6 orderedList=false} -->
+
+<!-- code_chunk_output -->
+
+- [翻转链表](#翻转链表)
+- [实现二叉树先序，中序和后序遍历](#实现二叉树先序中序和后序遍历)
+- [设计LRU缓存结构](#设计lru缓存结构)
+- [两个链表的第一个公共结点](#两个链表的第一个公共结点)
+- [求平方根](#求平方根)
+- [寻找第K大](#寻找第k大)
+- [判断链表中是否有环](#判断链表中是否有环)
+- [合并有序链表](#合并有序链表)
+- [合并k个已排序的链表](#合并k个已排序的链表)
+- [数组中相加和为0的三元组](#数组中相加和为0的三元组)
+- [删除链表的倒数第n个节点](#删除链表的倒数第n个节点)
+- [二分查找](#二分查找)
+- [两个链表生成相加链表](#两个链表生成相加链表)
+- [二叉树的之字形层序遍历](#二叉树的之字形层序遍历)
+- [链表内指定区间反转](#链表内指定区间反转)
+- [二叉树的镜像](#二叉树的镜像)
+- [数组中只出现一次的数字](#数组中只出现一次的数字)
+- [最长的括号子串](#最长的括号子串)
+- [把二叉树打印成多行](#把二叉树打印成多行)
+- [合并两个有序的数组](#合并两个有序的数组)
+- [二叉树的最大路径和](#二叉树的最大路径和)
+- [买卖股票的最佳时机](#买卖股票的最佳时机)
+- [二叉树中是否存在节点和为指定值的路径](#二叉树中是否存在节点和为指定值的路径)
+- [设计getMin功能的栈](#设计getmin功能的栈)
+- [LFU缓存结构设计](#lfu缓存结构设计)
+- [N皇后问题](#n皇后问题)
+- [带权值的最小路径和](#带权值的最小路径和)
+- [反转数字](#反转数字)
+- [二叉搜索树的第k个结点](#二叉搜索树的第k个结点)
+- [子数组最大乘积](#子数组最大乘积)
+- [最长递增子序列](#最长递增子序列)
+- [在两个长度相等的排序数组中找到上中位数](#在两个长度相等的排序数组中找到上中位数)
+- [判断t1树中是否有与t2树拓扑结构完全相同的子树](#判断t1树中是否有与t2树拓扑结构完全相同的子树)
+- [反转字符串](#反转字符串)
+- [最大正方形](#最大正方形)
+
+<!-- /code_chunk_output -->
+
+
+
 ### 翻转链表
 
 ```java
@@ -1386,44 +1430,188 @@ public class Solution {
 }
 ```
 
-###
-
-```java
-
-```
-
-###
+### 最长递增子序列
 
 ```java
+public int[] LIS (int[] arr) {
+    // write code here
+    if(arr == null || arr.length <= 0){
+        return null;
+    }
 
-```
-
-###
-
-```java
+    int len = arr.length;
+    int[] count = new int[len];             // 存长度
+    int[] end = new int[len];               // 存最长递增子序列
+
+    //init
+    int index = 0;                          // end 数组下标
+    end[index] = arr[0];
+    count[0] = 1;
+
+    for(int i = 0; i < len; i++){
+        if(end[index] < arr[i]){
+            end[++index] = arr[i];
+            count[i] = index;
+        }
+        else{
+            int left = 0, right = index;
+            while(left <= right){
+                int mid = (left + right) >> 1;
+                if(end[mid] >= arr[i]){
+                    right = mid - 1;
+                }
+                else{
+                    left = mid + 1;
+                }
+            }
+            end[left] = arr[i];
+            count[i] = left;
+        }
+    }
 
+    //因为返回的数组要求是字典序，所以从后向前遍历
+    int[] res = new int[index + 1];
+    for(int i = len - 1; i >= 0; i--){
+        if(count[i] == index){
+            res[index--] = arr[i];
+        }
+    }
+    return res;
+}
 ```
 
-###
+### 在两个长度相等的排序数组中找到上中位数
 
 ```java
-
+public int findMedianinTwoSortedAray (int[] arr1, int[] arr2) {
+    // write code here
+    int n = arr1.length;
+    if(n==0){
+        return 0;
+    }
+    //arr1左右两端
+    int l1=0,r1=n-1;
+    //arr2左右两端
+    int l2=0,r2=n-1;
+    int mid1,mid2;
+    //终止条件为l1=r1，即两个数组都只有一个元素，此时的上中位数为两数的最小值
+    while(l1< r1){ 
+        //arr1中位数
+        mid1 = l1+((r1-l1)>>1);
+        //arr2中位数
+        mid2 = l2+((r2-l2)>>1);
+        int k = r1-l1+1;
+        if(arr1[mid1] == arr2[mid2]){ //若两数组中位数相等，整体中位数也是这个
+            return arr1[mid1];
+        }
+        else if(arr1[mid1] > arr2[mid2]){
+            if(k%2 == 0){//区间元素个数为偶数
+                r1 = mid1; //整体中位数在arr1左区间,包括mid1
+                l2 = mid2+1; //整体中位数在arr2右区间，不包括mid2
+            }
+            else if(k%2 == 1){ //区间元素个数为奇数
+                r1 = mid1; //整体中位数在arr1左区间,包括mid1
+                l2 = mid2; //整体中位数在arr2右区间，包括mid2
+            }
+        }
+        else if (arr1[mid1] < arr2[mid2]){
+            if(k%2 == 0){//区间元素个数为偶数
+                r2 = mid2; //整体中位数在arr2左区间,包括mid2
+                l1 = mid1+1; //整体中位数在arr1右区间，不包括mid1
+            }
+            else if(k%2 == 1){ //区间元素个数为奇数
+                r2 = mid2; //整体中位数在arr2左区间,包括mid2
+                l1 = mid1; //整体中位数在arr1右区间，包括mid1
+            }
+        }
+    }
+    //当区间内只有一个元素时，两个区间中最小值即为整体中位数
+    return Math.min(arr1[l1],arr2[l2]);
+}
 ```
 
-###
+### 判断t1树中是否有与t2树拓扑结构完全相同的子树
 
 ```java
+/**
+    * 
+    * @param root1 TreeNode类 
+    * @param root2 TreeNode类 
+    * @return bool布尔型
+    */
+public boolean isContains (TreeNode root1, TreeNode root2) {
+    // write code here
+    if(root1 == null || root2 == null){
+        return false;
+    }
+    return recur(root1, root2) || isContains(root1.left,root2) || isContains(root1.right,root2);
+}
 
+public boolean recur(TreeNode root1, TreeNode root2){
+    if(root2 == null){
+        return true;
+    }
+    if(root1 == null || root1.val != root2.val){
+        return false;
+    }
+    return recur(root1.left,root2.left) && recur(root1.right,root2.right);
+}
 ```
 
-###
+### 反转字符串
 
 ```java
-
+/**
+* 反转字符串
+* @param str string字符串 
+* @return string字符串
+*/
+public String solve (String str) {
+    // write code here
+    if(str == null){
+        return null;
+    }
+    char[] c = new char[str.length()];
+    int left = 0, right = str.length() - 1;
+    
+    while(left <= right){
+        c[left] = str.charAt(right);
+        c[right] = str.charAt(left);
+        left++;
+        right--;
+    }
+    return new String(c);
+}
 ```
 
-###
+### 最大正方形
 
 ```java
-
+/**
+* 最大正方形
+* @param matrix char字符型二维数组 
+* @return int整型
+*/
+public int solve (char[][] matrix) {
+    // write code here
+    int m = matrix.length;
+    int n = matrix[0].length;
+    int dp[][] = new int [m][n];
+        for(int i = 0; i < m; i++){
+            dp[i][0] = matrix[i][0] - '0';
+        }
+    for(int j = 0; j < n; j++){
+        dp[0][j] = matrix[0][j] - '0';
+    }
+    int max = 0;
+    for(int i = 1; i < m; i++){
+        for(int j = 1; j < n; j++){
+            if(matrix[i][j] == '1'){
+                dp[i][j] = Math.min(Math.min(dp[i-1][j-1],dp[i][j-1]),dp[i-1][j]) + 1;
+                max = Math.max(max,dp[i][j]);
+            }
+        }
+    }
+    return max*max;
+}
 ```