一个搬砖工人

时间复杂度名称1常数logn对数n线性nlogn线性对数n^2平方n^3立方2^n指数1常数阶O(1)int sum = 0, n = 100; /*执行一次*/sum = (1 + n) * n / 2; /*执行一次*/printf("%d",sum); /*执行一次*/2线性阶O(n)int i; for(i = 0; i < n; i++){/*时间复杂度为O(1)的程序步骤序列*/}3对数阶O...

1递归的反转整个链表对于递归算法，最重要的就是明确递归函数的定义。具体来说，我们的reverse函数定义是这样的：输入一个节点head，将「以head为起点」的链表反转，并返回反转之后的头结点。明白了函数的定义，再来看这个问题。比如说我们想反转这个链表：那么输入reverse(head)后，会在这里进行递归：不要跳进递归，而是要根据刚才的函数定义，来弄清楚这段代码会产生什么结果：按照定义，这个reverse(head.next)执行完成后，整个链表应该变成了这样：并且根据函数定义，rev

堆分为两种：最大堆和最小堆，两者的差别在于节点的排序方式。在最大堆中，父节点的值比每一个子节点的值都要大。在最小堆中，父节点的值比每一个子节点的值都要小。这就是所谓的“堆属性”，并且这个属性对堆中的每一个节点都成立。这是一个最大堆，因为每一个父节点的值都比其子节点要大。10 比 7 和 2 都大。7 比 5 和 1都大。根据这一属性，那么最大堆总是将其中的最大值存放在树的根节点。而对于最小堆，根节点中的元素总是树中的最小值。堆属性非常有用，因为堆常常被当做优先队列使用，因为可以快速地访问到“最重要”

1树的理解1重点概念树（Tree）是n（n>=0)个结点的有限集。n=0时称为空树。在任意一颗非空树中：1）有且仅有一个特定的称为根（Root）的结点；2）当n>1时，其余结点可分为m(m>0)个互不相交的有限集T1、T2、......、Tn，其中每一个集合本身又是一棵树，并且称为根的子树。此外，树的定义还需要强调以下两点：1）n>0时根结点是唯一的，不可能存在多个根结点，数据结构中的树只能有一个根结点。2）m>0时，子树的个数没有限制，但它们一定是互不相交的。

public static void mergeSort(int[] arr) { if (arr == null || arr.length < 2) { return; } process(arr, 0, arr.length - 1); } private static void process(int[] arr, int l, int r) { if (l == r) { ..

单链表的数据结构class Node { public int value; public Node next; public Node(int value) { this.value = value; }}双链表数据结构public class DoubleNode { public int value; public DoubleNode last; public DoubleNode next; public DoubleNode(in

1异或运算法则异或运算:相同为0，不同为1异或运算就记成无进位相加。满足交换律，结合律。0^N = NN^N = 0int a = 7; // 00111int b = 13; // 01101 01010 = 8+2 = 102不用任何空间的情况下交换两个变量内存区域不同，可以使用这个方法：int a = 13;int b = 7;a = a^b;b = a^b;a = a^b;---> a = 7; b = 13;解释：a = a^b; //

1寻找一个数（基本的二分搜索）package com.example.demo;/** * @email 930312043@qq.com * @author: zhaoshuai * @date: 2021/7/31 22:12 */public class LeetCode { int binarySearch(int[] nums, int target) { if (nums == null && nums.length == 0) {

dp[i][1]的定义：截止到i索引位置并且i位置的代价花费了，最小的代价；dp[i][0]的定义：截止到i索引位置并且i位置的代价没有花费，最小的代价；class Solution { public int minCostClimbingStairs(int[] cost) { int len = cost.length; int[][] dp = new int[len][2]; dp[0][0] = 0; dp[0][1.

class Solution { public int numberOfMatches(int n) { return travel(n); } int travel(int n){ if( n== 1){ return 0; } if(n % 2 == 1){ return (n-1)/2 + travel((n - 1) / 2 + 1); }..

class Solution { public int maxProfit(int[] prices) { int len = prices.length; if(len < 2){ return 0; } int[][] dp = new int[len][2]; dp[0][0] = 0; dp[0][1] = -prices[0]; for(in..

有关括号问题，你只要记住两个个性质，思路就很容易想出来：1、一个「合法」括号组合的左括号数量一定等于右括号数量，这个显而易见。2、对于一个「合法」的括号字符串组合p，必然对于任何0 <= i < len§都有：子串p[0…i]中左括号的数量都大于或等于右括号的数量。class Solution { List<String> res; public List<String> generateParenthesis(int n) { r.

class Solution { public int climbStairs(int n) { if(n == 1) return 1; if(n == 2) return 2; int[] dp = new int[n+1]; dp[0] = 1; dp[1] = 1; for(int i = 2 ; i <= n ; i++){ dp[i] = dp[i-1] + ..

解题思路：1定义函数dp[i]=>截止到数组i处，最大子序列和；2在dp[]中找到最大值。class Solution { public int maxSubArray(int[] nums) { int len = nums.length; int res = 0; int[] dp = new int[len]; dp[0] = nums[0]; for(int i = 1 ; i < len ;.

class Solution { List<List<Integer>> res; public List<List<Integer>> permute(int[] nums) { res = new ArrayList<>(); List track = new ArrayList<>(); backtrack(nums,track); return ..

class Solution { List<List<Integer>> res; public List<List<Integer>> combine(int n, int k) { res = new ArrayList<>(); List<Integer> track = new ArrayList<>(); backtrack(n,k,1,track..

1子集import java.util.LinkedList;import java.util.List;class Solution { List<List<Integer>> res ; public List<List<Integer>> subsets(int[] nums) { res = new ArrayList<>(); List<Integer> track =

解决一个回溯问题，实际上就是一个决策树的遍历过程。你只需要思考 3 个问题：1、路径：也就是已经做出的选择。2、选择列表：也就是你当前可以做的选择。3、结束条件：也就是到达决策树底层，无法再做选择的条件。代码方面，回溯算法的框架：result = []def backtrack(路径, 选择列表): if 满足结束条件: result.add(路径) return for 选择 in 选择列表: 做选择 backtr

动态规划问题的一般形式就是求最值。比如说让你求**最长**递增子序列呀，**最小**编辑距离等等。既然是要求最值，核心问题是什么呢？**求解动态规划的核心问题是穷举**。因为要求最值，肯定要把所有可行的答案穷举出来，然后在其中**找最值**呗。 首先，动态规划的穷举有点特别，因为这类问题存在**「重叠子问题」**，如果暴力穷举的话效率会极其低下，所以需要「备忘录」或者**「DP table」**来优化穷举过程，避免不必要的计算。 而且，动态规划问题一定会具备**「最优子结构」**，才能通过**子问题的.

1冒泡排序（Bubble Sort） private int[] bubbleSort(int[] arr) { for (int i = 0 ; i < arr.length - 1 ; i++) { // 比较的趟数 for (int j = 0 ; j< arr.length - 1 - i ; j++) { // 每趟比较的次数 if (arr[j] > arr[j+1]){

1 位运算位运算符主要针对两个二进制数的位进行逻辑运算，它包括了：“与”、“非”、“或”、“异或”。1.1 与运算(&)运算规则：两个操作数中位都为1，结果才为1，否则结果为0public class Run { public static void main(String[] args) { int a = 4; int b = 8; int res = a & b; String s_a = Integer.