qq_35535026的博客

一石激起千层浪广度优先搜索模型： bfs( ) { 1.建立起开始步骤，队列初始化 2.遍历队列中的每一种可能，while(队列不为空) { 通过队头元素带出下一步所有的可能，并且依次入队 { 判断当前情况是否达成目标：按照目标要求处理逻辑 } 继续遍历队列中的剩余情况 }}例题1：员工的重要性import ja

1. dfs:1 深度优先搜索的关键是解决 -> 目前需要如何做 ，下一步的做法和当前的做法是相同的2 目前需要如何做 -> 一般是尝试每一种可能，遍历循环，对于每一种可能确定之后，继续走下一步，当前的剩余可能等到从下一步回退之后再处理，（深度优先搜索的模型） Dfs (当前这一步的处理逻辑) { 1.判断边界，是否已经一条路走到黑 ：向上回退 2.尝试当下的每一种可能 3.确定一种可能后，继续下一步Dfs(下一步) }例题1：员工的重要性

把字符串转换成一个整数思路： 先处理符合位，将其保存起来。 再将字符串转为字符数组，通过ASC||检查其中是否有别的字符 。最后从左往右 读取 字符数组中的值public class Main { public int StrToInt(String str) { if (str==""|| str.length()==0) return 0; if ( ( str.charAt(0)=='+' ||str.charAt(0)=='-' )&&am

要求时间复杂度为O(n),额外空间复杂度为O(1)的算法思路：找到中间节点，将中间节点后半部分的链表逆置，然后将两部分链表进行比较。public class PalindromeList { public boolean chkPalindrome(ListNode A) { ListNode middle = getMiddle(A); ListNode reverseHead = reverseList(middle); ListNode

public class Solution { public ListNode deleteDuplication(ListNode pHead) { if(pHead == null){ return null; } ListNode prev = new ListNode(-1); ListNode newHead= prev; prev.next = pHead; .

思路：代码：public class Partition { public ListNode partition(ListNode pHead, int x) { ListNode node1 = new ListNode(-1); ListNode head1 = node1; ListNode node2 = new ListNode(-1); ListNode head2 = node2; Li.

**思想：**分治思想的延伸，将大问题化解为小问题的分治过程。在处理的过程中，保存这些小问题的处理结果，在后面处理大问题时，可以直接调用**例题1 ：输出斐波那契数列的第n项我们通过推导已知 斐波那契数列的规律 f(n) = f(n-1) + f(n-2) f(0) = 0 f(1) = 1动态规划分析：状态转移方程 dp[i+1] = dp[i] + dp[i-1]class Solution { public int fib(int n) { if(n==0){

思路：先统计各个单词的出现次数将所有单词 + 次数组织成线性结构使用优先队列public class Solution2 { static class WordCount implements Comparable<WordCount> { String word; int count; public WordCount(String word, int count) { this.word = wo.

思路1： 复制链表 和 处理random 分开进行 使用Map1.首先复制链表（遍历+尾插）2.使用Map保存映射关系<旧结点 -> 新结点 > + oldRandom 得到 newRandomimport java.util.Comparator;import java.util.Map;import java.util.TreeMap;public class Solution { static class NodeComparator implements ..

思路：搜索树转化为有序链表， 有序可以理解为运用中序遍历，即 将中序遍历的结果，进行链表的尾插操作public class Solution { private Node head ; private Node last ; public Node treeToDoublyList(Node root) { head = null; last = null; inorder(root); head.left =

求两数之和，要求不得在函数体内使用 + - * / 四则运算符合思路：通常我们是如何 计算 5 + 71.只做个位相加，不进位 （二进制中， 异或 ^ 效果等于个位相加不进位， 0加0为0,1加0为1 ,1加1为0）2.做进位运算 5+7 进位，进位的值为10 （二进制中，位运算左移相当于进位）3.将前两个结果加起来public class Solution { public int Add(int num1,int num2) { while(num2!=0){

给定一个数组 A[0,1,…,n-1]，请构建一个数组 B[0,1,…,n-1]，其中 B[i] 的值是数组 A 中除了下标 i 以外的元素的积, 即 B[i]=A[0]×A[1]×…×A[i-1]×A[i+1]×…×A[n-1]。不能使用除法。思路： 先计算下三角的值，然后再计算上三角的值。下三角 计算公式for(int i=1;i<a.lenth;i++){ b[i] = b[i-1]*a[i-1] ;}上三角 计算公式for(int i = a.length-2;i>=

思路 ： 双指针引用删除有序数组中的重复项 ：public class Solution1 { public int removeDuplicates(int[] nums) { if (nums.length==0) return 0; int i = 0; // 慢指针 for (int j = 0; j <nums.length ; j++) { //快指针 //让快指针移动，当遇到不重复的数字时，

思路：首先可以根据前序遍历和后序遍历的特点找到根节点通过中序遍历找到左子树的长度，即可推导出右子树的长度分别构建左右子树public class Solution { public TreeNode buildTree(int[] preorder, int[] inorder) { if (preorder.length == 0) { return null; } int rootValue = preorder

思路 ：假如一个结点为根结点，则两个结点的最近公共祖先为根结点看 q. p 结点在 树的 左子树中还是右子树如果 两个结点 一个位于左子树 另一个位于 右子树 则 其最近的公共祖先 为 根节点分别在左右子树中递归查找

思路1 ：bfs 广度优先遍历 ， 将每一层的结点放入一个List中， 然后再将这个list插入最终的List中 public List<List<Integer>> levelOrder(TreeNode root) { List<List<Integer>> list = new ArrayList<>(); if (root==null){ return list;

判断两个非空二叉树 t 是否是 s的子树思路： dfs 深度优先搜索 ：即先比较s和t ，再从s的左右子树开始暴力搜索class Solution { public boolean isSubtree(TreeNode s, TreeNode t) { return dfs(s,t); } private boolean dfs(TreeNode s, TreeNode t) { if (s==null){ ret

例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。class Solution { private List<Integer> arrayToList(int[] array) { List<Integer> list = new ArrayList<>(array.length); for (int

题目：给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，有效字符串需满足：左括号必须用相同类型的右括号闭合。左括号必须以正确的顺序闭合。思路：使用栈，首先将字符串转为字符数组，将 ( [ { 类字符存入栈中 ，然后将其出栈与下一个字符进行比较，如果匹配则正确。否则错误class Solution { public boolean isValid(String s) { Stack<Character> stack = new

字符序列S=”abcdef”,要求输出循环左移3位后的结果，即“defabc”。方法1： s.substring(begin，end);public class Solution { public String LeftRotateString(String str,int n) { if(n<0 || n>str.length()){ return ""; } if(n==0 || n==str.length(

题目描述把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。示例1输入[3,4,5,1,2]返回值1思路：二分法通过二分法找到最小的数字。import java.util.ArrayList;public class Solution { public int minNumberInRotateArray(int [] array) {

思路class Solution { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { ListNode vir = new ListNode(-1); ListNode newHead = vir; while( l1 !=null && l2 !=null){ if( l1.val <= l2.val){

思路：快慢指针public class Solution { public ListNode detectCycle(ListNode head) { if (head == null) { return null; } ListNode slow = head, fast = head; while (fast != null) { slow = slow.next;

思路：通过两个引用，遍历两个链表，将引用统一，然后进行比较public class Solution { public ListNode getIntersectionNode(ListNode headA, ListNode headB) { int countA = getLength(headA); int countB = getLength(headB); ListNode curA = headA; ListN

给定一个头结点为 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。示例 1：输入：[1,2,3,4,5]输出：此列表中的结点 3 (序列化形式：[3,4,5])返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。注意，我们返回了一个 ListNode 类型的对象 ans，这样：ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NU

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。初始化哨兵节点为 ListNode(val-1)初始化两个指针 curr 和 prev 指向当前节点和前继节点。当 curr != nullptr：比较当前节点和要删除的节点：若当前节点就是要删除的节点：则 prev.next = curr.next。否则设 prve = curr。遍历下一个元素：curr = curr.next。返回 l1.nex

反转一个单链表。示例:输入: 1->2->3->4->5->NULL输出: 5->4->3->2->1->NULL解题思路双指针迭代我们可以申请两个指针，第一个指针叫 pre，最初是指向 null 的。第二个指针 cur 指向 head，然后不断遍历 cur。每次迭代到 cur，都将 cur 的 next 指向 pre，然后 pre 和 cur 前进一位。都迭代完了(cur 变成 null 了)，pre 就是最后一个节点了。pu