asd23rsa

算法分类汇总

数位 DP - OI Wiki

按照大纲把下面的题目刷完，并把代码烂熟于心，就几乎可以应对 90% 的面试算法考题了。

本篇内容包括如下模块：

高频算法题系列：链表
【】【有真题】高频算法题系列：字符串
【】【有真题】高频算法题系列：数组问题
高频算法题系列：二叉树
【】高频算法题系列：排序算法
【】高频算法题系列：二分查找
【】高频算法题系列：动态规划
高频算法题系列：BFS
【】高频算法题系列：栈
【】高频算法题系列：DFS
【】高频算法题系列：回溯算法

其中标的部分代表非常高频的考题，其中不乏笔者遇到的原题。其中对于每一类，首先会列出包含的考题，然后针对每一道考题会给出难度、考察知识点、是否是面试真题，在每道题详细介绍时，还会给出每道题的 LeetCode 链接，帮助读者理解题意，以及能够进行实际的测验，还可以观看其他人的答案，更好的帮助准备。

高频算法题系列：链表

笔者遇到的高频链表题主要包含这几道：

通过快慢指针寻找链表中点【简单】
通过链表的后续遍历判断回文链表问题【简单】
链表的反向输出【简单】
合并 K 个升序链表【困难】
K个一组翻转链表【困难】
环形链表【简单】
排序链表【中等】
相交链表【简单】

寻找链表中点

题解

通过快慢指针寻找链表中点

/**
  *
  */
function findCenter(head) {
    let slower = head, faster = head;
    while (faster && faster.next != null) {
        slower = slower.next;
        faster = faster.next.next;
    }
    // 如果 faster 不等于 null，说明是奇数个，slower 再移动一格
    if (faster != null) {
        slower = slower.next;
    }
    return slower;
}

前序遍历判断回文链表

【LeetCode 直通车】：234 回文链表（简单）[1]

题解1

利用链表的后续遍历，使用函数调用栈作为后序遍历栈，来判断是否回文

class Solution {
//方法2，倒叙遍历链表和正顺遍历链表
ListNode left;
boolean isPalindrome=true;
 public boolean isPalindrome(ListNode head) {
     this.left=head;
     isPalindromeDFS(head);
    return this.isPalindrome;

 }
  public void isPalindromeDFS(ListNode right){
      if(right==null){
          return;
      }
      isPalindromeDFS(right.next);
      if(right.val!=this.left.val){
          this.isPalindrome=false;
          return;
      }
      if(this.left!=null){
          this.left=this.left.next;
      }
    
  }


//    public boolean isPalindrome(ListNode head) {
// 		  ListNode fast=head,slow=head;
// 		  while(fast!=null&&fast.next!=null){
// 			  slow=slow.next;
// 			  fast=fast.next.next;
// 		  }
// 		  ListNode  lastNodes=null;
// 		  if(fast==null){
// 			    lastNodes=reverseNode2(slow);
// 		  }else{
// 			    lastNodes=reverseNode2(slow.next);
// 		  }
// 		  while(lastNodes!=null){
// 			  if(head.val!=lastNodes.val){
// 				  return false;
// 			  }
// 			  head=head.next;
// 			  lastNodes=lastNodes.next;
			  
// 		  }
// 		return true;
// 	    }
// 	  public static  ListNode reverseNode2(ListNode head){
//            if(head==null){
// 			  return null;
// 		  }
// 		  if(head.next==null){
// 			  return head;
// 		  }
// 		  ListNode next=head.next;
// 		  ListNode node=reverseNode2(next);
// 		  next.next=head;
// 		  head.next=null;
// 		  return node;
		  
// 	  }
	
}

反转链表

【LeetCode 直通车】：206 反转链表（简单）[2]

题解

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var reverseList = function(head) {
    if (head == null || head.next == null) return head;
    let last = reverseList(head.next);
    head.next.next = head;
    head.next = null;
    return last;
};

方法2
 public ListNode reverseList(ListNode head) {
        if(head==null){
            return null;
        }
        ListNode pre=null,cur=head,next=head.next;
        while(cur!=null){
            next=cur.next;
            cur.next=pre;
            pre=cur;
            cur=next;
        }
        return pre;
 }

合并K个升序链表

【LeetCode 直通车】：23 合并K个升序链表（困难）[3]

347. 前 K 个高频元素

题解

public ListNode mergeKLists(ListNode[] lists) {
	
	PriorityQueue pr=new PriorityQueue(new Comparator(){
        public int compare(ListNode o1,ListNode o2){
            return o1.val-o2.val;
        }
    });
	ListNode head=new ListNode();
	ListNode tail =head;
	if(lists==null||lists.length==0){
		return head.next;
	}
	for(ListNode temp:lists){
		if(temp!=null){
			pr.add(temp);
		}
		
	}
	
	while(!pr.isEmpty()){
		ListNode tempNode=pr.poll();
		tail.next=tempNode;
		tail =tail.next;
		if(tempNode.next!=null)
		pr.offer(tempNode.next);
		
	}
	return head.next;
	
}

92. 反转链表 II

class Solution {
public ListNode nextNewNode=null;
 public ListNode reverseBetween(ListNode head, int left, int right) {
        if(head==null){
            return null;
        }
        if(right==0){
            return head;
        }
        if(left==1){
            return reverseNodesK(head,right);
        }else{
            head.next=reverseBetween(head.next,left-1,right-1);
            return head;
        }
 }
    ListNode reverseNodesK(ListNode head,int k){
        if(head==null||head.next==null){
            return head;
        }
        if(k==1){
            this.nextNewNode=head.next;
            return head;
        }
        ListNode next=head.next;
        ListNode resultNode=reverseNodesK(next,k-1);
        next.next=head;
        head.next=nextNewNode;
        return resultNode;
    }
 
}

K 个一组翻转链表

【LeetCode 直通车】：25 K 个一组翻转链表（困难）[4]

题解

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if(head==null||k==0){
            return head;
        }
        ListNode tail =head;
        for(int i=0;i

 
  环形链表 
   【LeetCode 直通车】：141 环形链表（简单）[5] 
  题解 
   
   /**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @return {boolean}
 */
var hasCycle = function(head) {
    if (head == null || head.next == null) return false;
    let slower = head, faster = head;
    while (faster != null && faster.next != null) {
        slower = slower.next;
        faster = faster.next.next;
        if (slower === faster) return true;
    }
    return false;
};
 
   
  142. 环形链表 II 
   
   public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode faster=head,slower=head;
        while(faster!=null&&faster.next!=null){
            faster=faster.next.next;
            slower=slower.next;
            if(faster==slower){
                slower=head;
                while(slower!=faster){
                    slower=slower.next;
                    faster=faster.next;
                }
                return faster;
            }
        }
        return null;
        
    }
} 
   
   
   
  排序链表 
   【LeetCode 直通车】：148 排序链表（中等）[6] 
  题解 
   
   class Solution {
     public ListNode sortList(ListNode head) {
    	if(head==null||head.next==null){
    		return head;
    	}
    	ListNode middleNode=findMiddle(head);
    	ListNode nextList=middleNode.next;
    	middleNode.next=null;
    	ListNode sortedList1=sortList(head);
    	ListNode sortedList2=sortList(nextList);
    	return mergeSortedList(sortedList1,sortedList2);
    	
    	

    }
    public ListNode findMiddle(ListNode head){
    	ListNode faster=head,slower=head;
        if(faster!=null&&faster.next!=null&&faster.next.next==null){
            return faster;
        }
    	while(faster!=null&&faster.next!=null){
    		faster=faster.next.next;
    		slower=slower.next;
    	}
    	return slower;
    }
    
    public ListNode mergeSortedList(ListNode a,ListNode b){
    	ListNode head=new ListNode(0);
    	ListNode tail=head;
    	while(a!=null&&b!=null){
    		if(a.val>b.val){
    			tail.next=b;
    			tail=tail.next;
    			b=b.next;
    		}else{
    			tail.next=a;
    			tail=tail.next;
    			a=a.next;
    		}
    	}
    	if(a==null){
    		tail.next=b;
    	}else{
    		tail.next=a;
    	}
    	return head.next;
    }
    
} 
   
  相交链表 
   【LeetCode 直通车】：160 相交链表（简单）[7] 
  题解 
   
   public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode tempA=headA,tempB=headB;
        int i=0;
        while(tempA!=tempB){
            tempA=tempA.next;
            tempB=tempB.next;
            if(tempA==null){
                tempA=headB;
                i++;
            }
            if(tempB==null){
                tempB=headA;
                i++;
            }
            if(i>=3){
                return null;
            }
        }
        return tempA;
        
    }
} 
   
  【】高频算法题系列：字符串 
  主要有以下几类高频考题： 
   
    最长回文子串 【中等】【双指针】【面试真题】
  
    最长公共前缀 【简单】【双指针】
  
    无重复字符的最长子串【中等】【双指针】
  
    最小覆盖子串 【困难】【滑动窗口】【面试真题】
  
    424. 替换后的最长重复字符
  
   
  【面试真题】最长回文子串【双指针】 
   【LeetCode 直通车】：5 最长回文子串（中等）[8] 
  题解 
   
   class Solution {
   	   
	    public String longestPalindrome(String s) {
            int maxLength=0;
	        String longestPalindromeStr="";
			  if(s==null||s.length()==0){
                  return null;
              }
               if(s.length()==1){
                  return s;
              }
              int dp[][]=new int[s.length()][s.length()];
              for(int i=0;i0&&s.charAt(i)==s.charAt(j)){
                               dp[j][i]=dp[j+1][i-1]+2;
                          }
                      }
                      if(dp[j][i]>maxLength){
                          maxLength=dp[j][i];
                          longestPalindromeStr=s.substring(j,i+1);
                      }
                  }

              }
                if(maxLength==0){
                    return s.substring(0,1);
                }

              return longestPalindromeStr;
	    }
	

    //   public int longestPalindrome=0;
    //   public String longestPalindromeStr;
	//   public String longestPalindrome(String s) {
    //       if(s==null||s.length()==0){
    //           return null;
    //       }
    //       for(int i=0;i=0&&start2longestPalindrome){
    //           longestPalindrome=start2-start1;
    //           longestPalindromeStr=s.substring(start1+1,start2);
    //       }

    //   }
	
} 
   
  516. 最长回文子序列 
  class Solution { 
      public int longestPalindromeSubseq(String s) { 
          int m=s.length(); 
          int [][]dp=new int[m][m]; 
   
          for(int i=0;i 
  
            dp[i][i]=1; 
              for(int j=i-1;j>=0;j--){ 
                  if(s.charAt(i)==s.charAt(j)){ 
                      dp[j][i]=dp[j+1][i-1]+2; 
                  }else{ 
                      dp[j][i]=Math.max(dp[j][i-1],dp[j+1][i]); 
                  } 
   
              } 
          } 
          return dp[0][m-1]; 
   
      } 
  } 
   
   
  最长公共前缀【双指针】 
   【LeetCode 直通车】：14 最长公共前缀（简单）[9] 
  题解 
   
   class Solution {
    public String longestCommonPrefix(String[] strs) {
        String longestCommonPrefix=strs[0];
        for(int i=1;i
 
  
 
  无重复字符的最长子串【双指针】 
  209. 长度最小的子数组 
  283. 移动零（双指针） 
   
   【LeetCode 直通车】：3 无重复字符的最长子串（中等）[10] 
  题解 
   
   class Solution {
    public int lengthOfLongestSubstring(String s) {
        int left=0,right=0;
        int maxLength=0;
        if(s==null||"".equals(s)){
            return 0;
        }
         if(s.length()==1){
            return 1;
        }
        Set set=new HashSet();
        for( ;right
 
  
 
  【面试真题】 最小覆盖子串【滑动窗口】 
  1052. 爱生气的书店老板 
  1208. 尽可能使字符串相等 
   【LeetCode 直通车】：76 最小覆盖子串（困难）[11] 
  题解 
   
   class Solution {
   public String minWindow(String s, String t) {
       if(s==null||t==null||s.length() mapT=new HashMap();
	   Map mapS=new HashMap();
       for(int i=0;i
 
  
 
  【】高频算法题系列：数组问题 
  主要有几类高频考题： 
   
    俄罗斯套娃信封问题【困难】【排序+最长上升子序列】【面试真题】
  
    最长连续递增序列 【简单】【双指针】
  
    最长连续序列【困难】【哈希表】
  
    盛最多水的容器【困难】【面试真题】
  
    寻找两个正序数组的中位数【困难】【双指针】
  
    删除有序数组中的重复项【简单】【快慢指针】
  
    和为K的子数组【中等】【哈希表】
  
    nSum 问题【系列】【简单】【哈希表】
  
    接雨水【困难】【暴力+备忘录优化】【面试真题】
  
    跳跃游戏【系列】【中等】【贪心算法】
  
    915. 分割数组
  
   
  【面试真题】俄罗斯套娃信封问题【排序+最长上升子序列】 
   【LeetCode 直通车】：354 俄罗斯套娃信封问题（困难）[12] 
  题解 
   
   class Solution {
    public int maxEnvelopes(int[][] envelopes) {
        Arrays.sort(envelopes,new Comparator(){
            public int compare(int []o1,int[]o2){
                if(o1[0]!=o2[0]){
                    return o1[0]-o2[0];
                }else{
                    return o2[1]-o1[1];
                }
            }
        });
        int []dp=new int [envelopes.length];
        int result=0;
        for(int i=0;ienvelopes[j][1]){
                    dp[i]=Math.max(dp[i],dp[j]+1);
                }
            }
            result=Math.max(result,dp[i]);

        }
        return result;

    }
} 
   
  最长连续递增序列【快慢指针】 
   【LeetCode 直通车】：674 最长连续递增序列（简单）[13] 
  题解 
   
   class Solution {
    public int findLengthOfLCIS(int[] nums) {
        if(nums==null||nums.length==0){
            return 0;
        }
        int tempResult=1;
        int result=1;
        for(int i=0;inums[i]){
                tempResult++;
            }else{
                tempResult=1;
            }
            result=Math.max(result,tempResult);
        }
        return result;

    }
} 
   
  最长连续序列 【哈希表】 
   【LeetCode 直通车】：128 最长连续序列（困难）[14] 
  题解 
   
   class Solution {
    public int longestConsecutive(int[] nums) {
        Set set=new HashSet();
       for(int num:nums){
           set.add(num);
       }
        int result=0;
        for(int i=0;i
 
  
 
  【面试真题】盛最多水的容器【哈希表】 
   【LeetCode 直通车】：11 盛最多水的容器（中等）[15] 
  题解 
   
   /**
 * @param {number[]} height
 * @return {number}
 */
var maxArea = function(height) {
    let n = height.length;
    let left = 0, right = n - 1;
    let maxOpacity = 0;
    while (left < right) {
        let res = Math.min(height[left], height[right]) * (right - left);
        maxOpacity = Math.max(maxOpacity, res);
        if (height[left] < height[right]) left++
        else right--;
    }
    return maxOpacity;
};
 
   
  寻找两个正序数组的中位数【双指针】 
   【LeetCode 直通车】：4 寻找两个正序数组的中位数（困难）[16] 
  题解 
   
   class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int m=nums1.length,n=num2.length;
        if(m>n){
            int []temp=nums1;
            nums1=nums2;
            nums2=temp;
        }
        m=nums1.length,n=num2.length;
        int totalLfetCount=n-(n-m+1)/2;
        int nums1LeftCount=0;
        int nums2LeftCount=0;
        int left=0;right=m-1;
        while(left<=right){
            int middle=right-(right-left)/2;
            int nums2Right=totalLfetCount-middle-1;
            if(nums1[nums1LeftCount-1]>nums2[nums2LeftCount]){
                right=nums1left-1;
            }else{
                left=nums1left+1;
            }

        }


    }
} 
   
  删除有序数组中的重复项【快慢指针】 
   【LeetCode 直通车】：26 删除有序数组中的重复项（简单）[17] 
  题解 
   
   class Solution {
    public int removeDuplicates(int[] nums) {
      int slower=0,faster=0;
      while(faster
 
  
 
   【LeetCode 直通车】：695 岛屿的最大面积（中等）[18] 
  题解 
   
   class Solution {
    public int maxAreaOfIsland=0;
    public int tempMaxAreaOfIsland=0;
    public int maxAreaOfIsland(int[][] grid) {
        int m=grid.length;
        int n=grid[0].length;
        boolean [][]used=new boolean[m][n];
        for(int i=0;igrid.length-1||j<0||j>grid[0].length-1){
            return;
        }
        if(used[i][j]||grid[i][j]==0){
            return;
        }
        tempMaxAreaOfIsland++;
        maxAreaOfIsland=Math.max(maxAreaOfIsland,tempMaxAreaOfIsland);
        used[i][j]=true;

        maxAreaOfIslandDFS(grid,i+1,j,used);
        maxAreaOfIslandDFS(grid,i-1,j,used);
        maxAreaOfIslandDFS(grid,i,j-1,used);
        maxAreaOfIslandDFS(grid,i,j+1,used);

    }
} 
   
  和为K的子数组【哈希表】 
  437. 路径总和 III 
   
   
  1248. 统计「优美子数组」 
  974. 和可被 K 整除的子数组 
   【LeetCode 直通车】：560 和为K的子数组（中等）[19] 
  题解 
   
   //所有以nums[i]为结尾的和为k的连续子数组,    j到i的连续子数组和为k，则0到j的和为（0到i的和减去k）
class Solution {
    public int subarraySum(int[] nums, int k) {
        if(nums==null||nums.length==0){
            return 0;
        }
        Map mapResult=new HashMap();
        int temp=0;
        int result=0;
        mapResult.put(0,1);
        for(int i=0;i
 
  
 
  nSum问题【哈希表】【系列】 
   
     【LeetCode 直通车】：1 两数之和（简单）[20]
  
    
     
         public int[] twoSum(int[] nums, int target) {
		Map map=new HashMap();
        for(int i=0;i
 
    
 
 
     【LeetCode 直通车】：167 两数之和 II - 输入有序数组（简单）[21]
  
    
     
         public int[] twoSum(int[] numbers, int target) {
        int left=0,right=numbers.length-1;
        while(lefttarget){
                right--;
            }else{
                left++;
            }
        }
        return new int[]{-1,-1};

    } 
    
  
     【LeetCode 直通车】：15 三数之和（中等）[22]
  
    
     【LeetCode 直通车】：18 四数之和（中等）[23]
  
  
 
   
   class Solution {
    public List> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        return nSumDFS(nums,4,0,target);

    }
    public List> nSumDFS(int []nums,int n,int start,int target){
        List>  result=new ArrayList>();
        if(n==2){
            int end=nums.length-1;
            while(starttarget){
                    end--;
                     while(nums[end]==nums[end+1]&&start twoSum=new ArrayList();
                     twoSum.add(nums[start]);
                     twoSum.add(nums[end]);
                     result.add(twoSum);
                     start++;
                     end--;
                    while(start>0&&nums[start]==nums[start-1]&&startstart&&nums[i]==nums[i-1]){
                    continue;
                }
                List> tempResult=nSumDFS(nums,n-1,i+1,target-curNum);
                if(tempResult!=null&&tempResult.size()>0){
                    for(List tempList:tempResult){
                        tempList.add(curNum);
                        result.add(tempList);
                    }
                }
             }

        }
       return result;


    }
} 
   
   
  接雨水【暴力+备忘录优化】 
   【LeetCode 直通车】：42 接雨水（困难）[24] 
  题解 
   
   //     1.首先我们需要搞清楚，下标为i的雨水量是由什么决定的.
// 是由i左右两边最大值中较小的那个减去height[i]决定的.例 [0,1,0,2,1,0,1,3,2,1,2,1]中，下标为2的位置 值为0，而它的用水量是由左边的最大值1，右边最大值3 中较小的那个 也就是1减去0得到的。

// 2.本题解的双指针先找到当前维护的左、右最大值中较小的那个，例 当前 i 处左边的最大值如果比右边的小，那么就可以不用考虑 i 处右边最大值的影响了，因为 i 处 右边真正的最大值绝对比左边的最大值要大，在不断遍历时，更新max_l和max_r以及返回值即可。例 [0,1,0,2,1,0,1,3,2,1,2,1]中i=2时，值为0，此时max_l一定为1，当前max_r如果为2，即便max_r不是真正的i右边的最大值，也可忽略右边最大值的影响，因为右边真正的最大值一定比左边真正的最大值大。


   public int trap(int[] height) {
		 if(height==null||height.length==0){
			 return 0;
		 }
		 int result=0,left=0,right=height.length-1,leftMax=0,rightMax=0;
		 while(left stack=new Stack();
        int result=0;
        for(int i=0;iheight[stack.peek()]){
                    int heightLow=height[stack.pop()];
                    if(stack.isEmpty()){
                        break;
                    }
                    int deep=Math.min(height[stack.peek()],height[i])-heightLow;
                    result+=(deep*(i-stack.peek()-1)); //此处必须是stack中最后一个值，不能上上一个弹出的，例如  0的时候，7和2之间的宽度,2的时候7和4之间的宽度  [4,2,0,7]

                }
                stack.push(i);
            }
        }
        return result;
      

    } 
   
  跳跃游戏【贪心算法】【系列】 
   
     【LeetCode 直通车】：55 跳跃游戏（中等）[25]
  
    
     
     class Solution {
    // 这样以来，我们依次遍历数组中的每一个位置，并实时维护 最远可以到达的位置。对于当前遍历到的位置 xx，如果它在 最远可以到达的位置 的范围内，那么我们就可以从起点通过若干次跳跃到达该位置，因此我们可以用 x + \textit{nums}[x]x+nums[x] 更新 最远可以到达的位置。
    public boolean canJump(int[] nums) { 
		if(nums==null||nums.length==0){
            return true;
        }
        int rightMost=nums[0];
        for(int i=1;i=nums.length-1;
	}
	 


    //暴力破解法
   	// public boolean canJump;
	//  public boolean canJump(int[] nums) {
	// 	 if(nums==null||nums.length==0){
	// 		 return false;
	// 	 }
	// 	 canJumpDFS(nums,0);
	// 	 return canJump;
	//     }
	 
	 
	//  public void canJumpDFS(int[] nums,int start){
	// 	 if(canJump==true){
	// 		 return;
	// 	 }
	// 	 if(start>=nums.length-1){
	// 		 canJump=true;
	// 		 return;
	// 	 }
	// 	 for(int i=start+1;i<=start+nums[start];i++){
	// 		 canJumpDFS(nums, i);
	// 	 }
		 
	//  }
	
} 
    
  
     【LeetCode 直通车】：45 跳跃游戏 II（中等）[26]
  
   
  受限于篇幅，这里只给出第一道题的代码模板，也是一面常考真题。 
  题解 
   
   class Solution {
    public int jump(int[] nums) {
       if(nums==null||nums.length<=1){
           return 0;
       }
       int end=nums[0],farthest=nums[0],step=1;
       for(int i=0;i
 
  
 
  高频算法题系列：二叉树 
  主要有以下几类高频考题： 
   
    二叉树的最近公共祖先【简单】【二叉树】
  
    二叉搜索树中的搜索【简单】【二叉树】
  
    删除二叉搜索树中的节点【中等】【二叉树】
  
    完全二叉树的节点个数【中等】【二叉树】
  
    二叉树的锯齿形层序遍历【中等】【二叉树】
  
   
  二叉树的最近公共祖先【二叉树】 
   【LeetCode 直通车】：236 二叉树的最近公共祖先（简单）[27] 
  题解 
   
   /**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
TreeNode result;
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    lowestCommonAncestorDFS(root,p,q);
    return result;

}
public boolean lowestCommonAncestorDFS(TreeNode root ,TreeNode p,TreeNode q){
    if(root==null){
        return false;
    }
    boolean inCurren=false;
    if(root.val==p.val||root.val==q.val){
        inCurren=true;
    }
    boolean inLeft=lowestCommonAncestorDFS(root.left,p,q);
    boolean inRight=lowestCommonAncestorDFS(root.right,p,q);
    if(inCurren&&(inLeft||inRight)){
        result=root;
    }
     if(inLeft&&inRight){
        result=root;
    }
    return inLeft||inRight||inCurren;
}

    // public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    //     if(root==null){
    //         return null;
    //     }
    //     TreeNode left=lowestCommonAncestor(root.left,p,q);
    //     TreeNode right=lowestCommonAncestor(root.right,p,q);
    //      if((root.val==p.val||root.val==q.val)&&(left!=null||right!=null)){
    //         return root;
    //     }
    //     if(left!=null&&right!=null){
    //         return root;
    //     }
    //     if(left!=null){
    //         return  left;
    //     }
    //     if(right!=null){
    //         return  right;
    //     }

    //      if(root.val==p.val||root.val==q.val){
    //         return root;
    //     }
    //     return null;
       
        
    // }
} 
   
  二叉搜索树中的搜索【二叉树】 
   【LeetCode 直通车】：700 二叉搜索树中的搜索（简单）[28] 
  题解 
   
   class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
      if(root==null){
          return null;
      }
      if(root.val==val){
          return root;
      }
      if(val>root.val){
          return searchBST(root.right,val);
      }else{
           return searchBST(root.left,val);
      }
        
    }
} 
   
  删除二叉搜索树中的节点【二叉树】 
   【LeetCode 直通车】：450 删除二叉搜索树中的节点（中等）[29] 
  题解 
   
   class Solution {
    public TreeNode deleteNode(TreeNode root, int key) {
        if(root==null){
            return null;
        }
        if(key>root.val){
            root.right=deleteNode(root.right,key);
        }else if(key
 
  
 
  完全二叉树的节点个数【二叉树】 
   【LeetCode 直通车】：222 完全二叉树的节点个数（中等）[30] 
  题解 
   
   class Solution {
    public int countNodes(TreeNode root) {
        if(root==null){
            return 0;
        }
        int leftHeight=0;
        TreeNode leftTree=root;
        while(leftTree.left!=null){
            leftTree=leftTree.left;
            leftHeight++;
        }
         int rightHeight=0;
        TreeNode rightTree=root;
        while(rightTree.right!=null){
            rightTree=rightTree.right;
            rightHeight++;
        }
        if(leftHeight==rightHeight){
            return (int)Math.pow(2,leftHeight+1)-1;
        }else{
            return 1+ countNodes(root.left)+countNodes(root.right);
        }
    }
} 
   
  二叉树的锯齿形层序遍历【二叉树】 
   【LeetCode 直通车】：103 二叉树的锯齿形层序遍历（中等）[31] 
  题解 
   
   class Solution {
    public List> zigzagLevelOrder(TreeNode root) {
        Queue  queue=new LinkedList();
        List> result=new ArrayList>();
        int index=1;
        if(root!=null){
            queue.offer(root);
        }
        while(!queue.isEmpty()){
            int size=queue.size();
            Deque deque=new LinkedList();
            for(int i=0;i
 
  
 
  【】高频算法题系列：排序算法 
  主要有以下几类高频考题： 
   
    用最少数量的箭引爆气球【中等】【排序】
  
    合并区间【中等】【排序算法+区间问题】【面试真题】
  
   
  用最少数量的箭引爆气球【排序算法】 
   【LeetCode 直通车】：452 用最少数量的箭引爆气球（中等）[32] 
  题解 
  对比435. 无重叠区间 
  如果按左端升序排序，可能出现这种：[0, 9], [0, 6], [7, 8] 
      当前第一个区间和第二个重合，我让当前第一个区间继续寻求重合，它和第三个也重合。
     你想着一箭三雕，但第二个和第三个其实并不重合。
     被「包含」在当前区间的重合区间，不一定和别的重合区间重合
     当前区间可能和很多区间重合，但无法保证这些区间内部都互相重合。 
   
  //尾部排序，每个开始和之前的结尾做对比，结尾是有序的，若采用头部排序，后面的头部和结尾比较，结尾无续，可能存在前面的尾部更长，后面两个尾部更短的情况  
   
   class Solution {
    public int findMinArrowShots(int[][] points) {
        if(points==null){
            return 0;
        }
        Arrays.sort(points,new Comparator(){
            public int compare(int []o1,int []o2){
               return  Integer.compare(o1[1], o2[1]);
            }
        });
        int startIndex=points[0][1];
        int result=1;
        for(int i=1;istartIndex){
                result++;
                startIndex=points[i][1];
            }
        }
        return result;
    }
} 
   
  合并区间【排序算法+区间问题】 
   【LeetCode 直通车】：56 合并区间（中等）[33] 
  题解 
   
   class Solution {
     public int[][] merge(int[][] intervals) {
         if(intervals==null){
             return new int[][]{};
         }
         Arrays.sort(intervals,new Comparator(){
             public int compare(int[]a,int[]b){
                 return Integer.compare(a[0],b[0]);
             }
         });
         List result=new ArrayList();
         result.add(intervals[0]);
         int maxRight=intervals[0][1];
        for(int i=1;i result.get(result.size()-1)[1]){
                 result.add(intervals[i]);
            }else{
                result.get(result.size()-1)[1]=Math.max(intervals[i][1], result.get(result.size()-1)[1]);
            }

        }
        return result.toArray(new int [result.size()][]);

     }
} 
   
  高频算法题系列：二分查找 
  主要有以下几类高频考题： 
   
    寻找两个正序数组的中位数【困难】【二分查找】
  
    判断子序列【简单】【二分查找】
  
    在排序数组中查找元素的第一个和最后一个位置【中等】【二分查找】
  
   
  寻找两个正序数组的中位数【二分查找】 
   【LeetCode 直通车】：4 寻找两个正序数组的中位数（困难）[34] 
  题解 
   
   /**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number}
 */
var findMedianSortedArrays = function(nums1, nums2) {
    let m = nums1.length, n = nums2.length;
    let i = 0, j = 0;
    let newArr = [];
    while (i < m && j < n) {
        if (nums1[i] < nums2[j]) {
            newArr.push(nums1[i++]);
        } else {
            newArr.push(nums2[j++]);
        }
    }
    newArr = newArr.concat(i < m ? nums1.slice(i) : nums2.slice(j));
    const len = newArr.length;
    console.log(newArr)
    if (len % 2 === 0) {
        return (newArr[len / 2] + newArr[len / 2 - 1]) / 2;
    } else {
        return newArr[Math.floor(len / 2)];
    }
};
 
   
  判断子序列【二分查找】 
   【LeetCode 直通车】：392 判断子序列（简单）[35] 
  题解 
   
   class Solution {
    public boolean isSubsequence(String s, String t) {
        if(s==null||t==null){
            return true;
        }
        int m=s.length(),n=t.length(),i=0,j=0;
        if(m>n){
            return false;
        }
        while(i
 
  
 
   在排序数组中查找元素的第一个和最后一个位置【二分搜索】 
   
  对比二分查找：875. 爱吃香蕉的珂珂 
  1011. 在 D 天内送达包裹的能力 
  69. Sqrt(x) 
   
   【LeetCode 直通车】：34 在排序数组中查找元素的第一个和最后一个位置（中等）[36] 
  题解 
   
   class Solution {
    public int[] searchRange(int[] nums, int target) {
        if(nums==null||nums.length==0){
            return new int[]{-1,-1};
        }
        int left=binarySearch(nums,target,true);
         int right=binarySearch(nums,target,false);
         return new int[]{left,right};
        
    }
   public int binarySearch(int []nums,int target,boolean isFirst){
       int left=0,right=nums.length-1;
       while(left<=right){
           int middle=right-(right-left)/2;
           if(isFirst){
               if(target<=nums[middle]){
                   right=middle-1;
               }else{
                   left=middle+1;
               }
           }else{
               if(target>=nums[middle]){
                   left=middle+1;
               }else{
                   right=middle-1;
               }

           }
        
       }
        if(isFirst&&left=0&&nums[right]==target){
            return right;
            
        }
        return -1;
   }
} 
   
  【】高频算法题系列：动态规划 
  主要有以下几类高频考题： 
   
    最长递增子序列【中等】【动态规划】
  
    零钱兑换【中等】【动态规划】【面试真题】
  
    最长公共子序列 【中等】【动态规划】【面试真题】
  
    编辑距离 【困难】【动态规划】
  
    最长回文子序列【中等】【动态规划】【面试真题】
  
    最大子序和【简单】【动态规划】【面试真题】
  
    买卖股票的最佳时机系列【系列】【动态规划】【面试真题】
  
    801. 使序列递增的最小交换次数
  
    940. 不同的子序列 II
  
   
  最长递增子序列【动态规划】 
   【LeetCode 直通车】：300 最长递增子序列（中等）[37] 
  题解 
   
   class Solution {
// 考虑往]dp[0…i−1] 中最长的上升子序列后面再加一个 nums[i]。由于dp[j] 代表 nums[0…j] 中以 nums[j] 结尾的最长上升子序列，所以如果
   public int lengthOfLIS(int[] nums) {
		if(nums==null||nums.length==0){
            return 0;
        }
        int []dp=new int [nums.length];
        dp[0]=1;
        int result=0;
        for(int i=0;inums[j]){
                    dp[i]=Math.max(dp[i],dp[j]+1);
                }
            }
            result=Math.max(result,dp[i]);
        }
        return result;

    }
	
} 
   
  【面试真题】 零钱兑换【动态规划】 
   【LeetCode 直通车】：322 零钱兑换（中等）[38] 
  题解 
   
   class Solution {
    public int coinChange(int[] coins, int amount) {
         int dp[] =new int [amount+1];
         for(int i=1;i<=amount;i++){
             dp[i]=Integer.MAX_VALUE-1;
         }
         dp[0]=0;
        for(int coin:coins){
            for(int j=coin;j<=amount;j++){
                dp[j]=Math.min(dp[j],dp[j-coin]+1);

            }
        }
        return dp[amount]<(Integer.MAX_VALUE-1)?dp[amount]:-1;
    }
} 
   
  【面试真题】 最长公共子序列【动态规划】 
   【LeetCode 直通车】：1143 最长公共子序列（中等）[39] 
  题解 
   
   class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        if(text1==null||text2==null){
            return 0;
        }
        int dp[][]=new int[text1.length()+1][text2.length()+1];
        for(int i=1;i<=text1.length();i++){
            for(int j=1;j<=text2.length();j++){
                if(text1.charAt(i-1)==text2.charAt(j-1)){
                    dp[i][j]=dp[i-1][j-1]+1;
                }else{
                     dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);
                }


            }
        }
        return dp[text1.length()][text2.length()];

    }
} 
   
  编辑距离【动态规划】 
  221. 最大正方形 
   【LeetCode 直通车】：72 编辑距离（困难）[40] 
  题解 
   
   class Solution {
    public int minDistance(String word1, String word2) {
        int dp[][]=new int[word1.length()+1][word2.length()+1];
        for(int i=0;i<=word1.length();i++){
            dp[i][0]=i;
        }
        for(int i=0;i<=word2.length();i++){
            dp[0][i]=i;
        }
         for(int i=1;i<=word1.length();i++){
            for(int j=1;j<=word2.length();j++){
                if(word1.charAt(i-1)==word2.charAt(j-1)){
                    dp[i][j]=dp[i-1][j-1];
                }else{
                    dp[i][j]=Math.min(
                        Math.min(dp[i][j-1],dp[i-1][j]),dp[i-1][j-1]
                    )+1;
                }
            }
        }
        return dp[word1.length()][word2.length()];

    }
} 
   
  【面试真题】最长回文子序列【动态规划】 
   【LeetCode 直通车】：516 最长回文子序列（中等）[41] 
  题解 
   
   class Solution {
    public int longestPalindromeSubseq(String s) {
        if(s==null||s.length()==0){
            return 0;
        }
        int [][]dp=new int[s.length()+1][s.length()+1];
        for(int i=0;i=0;j--){
                if(s.charAt(j)==s.charAt(i)){
                    dp[j][i]=dp[j+1][i-1]+2;
                }else{
                    dp[j][i]=Math.max(dp[j+1][i],dp[j][i-1]);
                }
            }
        }
        return dp[0][s.length()-1];
        
    }
} 
   
  【LeetCode 直通车】：5最长回文子串（中等）[41] 
  题解 
   
   class Solution {
   	   
	    public String longestPalindrome(String s) {
            int maxLength=0;
	        String longestPalindromeStr="";
			  if(s==null||s.length()==0){
                  return null;
              }
               if(s.length()==1){
                  return s;
              }
              int dp[][]=new int[s.length()][s.length()];
              for(int i=0;i0&&s.charAt(i)==s.charAt(j)){
                               dp[j][i]=dp[j+1][i-1]+2;
                          }
                      }
                      if(dp[j][i]>maxLength){
                          maxLength=dp[j][i];
                          longestPalindromeStr=s.substring(j,i+1);
                      }
                  }

              }
                if(maxLength==0){
                    return s.substring(0,1);
                }

              return longestPalindromeStr;
	    }
	

    //   public int longestPalindrome=0;
    //   public String longestPalindromeStr;
	//   public String longestPalindrome(String s) {
    //       if(s==null||s.length()==0){
    //           return null;
    //       }
    //       for(int i=0;i=0&&start2longestPalindrome){
    //           longestPalindrome=start2-start1;
    //           longestPalindromeStr=s.substring(start1+1,start2);
    //       }

    //   }
	
} 
   
   
   
   
  【面试真题】 最大子序和【动态规划】 
  对比152. 乘积最大子数组 
   【LeetCode 直通车】：53 最大子序和（简单）[42] 
  题解 
   
   class Solution {
     public int maxSubArray(int[] nums) {
         int dp[] =new int[nums.length];  //状态不能定义为前i个连续子数组，状态转移时 i和i-1未必连续，定位为以i为结尾的连续子数组
         if(nums==null||nums.length==0){
             return 0;
         }
         int maxSubArray=nums[0];
         dp[0]=nums[0];
         for(int i=1;i0){  //和大于0，就对后边新的数组有增益，可继续加
    //             result=Math.max(result,tempSum);
    //         }else{
    //             result=Math.max(result,tempSum);
    //             tempSum=0;
    //         }
    //     }
    //     return result;

    // }
} 
   
  【面试真题】 买卖股票的最佳时机【动态规划】 
   
     【LeetCode 直通车】：121 买卖股票的最佳时机（简单）[43]【面试真题】
  
    
     
     class Solution {
    public int maxProfit(int[] prices) {
        int minValue=Integer.MAX_VALUE,result=0;
        if(prices==null||prices.length==1){
            return 0;
        }
        for(int price :prices){
            minValue=Math.min(minValue,price);
            result=Math.max(result,price-minValue);
        }
        return result;

    }
} 
    
  
     【LeetCode 直通车】：122 买卖股票的最佳时机 II（简单）[44]
  
    
     
     class Solution {

    // //贪心算法，画个走势上升下降图，每个上升阶段最高点和最低点差值，相当于中间各个点差值相加
    // public int maxProfit(int[] prices) {
    //     if(prices==null||prices.length<2){
    //         return 0;
    //     }
    //     int result=0;
    //     for(int i=1;iprices[i-1]){
    //             result+=(prices[i]-prices[i-1]);
    //         }
    //     }
    //     return result;

    // }

 public int maxProfit(int[] prices) {
      if(prices==null||prices.length<2){
            return 0;
        }
		int [][]dp=new int[prices.length][2];  //当前持有股票和未持有股票两种情况
		dp[0][0]=0;
		dp[0][1]=-prices[0];
		for(int i=1;i
 
    
 
 
     【LeetCode 直通车】：123 买卖股票的最佳时机 III（困难）[45]
  
     【LeetCode 直通车】：188 买卖股票的最佳时机IV（困难）[46]
  
     【LeetCode 直通车】：309 买卖股票的最佳时机含冷冻期（中等）[47]
  
    
     
     class Solution {
    public int maxProfit(int[] prices) {
                if(prices==null||prices.length<1){
                    return 0;
                }
		        int n=prices.length;
		        int dp [][]=new int [n][3];
		        //   [i][0]表示今天过后处于冻结未持有,[i][1]表持今天过后持有 ,[i][2] 表示处于非冻结可以买入期
		        dp [0][1]=-prices[0];
		      for(int i=1;i
 
    
 
 
     【LeetCode 直通车】：714 买卖股票的最佳时机含手续费（中等）[48]
  
  
 
  受限于篇幅，这里只给出第一道题的代码模板，也是一面常考真题，笔者在面试字节跳动时就遇到过。 
  题解 
   
   /**
 * @param {number[]} prices
 * @return {number}
 */
var maxProfit = function(prices) {
  let dp = [];
  for (let i = -1; i < prices.length; i++) {
    dp[i] = []
    for (let j = 0; j <= 1; j++) {
      dp[i][j] = [];
      dp[i][j][0] = 0;
      dp[i][j][1] = 0;
      if (i === -1) {
        dp[i][j][1] = -Infinity;
      }
      if (j === 0) {
        dp[i][j][1] = -Infinity;
      }
      if (j === -1) {
        dp[i][j][1] = -Infinity;
      }
    }
  }
  for (let i = 0; i < prices.length; i++) {
    for (let j = 1; j <= 1; j++) {
      dp[i][j][0] = Math.max(dp[i - 1][j][0], dp[i - 1][j][1] + prices[i]);
      dp[i][j][1] = Math.max(dp[i - 1][j][1], dp[i - 1][j - 1][0] - prices[i]);
    }
  }
  return dp[prices.length - 1][1][0];
};
 
   
  801. 使序列递增的最小交换次数 
  class Solution {
    public int minSwap(int[] nums1, int[] nums2) {
        int n = nums1.length;
        int a = 0, b = 1;
        for (int i = 1; i < n; i++) {
            int at = a, bt = b;
            a = b = n;
            if (nums1[i] > nums1[i - 1] && nums2[i] > nums2[i - 1])  {
                a = Math.min(a, at);
                b = Math.min(b, bt + 1);
            }
            if (nums1[i] > nums2[i - 1] && nums2[i] > nums1[i - 1]) {
                a = Math.min(a, bt);
                b = Math.min(b, at + 1);
            }
        }
        return Math.min(a, b);
    }
}

 
  高频算法题系列：BFS 
  主要有以下几类高频考题： 
   
    打开转盘锁【中等】【BFS】
  
    二叉树的最小深度【简单】【BFS】
  
   
  打开转盘锁【BFS】 
   【LeetCode 直通车】：752 打开转盘锁（中等）[49] 
  题解 
   
   class Solution {
   	 public int openLock(String[] deadends, String target) {
		 	Set lockSet=new HashSet();
		 	Set visited=new HashSet();
		 	for(String curLock:deadends){
		 		lockSet.add(curLock);
		 	}
		 	Deque queue=new LinkedList();
		 	queue.offer("0000");
		 	// visited.add("0000");
		 	int minLength=0;
		 	while(!queue.isEmpty()){
		 		int length=queue.size();
		 		for(int j=0;j
 
  
 
  二叉树的最小深度【BFS】 
   【LeetCode 直通车】：111 二叉树的最小深度（简单）[50] 
  题解 
   
   class Solution {
    public int minDepth(TreeNode root) {
        if(root==null){
            return 0;
        }
        Deque queue=new LinkedList();
        queue.offer(root);
        int minDeep=1;
        while(!queue.isEmpty()){
            int length=queue.size();
            for(int i=0;i
 
  
 
  【】高频算法题系列：栈 
  主要有以下几类高频考题： 
   
    最小栈【简单】【栈】
  
    有效的括号【中等】【栈】【面试真题】
  
    简化路径【中等】【栈】
  
    下一个更大元素 【系列】【栈】
  
   
  227. 基本计算器 II(点击看题) 
  1006. 笨阶乘 
  769. 最多能完成排序的块 
   
  最小栈【栈】 
   【LeetCode 直通车】：155 最小栈（简单）[51] 
  题解 
   
   class MinStack {
    Stack  stack;
    Stack  minStack;

    /** initialize your data structure here. */
    public MinStack() {
        stack=new Stack();
        minStack=new Stack();

    }
    
    public void push(int val) {
        stack.push(val);
        minStack.push(minStack.isEmpty()?val:Math.min(minStack.peek(),val));

    }
    
    public void pop() {
        stack.pop();
        minStack.pop();

    }
    
    public int top() {
        return stack.peek();

    }
    
    public int getMin() {
        return minStack.peek();

    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(val);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */ 
   
  【系列】下一个更大元素 【栈】 
   
     【LeetCode 直通车】：496 下一个更大元素 I（简单）[52]
  
     【LeetCode 直通车】：503 下一个更大元素 II（中等）[53]
  
   
  受限于篇幅，这里只给出第一道题的代码模板 
  题解 
   
   class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
      Map map=new HashMap();
      Stack stack=new Stack();
      int []result=new int[nums1.length];
      for(int i=nums2.length-1;i>=0;i--){
          while(!stack.isEmpty()&&nums2[i]>stack.peek()){
              stack.pop();
          }
          int iResult=stack.isEmpty()?-1:stack.peek();
          stack.push(nums2[i]);
          map.put(nums2[i],iResult);
      }
      for(int i=0;i stack=new Stack();
        int n=nums.length;
        int [] result=new int[n];
        for(int i=2*n-1;i>=0;i--){
            int index=i%n;
            while(!stack.isEmpty()&&stack.peek()<=nums[index]){
                stack.pop();
            }
            int curValue=stack.isEmpty()?-1:stack.peek();
            stack.push(nums[index]);
            result[index]=curValue;
        }
        return result;

    }
} 
   
  【面试真题】有效的括号【栈】 
   【LeetCode 直通车】：20 有效的括号（中等）[54] 
  题解 
   
   class Solution {
     public static  boolean isValid(String s) {
		 if(s==null||s.length()==0){
			 return true;
		 }
		 while(s.contains("()")||s.contains("{}")||s.contains("[]")){
			s=s.replace("()", "");
			s=s.replace("{}", "");
			s=s.replace("[]", "");
		 }
		 return s.length()>0?false:true;
	    }



    // public static  boolean isValid(String s) {
	// 	 if(s==null||s.length()==0){
	// 		 return true;
	// 	 }
	// 	 Stack stack=new Stack();
	// 	 for(int i=0;i0?false:true;
	// }
} 
   
  简化路径【栈】 
   【LeetCode 直通车】：71 简化路径（中等）[55] 
  题解 
   
   class Solution {
    public String simplifyPath(String path) {
        if(path==null||"".equals(path)){
            return "/";
        }
        String [] pathArray=path.split("/");
        Stack stack=new Stack();
        for(int i=0;i
 
  
 
  【】高频算法题系列：DFS 
  主要有以下几类高频考题： 
   
    岛屿的最大面积【中等】【DFS】
  
    相同的树【简单】【DFS】
  
   
  岛屿的最大面积【DFS】 
   【LeetCode 直通车】：695 岛屿的最大面积（中等）[56] 
  题解 
   
   class Solution {
    public int maxAreaOfIsland=0;
    public int tempMaxAreaOfIsland=0;
    public int maxAreaOfIsland(int[][] grid) {
        int m=grid.length;
        int n=grid[0].length;
        boolean [][]used=new boolean[m][n];
        for(int i=0;igrid.length-1||j<0||j>grid[0].length-1){
            return;
        }
        if(used[i][j]||grid[i][j]==0){
            return;
        }
        tempMaxAreaOfIsland++;
        maxAreaOfIsland=Math.max(maxAreaOfIsland,tempMaxAreaOfIsland);
        used[i][j]=true;

        maxAreaOfIslandDFS(grid,i+1,j,used);
        maxAreaOfIslandDFS(grid,i-1,j,used);
        maxAreaOfIslandDFS(grid,i,j-1,used);
        maxAreaOfIslandDFS(grid,i,j+1,used);

    }
} 
   
  相同的树【DFS】 
   【LeetCode 直通车】：100 相同的树（简单）[57] 
  题解 
   
   class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if((p!=null&&q!=null)&&(p.val==q.val)){
            return isSameTree(p.left,q.left)&&isSameTree(p.right,q.right);
        }else if(p==null&&q==null){
            return true;
        }else{
            return false;
        }

    }
} 
   
  【】高频算法题系列：回溯算法 
  主要有以下几类高频考题： 
   
    N皇后【困难】【回溯算法】【面试真题】
  
    全排列【中等】【回溯算法】
  
    括号生成【中等】【回溯算法】
  
    复原 IP 地址【中等】【回溯算法】
  
    子集 【简单】【回溯算法】
  
   
  【面试真题】N皇后【回溯算法】 
   【LeetCode 直通车】：51 N皇后（困难）[58] 
  题解 
   
   class Solution {
    List> result=new ArrayList>();
    public List> solveNQueens(int n) {
        char [][] queenChar=new char[n][n];
        for(int i=0;iqueenChar.length){
            return;  //理论上不可能>n，有所有rowIndex都不满足的，就没有深度遍历了
        }
        if(colIndex==queenChar.length){
            result.add(arrayToList(queenChar));
        }
        //在本行的所有列都暴力遍历一遍
        for(int i=0;i=0;i--){
            if(queenChar[i][rowIndex]=='Q'){
                return false;
            }
        }
         //左上角
        for(int i=colIndex-1,j=rowIndex-1;i>=0&&j>=0;i--,j--){
            if(queenChar[i][j]=='Q'){
                return false;
            }
        }

         //右上角
        for(int i=colIndex-1,j=rowIndex+1;i>=0&&j arrayToList(char [][]queenChar){
        List result=new ArrayList();
        for(char [] tempChar:queenChar){
            String s=new String(tempChar);
            result.add(s);
        }
        return result;
    }
} 
   
  全排列【回溯算法】 
   【LeetCode 直通车】：46 全排列（中等）[59] 
  题解 
   
   class Solution {
    List> result=new ArrayList>();
    public List> permute(int[] nums) {
        if(nums==null||nums.length==0){
            return new ArrayList();
        }
        permuteDFS(nums,new ArrayList(),new boolean [nums.length]);
        return result;
    }
    public void permuteDFS(int []nums,List tempList,boolean[]used){
        if(tempList.size()==nums.length){
            result.add(new ArrayList(tempList));
            return;
        }
        for(int i=0;i
 
  
 
  括号生成【回溯算法】 
   【LeetCode 直通车】：22 括号生成（中等）[60] 
  题解 
   
   
class Solution {
        List list = new ArrayList<>();
    public List generateParenthesis(int n) {
        if(n==0){
            return new ArrayList();
        }
        generateParenthesisDFS(n,0,0,"");
        return list;
      
    }
   public void generateParenthesisDFS(int n,int l,int right,String tempStr){
        if(l==right&&l==n){
            list.add(tempStr);
        }
        if(l
 
  
 
  复原 IP 地址【回溯算法】 
   【LeetCode 直通车】：93 复原 IP 地址（中等）[61] 
  题解 
   
   class Solution {
    List result=new ArrayList();
    public List restoreIpAddresses(String s) {
        if(s==null||s.length()==0){
            return result;
        }
        restoreIpAddressesDFS(0,s,4,"");
        return result;
    }
    public void restoreIpAddressesDFS(int startIndex,String s,int n,String tempS){
        if(startIndex==s.length()&&n==0){
            result.add(tempS);
        }
        if(startIndex==s.length()){
            return;
        }
        if(n==0){
            return;
        }
        char curChar=s.charAt(startIndex);
        if(curChar=='0'){
            if(!"".equals(tempS)){
                tempS+=".";
            }
            tempS+=curChar;
            restoreIpAddressesDFS(startIndex+1,s,n-1,tempS);
        }else{
            if(!"".equals(tempS)){
                tempS+=".";
            }
            for(int i=1;i<4;i++){
                if(startIndex+i>s.length()){
                    return;
                }
                String curStr=s.substring(startIndex,startIndex+i);
                if(Integer.valueOf(curStr)>255){
                    return;
                }
                restoreIpAddressesDFS(startIndex+i,s,n-1,tempS+curStr);
            }

        }

    }

} 
   
  子集【回溯算法】 
   【LeetCode 直通车】：78 子集（中等）[62] 
  题解 
   
   class Solution {
    List> result=new ArrayList>();
    public List> subsets(int[] nums) {
        if(nums==null||nums.length==0){
            return new ArrayList>();
        }
        subsetsDFS(nums,0,new ArrayList());
        return result;
    }
    public void subsetsDFS(int []nums,int start,List tempList){
        result.add(new ArrayList(tempList));
        for(int i=start;i
 
  
 
  文末福利 
  推荐一个非常有帮助的刷算法题的网址，labuladong 的算法小抄[63]，通过套路，认准高频题目，直通大厂；这本小炒目前已经出版成书，对应的 Github 仓库[64]也有 86.2K Star，而且作者还在频繁更新，非常值得学习！ 
  ❤️谢谢 
  往期精文 
   
    字节跳动最爱考的前端面试题:JavaScript 基础[65]  2696 
  
    字节跳动最爱考的前端面试题:CSS 基础[66] 687 
  
    字节跳动最爱考的前端面试题:计算机网络基础[67] 761 
  
   
  欢迎关注公众号：图雀社区。 如果你想从零开始以实战的方式学习一门技术，亦或是想动手做一个比较完整的项目以准备面试，相信 「图雀社区」 的内容都能够帮助到你，成为初入前端的你成长路上的指南针。 
  原创不易 
  喜欢的话原创不易，给点鼓励吧 ❤️ 别忘了 分享、点赞、在看 三连哦~。 
  参考资料 
  [1] 
  【LeetCode 直通车】：234 回文链表（简单）: https://leetcode-cn.com/problems/palindrome-linked-list/ 
  [2] 
  【LeetCode 直通车】：206 反转链表（简单）: https://leetcode-cn.com/problems/reverse-linked-list/ 
  [3] 
  【LeetCode 直通车】：23 合并K个升序链表（困难）: https://leetcode-cn.com/problems/merge-k-sorted-lists/ 
  [4] 
  【LeetCode 直通车】：25 K 个一组翻转链表（困难）: https://leetcode-cn.com/problems/reverse-nodes-in-k-group/ 
  [5] 
  【LeetCode 直通车】：141 环形链表（简单）: https://leetcode-cn.com/problems/linked-list-cycle/ 
  [6] 
  【LeetCode 直通车】：148 排序链表（中等）: https://leetcode-cn.com/problems/sort-list/ 
  [7] 
  【LeetCode 直通车】：160 相交链表（简单）: https://leetcode-cn.com/problems/intersection-of-two-linked-lists/ 
  [8] 
  【LeetCode 直通车】：5 最长回文子串（中等）: https://leetcode-cn.com/problems/longest-palindromic-substring/ 
  [9] 
  【LeetCode 直通车】：14 最长公共前缀（简单）: https://leetcode-cn.com/problems/longest-common-prefix/ 
  [10] 
  【LeetCode 直通车】：3 无重复字符的最长子串（中等）: https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/ 
  [11] 
  【LeetCode 直通车】：76 最小覆盖子串（困难）: https://leetcode-cn.com/problems/minimum-window-substring/ 
  [12] 
  【LeetCode 直通车】：354 俄罗斯套娃信封问题（困难）: https://leetcode-cn.com/problems/russian-doll-envelopes/ 
  [13] 
  【LeetCode 直通车】：674 最长连续递增序列（简单）: https://leetcode-cn.com/problems/longest-continuous-increasing-subsequence/ 
  [14] 
  【LeetCode 直通车】：128 最长连续序列（困难）: https://leetcode-cn.com/problems/longest-consecutive-sequence/ 
  [15] 
  【LeetCode 直通车】：11 盛最多水的容器（中等）: https://leetcode-cn.com/problems/container-with-most-water/ 
  [16] 
  【LeetCode 直通车】：4 寻找两个正序数组的中位数（困难）: https://leetcode-cn.com/problems/median-of-two-sorted-arrays/ 
  [17] 
  【LeetCode 直通车】：26 删除有序数组中的重复项（简单）: https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/ 
  [18] 
  【LeetCode 直通车】：695 岛屿的最大面积（中等）: https://leetcode-cn.com/problems/max-area-of-island/ 
  [19] 
  【LeetCode 直通车】：560 和为K的子数组（中等）: https://leetcode-cn.com/problems/subarray-sum-equals-k/ 
  [20] 
  【LeetCode 直通车】：1 两数之和（简单）: https://leetcode-cn.com/problems/two-sum/ 
  [21] 
  【LeetCode 直通车】：167 两数之和 II - 输入有序数组（简单）: https://leetcode-cn.com/problems/two-sum-ii-input-array-is-sorted/ 
  [22] 
  【LeetCode 直通车】：15 三数之和（中等）: https://leetcode-cn.com/problems/3sum/ 
  [23] 
  【LeetCode 直通车】：18 四数之和（中等）: https://leetcode-cn.com/problems/4sum/ 
  [24] 
  【LeetCode 直通车】：42 接雨水（困难）: https://leetcode-cn.com/problems/trapping-rain-water/ 
  [25] 
  【LeetCode 直通车】：55 跳跃游戏（中等）: https://leetcode-cn.com/problems/jump-game/ 
  [26] 
  【LeetCode 直通车】：45 跳跃游戏 II（中等）: https://leetcode-cn.com/problems/jump-game-ii/ 
  [27] 
  【LeetCode 直通车】：236 二叉树的最近公共祖先（简单）: https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree/ 
  [28] 
  【LeetCode 直通车】：700 二叉搜索树中的搜索（简单）: https://leetcode-cn.com/problems/search-in-a-binary-search-tree/ 
  [29] 
  【LeetCode 直通车】：450 删除二叉搜索树中的节点（中等）: https://leetcode-cn.com/problems/delete-node-in-a-bst/ 
  [30] 
  【LeetCode 直通车】：222 完全二叉树的节点个数（中等）: https://leetcode-cn.com/problems/count-complete-tree-nodes/ 
  [31] 
  【LeetCode 直通车】：103 二叉树的锯齿形层序遍历（中等）: https://leetcode-cn.com/problems/binary-tree-zigzag-level-order-traversal/ 
  [32] 
  【LeetCode 直通车】：452 用最少数量的箭引爆气球（中等）: https://leetcode-cn.com/problems/minimum-number-of-arrows-to-burst-balloons/ 
  [33] 
  【LeetCode 直通车】：56 合并区间（中等）: https://leetcode-cn.com/problems/merge-intervals/ 
  [34] 
  【LeetCode 直通车】：4 寻找两个正序数组的中位数（困难）: https://leetcode-cn.com/problems/median-of-two-sorted-arrays/ 
  [35] 
  【LeetCode 直通车】：392 判断子序列（简单）: https://leetcode-cn.com/problems/is-subsequence/ 
  [36] 
  【LeetCode 直通车】：34 在排序数组中查找元素的第一个和最后一个位置（中等）: https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/ 
  [37] 
  【LeetCode 直通车】：300 最长递增子序列（中等）: https://leetcode-cn.com/problems/longest-increasing-subsequence/ 
  [38] 
  【LeetCode 直通车】：322 零钱兑换（中等）: https://leetcode-cn.com/problems/coin-change/ 
  [39] 
  【LeetCode 直通车】：1143 最长公共子序列（中等）: https://leetcode-cn.com/problems/longest-common-subsequence/ 
  [40] 
  【LeetCode 直通车】：72 编辑距离（困难）: https://leetcode-cn.com/problems/edit-distance/ 
  [41] 
  【LeetCode 直通车】：516 最长回文子序列（中等）: https://leetcode-cn.com/problems/longest-palindromic-subsequence/ 
  [42] 
  【LeetCode 直通车】：53 最大子序和（简单）: https://leetcode-cn.com/problems/maximum-subarray/ 
  [43] 
  【LeetCode 直通车】：121 买卖股票的最佳时机（简单）: https://leetcode-cn.com/problems/container-with-most-water/ 
  [44] 
  【LeetCode 直通车】：122 买卖股票的最佳时机 II（简单）: https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/ 
  [45] 
  【LeetCode 直通车】：123 买卖股票的最佳时机 III（困难）: https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iii/ 
  [46] 
  【LeetCode 直通车】：188 买卖股票的最佳时机IV（困难）: https://leetcode-cn.com/problems/container-with-most-water/ 
  [47] 
  【LeetCode 直通车】：309 买卖股票的最佳时机含冷冻期（中等）: https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/ 
  [48] 
  【LeetCode 直通车】：714 买卖股票的最佳时机含手续费（中等）: https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/ 
  [49] 
  【LeetCode 直通车】：752 打开转盘锁（中等）: https://leetcode-cn.com/problems/open-the-lock/ 
  [50] 
  【LeetCode 直通车】：111 二叉树的最小深度（简单）: https://leetcode-cn.com/problems/minimum-depth-of-binary-tree/ 
  [51] 
  【LeetCode 直通车】：155 最小栈（简单）: https://leetcode-cn.com/problems/min-stack/submissions/ 
  [52] 
  【LeetCode 直通车】：496 下一个更大元素 I（简单）: https://leetcode-cn.com/problems/next-greater-element-i/ 
  [53] 
  【LeetCode 直通车】：503 下一个更大元素 II（中等）: https://leetcode-cn.com/problems/next-greater-element-ii/ 
  [54] 
  【LeetCode 直通车】：20 有效的括号（中等）: https://leetcode-cn.com/problems/valid-parentheses/ 
  [55] 
  【LeetCode 直通车】：71 简化路径（中等）: https://leetcode-cn.com/problems/simplify-path/ 
  [56] 
  【LeetCode 直通车】：695 岛屿的最大面积（中等）: https://leetcode-cn.com/problems/max-area-of-island/ 
  [57] 
  【LeetCode 直通车】：100 相同的树（简单）: https://leetcode-cn.com/problems/same-tree/ 
  [58] 
  【LeetCode 直通车】：51 N皇后（困难）: https://leetcode-cn.com/problems/n-queens/ 
  [59] 
  【LeetCode 直通车】：46 全排列（中等）: https://leetcode-cn.com/problems/permutations/ 
  [60] 
  【LeetCode 直通车】：22 括号生成（中等）: https://leetcode-cn.com/problems/generate-parentheses/ 
  [61] 
  【LeetCode 直通车】：93 复原 IP 地址（中等）: https://leetcode-cn.com/problems/restore-ip-addresses/ 
  [62] 
  【LeetCode 直通车】：78 子集（中等）: https://leetcode-cn.com/problems/subsets/ 
  [63] 
  labuladong 的算法小抄: https://www.yuque.com/tuture/interview/labuladong：https 
  [64] 
  Github 仓库: https://github.com/labuladong/fucking-algorithm 
  [65] 
  字节跳动最爱考的前端面试题:JavaScript 基础: https://juejin.cn/post/6934500357091360781 
  [66] 
  字节跳动最爱考的前端面试题:CSS 基础: https://juejin.cn/post/6936913689115099143 
  [67] 
  字节跳动最爱考的前端面试题:计算机网络基础: https://juejin.cn/post/6939691851746279437 
   
     
   
   
   
  前端技术优选 
  为你精选前端领域优质技术博文，欢迎关注。 
  61篇原创内容 
  公众号

机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
Goolge earth studio 进阶4——路径修改与平滑陟彼高冈yu Google earth studio 进阶教程旅游
如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
基于社交网络算法优化的二维最大熵图像分割智能算法研学社（Jack旭）智能优化算法应用图像分割算法 php 开发语言
智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
python八股文面试题分享及解析(1) Shawn________ python
#1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
121. 买卖股票的最佳时机薄荷糖的味道_fb40
给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。示例1:输入:[7,1,5,3,6,4]输出:5解释:在第2天（股票价格=1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润=6-1=5。注意利润不能是7-1=6,因为卖出价格需要大于买入价格。示例2:输入:
MYSQL面试系列-04 king01299 面试 mysql 面试
MYSQL面试系列-0417.关于redolog和binlog的刷盘机制、redolog、undolog作用、GTID是做什么的？innodb_flush_log_at_trx_commit及sync_binlog参数意义双117.1innodb_flush_log_at_trx_commit该变量定义了InnoDB在每次事务提交时，如何处理未刷入（flush）的重做日志信息（redolog）。它
Kafka 消息丢失如何处理？架构文摘JGWZ 学习
今天给大家分享一个在面试中经常遇到的问题：Kafka消息丢失该如何处理？这个问题啊，看似简单，其实里面藏着很多“套路”。来，咱们先讲一个面试的“真实”案例。面试官问：“Kafka消息丢失如何处理？”小明一听，反问：“你是怎么发现消息丢失了？”面试官顿时一愣，沉默了片刻后，可能有点不耐烦，说道：“这个你不用管，反正现在发现消息丢失了，你就说如何处理。”小明一头雾水：“问题是都不知道怎么丢的，处理起来
每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
回溯算法-重新安排行程 chirou_ 算法数据结构图论 c++图搜索
leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1）算法大师华为od 面试 python 算法前端
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
Faiss：高效相似性搜索与聚类的利器网络·魚大数据 faiss
Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面一个射手座的程序媛程序员华为od 面试职场和发展
最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insert into select 主键自增 mybatis delete返回值 mybatis insert返回主键 mybatis insert返回对象 mybatis plus insert返回主键 mybatis plus 插入生成id
前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
k均值聚类算法考试例题_k均值算法(k均值聚类算法计算题) 寻找你83497 k均值聚类算法考试例题
?算法：第一步：选K个初始聚类中心，z1(1),z2(1)，…，zK(1)，其中括号内的序号为寻找聚类中心的迭代运算的次序号。聚类中心的向量值可任意设定，例如可选开始的K个.k均值聚类：---------一种硬聚类算法，隶属度只有两个取值0或1，提出的基本根据是“类内误差平方和最小化”准则；模糊的c均值聚类算法：--------一种模糊聚类算法，是.K均值聚类算法是先随机选取K个对象作为初始的聚类
Python实现简单的机器学习算法 master_chenchengg python python 办公效率 python开发 IT
Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
推荐算法_隐语义-梯度下降 _feivirus_ 算法机器学习和数学推荐算法机器学习隐语义
importnumpyasnp1.模型实现"""inputrate_matrix:M行N列的评分矩阵，值为P*Q.P:初始化用户特征矩阵M*K.Q:初始化物品特征矩阵K*N.latent_feature_cnt:隐特征的向量个数max_iteration:最大迭代次数alpha:步长lamda:正则化系数output分解之后的P和Q"""defLFM_grad_desc(rate_matrix,l
K近邻算法_分类鸢尾花数据集 _feivirus_ 算法机器学习和数学分类机器学习 K近邻
importnumpyasnpimportpandasaspdfromsklearn.datasetsimportload_irisfromsklearn.model_selectionimporttrain_test_splitfromsklearn.metricsimportaccuracy_score1.数据预处理iris=load_iris()df=pd.DataFrame(data=ir
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列 C语言
文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
2024.8.22 Python，链表两数之和，链表快速反转，二叉树的深度，二叉树前中后序遍历，N叉树递归遍历，翻转二叉树 RaidenQ python 链表开发语言
1.链表两数之和输入：l1=[2,4,3],l2=[5,6,4]输出：[7,0,8]解释：342+465=807.示例2：输入：l1=[0],l2=[0]输出：[0]示例3：输入：l1=[9,9,9,9,9,9,9],l2=[9,9,9,9]输出：[8,9,9,9,0,0,0,1]昨天的这个题，用自己的办法写的麻烦的要死，然后刚才一看chat归类的办法，感觉自己像个智障。classListNode
2019考研 | 西交大软件工程笔者阿蓉
本科背景：某北京211学校电子信息工程互联网开发工作两年录取结果：全日制软件工程学院分数：初试350+复试笔试80+面试85+总排名：100+从五月份开始脱产学习，我主要说一下专业课和复试还有我对非全的一些看法。【数学100+】张宇，张宇，张宇。跟着张宇学习，入门视频刷一遍，真题刷两遍，错题刷三遍。书刷N多遍。从视频开始学习，是最快的学习方法。5-7月份把主要是数学学好，8-9月份开始给自己每个周
[Python] 数据结构详解及代码 AIAdvocate 算法 python 数据结构链表
今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
Python算法L5：贪心算法小熊同学哦 Python算法算法 python 贪心算法
Python贪心算法简介目录Python贪心算法简介贪心算法的基本步骤贪心算法的适用场景经典贪心算法问题1.**零钱兑换问题**2.**区间调度问题**3.**背包问题**贪心算法的优缺点优点：缺点：结语贪心算法（GreedyAlgorithm）是一种在每一步选择中都采取当前最优或最优解的算法。它的核心思想是，在保证每一步局部最优的情况下，希望通过贪心选择达到全局最优解。虽然贪心算法并不总能得到全
【RabbitMQ 项目】服务端：数据管理模块之绑定管理月夜星辉雪 rabbitmq 分布式
文章目录一.编写思路二.代码实践一.编写思路定义绑定信息类交换机名称队列名称绑定关键字：交换机的路由交换算法中会用到没有是否持久化的标志，因为绑定是否持久化取决于交换机和队列是否持久化，只有它们都持久化时绑定才需要持久化。绑定就好像一根绳子，两端连接着交换机和队列，当一方不存在，它就没有存在的必要了定义绑定持久化类构造函数：如果数据库文件不存在则创建，打开数据库，创建binding_table插入
非对称加密算法原理与应用2——RSA私钥加密文件私语茶馆云部署与开发架构及产品灵感记录 RSA2048 私钥加密
作者：私语茶馆1.相关章节（1）非对称加密算法原理与应用1——秘钥的生成-CSDN博客第一章节讲述的是创建秘钥对，并将公钥和私钥导出为文件格式存储。本章节继续讲如何利用私钥加密内容，包括从密钥库或文件中读取私钥，并用RSA算法加密文件和String。2.私钥加密的概述本文主要基于第一章节的RSA2048bit的非对称加密算法讲述如何利用私钥加密文件。这种加密后的文件，只能由该私钥对应的公钥来解密。
粒子群优化 (PSO) 在三维正弦波函数中的应用 subject625Ruben 机器学习人工智能 matlab 算法
在这篇博客中，我们将展示如何使用粒子群优化（PSO）算法求解三维正弦波函数，并通过增加正弦波扰动，使优化过程更加复杂和有趣。本文将介绍目标函数的定义、PSO参数设置以及算法执行的详细过程，并展示搜索空间中的动态过程和收敛曲线。1.目标函数定义我们使用的目标函数是一个三维正弦波函数，定义如下：objectiveFunc=@(x)sin(sqrt(x(1).^2+x(2).^2))+0.5*sin(5
自定义队列 junjun2018
队列：像排队吃饭一样，先到的先点菜，后来的后点菜。以下代码展示使用单向列表实现的队列。//链表是以节点为单位的，对于单向链表，每个节点中包含一个值和指向下一个对象的引用publicclassNode{Objectvalue;Nodenext;publicNode(Objectvalue){this.value=value;}publicObjectgetValue(){returnvalue;}p
对于规范和实现，你会混淆吗？ yangshangchuan HotSpot
昨晚和朋友聊天，喝了点咖啡，由于我经常喝茶，很长时间没喝咖啡了，所以失眠了，于是起床读JVM规范，读完后在朋友圈发了一条信息： JVM Run-Time Data Areas：The Java Virtual Machine defines various run-time data areas that are used during execution of a program. So
android 网络百合不是茶网络
android的网络编程和java的一样没什么好分析的都是一些死的照着写就可以了,所以记录下来方便查找 , 服务器使用的是TomCat 服务器代码; servlet的使用需要在xml中注册 package servlet; import java.io.IOException; import java.util.Arr
[读书笔记]读法拉第传 comsci 读书笔记
1831年的时候,一年可以赚到1000英镑的人..应该很少的... 要成为一个科学家,没有足够的资金支持,很多实验都无法完成但是当钱赚够了以后....就不能够一直在商业和市场中徘徊......
随机数的产生沐刃青蛟随机数
c++中阐述随机数的方法有两种：一是产生假随机数（不管操作多少次，所产生的数都不会改变）这类随机数是使用了默认的种子值产生的，所以每次都是一样的。 //默认种子 for (int i = 0; i < 5; i++) { cout<<
PHP检测函数所在的文件名 IT独行者 PHP 函数
很简单的功能，用到PHP中的反射机制，具体使用的是ReflectionFunction类，可以获取指定函数所在PHP脚本中的具体位置。创建引用脚本。代码： [php] view plain copy // Filename: functions.php <?php&nbs
银行各系统功能简介文强chu 金融
银行各系统功能简介　业务系统核心业务系统业务功能包括：总账管理、卡系统管理、客户信息管理、额度控管、存款、贷款、资金业务、国际结算、支付结算、对外接口等清分清算系统以清算日期为准，将账务类交易、非账务类交易的手续费、代理费、网络服务费等相关费用，按费用类型计算应收、应付金额，经过清算人员确认后上送核心系统完成结算的过程国际结算系
Python学习1(pip django 安装以及第一个project) 小桔子 python django pip
最近开始学习python,要安装个pip的工具。听说这个工具很强大，安装了它，在安装第三方工具的话so easy!然后也下载了，按照别人给的教程开始安装，奶奶的怎么也安装不上！第一步：官方下载pip-1.5.6.tar.gz, https://pypi.python.org/pypi/pip easy! 第二部：解压这个压缩文件，会看到一个setup.p
php 数组 aichenglong PHP 排序数组循环多维数组
1 php中的创建数组 $product = array('tires','oil','spark');//array()实际上是语言结构而不是函数 2 如果需要创建一个升序的排列的数字保存在一个数组中，可以使用range()函数来自动创建数组 $numbers=range(1,10)//1 2 3 4 5 6 7 8 9 10 $numbers=range(1,10,
安装python2.7 AILIKES python
安装python2.7 1、下载可从 http://www.python.org/进行下载#wget https://www.python.org/ftp/python/2.7.10/Python-2.7.10.tgz 2、复制解压 #mkdir -p /opt/usr/python #cp /opt/soft/Python-2
java异常的处理探讨百合不是茶 JAVA异常
//java异常 /* 1，了解java 中的异常处理机制，有三种操作 a,声明异常 b,抛出异常 c,捕获异常 2，学会使用try-catch-finally来处理异常 3，学会如何声明异常和抛出异常 4，学会创建自己的异常 */ //2，学会使用try-catch-finally来处理异常
getElementsByName实例 bijian1013 element
实例1： <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/x
探索JUnit4扩展：Runner bijian1013 java 单元测试 JUnit
参加敏捷培训时，教练提到Junit4的Runner和Rule，于是特上网查一下，发现很多都讲的太理论，或者是举的例子实在是太牵强。多搜索了几下，搜索到两篇我觉得写的非常好的文章。文章地址：http://www.blogjava.net/jiangshachina/archive/20
[MongoDB学习笔记二]MongoDB副本集 bit1129 mongodb
1. 副本集的特性 1)一台主服务器(Primary),多台从服务器(Secondary) 2)Primary挂了之后，从服务器自动完成从它们之中选举一台服务器作为主服务器，继续工作，这就解决了单点故障，因此，在这种情况下，MongoDB集群能够继续工作 3)挂了的主服务器恢复到集群中只能以Secondary服务器的角色加入进来 2
【Spark八十一】Hive in the spark assembly bit1129 assembly
Spark SQL supports most commonly used features of HiveQL. However, different HiveQL statements are executed in different manners: 1. DDL statements (e.g. CREATE TABLE, DROP TABLE, etc.)
Nginx问题定位之监控进程异常退出 ronin47
nginx在运行过程中是否稳定，是否有异常退出过？这里总结几项平时会用到的小技巧。 1. 在error.log中查看是否有signal项，如果有，看看signal是多少。比如，这是一个异常退出的情况： $grep signal error.log 2012/12/24 16:39:56 [alert] 13661#0: worker process 13666 exited on s
No grammar constraints (DTD or XML schema).....两种解决方法 byalias xml
方法一：常用方法关闭XML验证工具栏：windows => preferences => xml => xml files => validation => Indicate when no grammar is specified:选择Ignore即可。方法二：（个人推荐）添加内容如下 <?xml version=
Netty源码学习-DefaultChannelPipeline bylijinnan netty
package com.ljn.channel; /** * ChannelPipeline采用的是Intercepting Filter 模式 * 但由于用到两个双向链表和内部类，这个模式看起来不是那么明显，需要仔细查看调用过程才发现 * * 下面对ChannelPipeline作一个模拟，只模拟关键代码： */ public class Pipeline {
MYSQL数据库常用备份及恢复语句 chicony mysql
备份MySQL数据库的命令，可以加选不同的参数选项来实现不同格式的要求。 mysqldump -h主机 -u用户名 -p密码数据库名 > 文件备份MySQL数据库为带删除表的格式，能够让该备份覆盖已有数据库而不需要手动删除原有数据库。 mysqldump -–add-drop-table -uusername -ppassword databasename > ba
小白谈谈云计算--基于Google三大论文 CrazyMizzz Google 云计算 GFS
之前在没有接触到云计算之前，只是对云计算有一点点模糊的概念，觉得这是一个很高大上的东西，似乎离我们大一的还很远。后来有机会上了一节云计算的普及课程吧，并且在之前的一周里拜读了谷歌三大论文。不敢说理解，至少囫囵吞枣啃下了一大堆看不明白的理论。现在就简单聊聊我对于云计算的了解。我先说说GFS &n
hadoop 平衡空间设置方法 daizj hadoop balancer
在hdfs-site.xml中增加设置balance的带宽，默认只有1M： <property> <name>dfs.balance.bandwidthPerSec</name> <value>10485760</value> <description&g
Eclipse程序员要掌握的常用快捷键 dcj3sjt126com 编程
判断一个人的编程水平，就看他用键盘多，还是鼠标多。用键盘一是为了输入代码（当然了，也包括注释），再有就是熟练使用快捷键。曾有人在豆瓣评《卓有成效的程序员》：“人有多大懒，才有多大闲”。之前我整理了一个程序员图书列表，目的也就是通过读书，让程序员变懒。程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可以那么勤奋，每天都孜孜不倦得
Android学习之路 dcj3sjt126com Android学习
转自：http://blog.csdn.net/ryantang03/article/details/6901459 以前有J2EE基础，接触JAVA也有两三年的时间了，上手Android并不困难，思维上稍微转变一下就可以很快适应。以前做的都是WEB项目，现今体验移动终端项目，让我越来越觉得移动互联网应用是未来的主宰。下面说说我学习Android的感受，我学Android首先是看MARS的视
java 遍历Map的四种方法 eksliang java HashMap java 遍历Map的四种方法
转载请出自出处： http://eksliang.iteye.com/blog/2059996 package com.ickes; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; /** * 遍历Map的四种方式
【精典】数据库相关相关 gengzg 数据库
package C3P0; import java.sql.Connection; import java.sql.SQLException; import java.beans.PropertyVetoException; import com.mchange.v2.c3p0.ComboPooledDataSource; public class DBPool{
自动补全 huyana_town 自动补全
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml&quo
jquery在线预览PDF文件，打开PDF文件天梯梦 jquery
最主要的是使用到了一个jquery的插件jquery.media.js，使用这个插件就很容易实现了。核心代码 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.
ViewPager刷新单个页面的方法 lovelease android viewpager tag 刷新
使用ViewPager做滑动切换图片的效果时，如果图片是从网络下载的，那么再子线程中下载完图片时我们会使用handler通知UI线程，然后UI线程就可以调用mViewPager.getAdapter().notifyDataSetChanged()进行页面的刷新，但是viewpager不同于listview，你会发现单纯的调用notifyDataSetChanged()并不能刷新页面
利用按位取反（~）从复合枚举值里清除枚举值草料场 enum
以 C# 中的 System.Drawing.FontStyle 为例。如果需要同时有多种效果，如：“粗体”和“下划线”的效果，可以用按位或（|） FontStyle style = FontStyle.Bold | FontStyle.Underline; 如果需要去除 style 里的某一种效果，
Linux系统新手学习的11点建议刘星宇编程工作 linux 脚本
　　随着Linux应用的扩展许多朋友开始接触Linux，根据学习Windwos的经验往往有一些茫然的感觉：不知从何处开始学起。这里介绍学习Linux的一些建议。　　一、从基础开始：常常有些朋友在Linux论坛问一些问题，不过，其中大多数的问题都是很基础的。例如：为什么我使用一个命令的时候，系统告诉我找不到该目录，我要如何限制使用者的权限等问题，这些问题其实都不是很难的，只要了解了 Linu
hibernate dao层应用之HibernateDaoSupport二次封装 wangzhezichuan DAO Hibernate
/** * 方法描述:sql语句查询返回List<Class> * 方法备注: Class 只能是自定义类 * @param calzz * @param sql * @return * 创建人：王川 * 创建时间：Jul

算法分类汇总

数位 DP - OI Wiki

高频算法题系列：链表

寻找链表中点

前序遍历判断回文链表

反转链表

合并K个升序链表

K 个一组翻转链表

环形链表

排序链表

相交链表

【】高频算法题系列：字符串

【面试真题】最长回文子串【双指针】

最长公共前缀【双指针】

无重复字符的最长子串【双指针】

【面试真题】 最小覆盖子串【滑动窗口】

【】高频算法题系列：数组问题

【面试真题】俄罗斯套娃信封问题【排序+最长上升子序列】

最长连续递增序列【快慢指针】

最长连续序列 【哈希表】

【面试真题】盛最多水的容器【哈希表】

寻找两个正序数组的中位数【双指针】

删除有序数组中的重复项【快慢指针】

和为K的子数组【哈希表】

nSum问题【哈希表】【系列】

接雨水【暴力+备忘录优化】

跳跃游戏【贪心算法】【系列】

高频算法题系列：二叉树

二叉树的最近公共祖先【二叉树】

二叉搜索树中的搜索【二叉树】

删除二叉搜索树中的节点【二叉树】

完全二叉树的节点个数【二叉树】

二叉树的锯齿形层序遍历【二叉树】

【】高频算法题系列：排序算法

用最少数量的箭引爆气球【排序算法】

合并区间【排序算法+区间问题】

高频算法题系列：二分查找

寻找两个正序数组的中位数【二分查找】

判断子序列【二分查找】

在排序数组中查找元素的第一个和最后一个位置【二分搜索】

【】高频算法题系列：动态规划

最长递增子序列【动态规划】

【面试真题】 零钱兑换【动态规划】

【面试真题】 最长公共子序列【动态规划】

编辑距离【动态规划】

【面试真题】最长回文子序列【动态规划】

【面试真题】 最大子序和【动态规划】

【面试真题】 买卖股票的最佳时机【动态规划】

高频算法题系列：BFS

打开转盘锁【BFS】

二叉树的最小深度【BFS】

【】高频算法题系列：栈

最小栈【栈】

【系列】下一个更大元素 【栈】

【面试真题】有效的括号【栈】

简化路径【栈】

【】高频算法题系列：DFS

岛屿的最大面积【DFS】

相同的树【DFS】

【】高频算法题系列：回溯算法

【面试真题】N皇后【回溯算法】

全排列【回溯算法】

括号生成【回溯算法】

复原 IP 地址【回溯算法】

子集【回溯算法】

文末福利

❤️谢谢

往期精文

原创不易

参考资料

你可能感兴趣的:(算法,算法,面试,链表,1024程序员节)

【面试真题】最小覆盖子串【滑动窗口】

最长连续序列【哈希表】

【面试真题】零钱兑换【动态规划】

【面试真题】最长公共子序列【动态规划】

【面试真题】最大子序和【动态规划】

【面试真题】买卖股票的最佳时机【动态规划】

【系列】下一个更大元素【栈】