dl674756321的博客

1. 用队列实现栈结构图的深度优先遍历需要用栈来实现。用队列实现图的深度优先遍历方法是：先用队列实现栈结构，再用栈结构实现图的深度优先遍历。代码思路：构建两个队列：Data队列和help队列；压入数据时数据都进Data队列，假设队列中按顺序进入了1，2，3，4，5，返回数据时，把1，2，3，4 放入help队列，然后拿出Data中的5返回；接着改引用，将Data队列和help队列的引用交换...

归并排序，任何情况下都是O(nlogn)，在合并两个有序数组为一个有序数组时，需要借助额外的存储空间，n/2，n/4，…，1 ，所以空间复杂度为 O(n)。稳定。 public void mergeSort(int[] a) { int n = a.length; if (n <= 1) { return; }...

冒泡排序，O(n2)，O(1)，稳定  冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系。如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置，重复 n 次，就完成了 n 个数据的排序工作。 public void bubbleSort(int[] a) { int n = a.length; i...

前序遍历递归法：public class LC144 { //递归法： public List<Integer> preorderTraversal(TreeNode root) { ArrayList<Integer> list = new ArrayList<>(); if (root == null)...

LFU概念：最少频率使用算法（LFU）：它为每个页面设计了一个访问频次计数器，页面每次被访问时，频次加一，优先淘汰频次最小的页面。import java.util.HashMap;import java.util.LinkedHashSet;import java.util.Map;public class LFUCache { class Node { int key; int value; int freq; // 封装

手写 HashMap（链表中的元素按value降序排列）

手写的 HashMap 里，链表元素按value降序排列public interface MyMap2 { //接口中的方法默认使用的 public abstract 修饰 int put(Integer key, Integer value); int get(Integer key); int size(); interface Entry { int getKey(); int getValue(); }}

手写工厂模式public class 手写工厂方法模式 { public interface Shape { void draw(); } public interface Factory { Shape getShape(); } public static class Circle implements Shape { public Circle() { System.out.print

单例模式1. 饿汉式-线程安全public class Singleton { private static Singleton uniqueInstance = new Singleton(); //私有静态变量 private Singleton() { //私有构造方法 } public static Singleton getUniqueInstan...

手写LinkedListclass Node { Object obj; Node pre; Node next; public Node() { } public void setObj(Object obj) { this.obj = obj; } public void setPre(Node pre) { this.pre = pre; } public void setNext

public class n个线程打印0到100 { static int result = 0; public static void main(String[] args) throws InterruptedException { //假设有20个线程 int n = 20; Thread[] threads = new Thread[n]; //创建n个信号量 final Semaphore[] s .

三个线程交叉打印0-100之间的数import java.util.concurrent.atomic.AtomicInteger;public class 三个线程交替打印0到100 { public static void main(String[] args) { final AtomicInteger i = new AtomicInteger(0); final int n = 100; Thread t1 = new Thread(

两个线程分别打印0到100之间的奇偶public class 两个线程分别打印0到100之间的奇偶 { private static final Object LOCK = new Object(); private static int i = 0; private static final int TOTAL = 100; public static void main(String[] args) { Thread thread1 = new Thr

1. 阻塞队列ArrayBlockingQueue：由数组结构组成的有界阻塞队列，按照先进先出的原则。LinkedBlockingQueue：由链表结构组成的有界阻塞队列，按照先进先出的原则。PriorityBlockingQueue：支持优先级排序的无界阻塞队列。SynchronousQueue：不存储元素的阻塞队列，来一个处理一个。详细理解ArrayBlockingQueue与L...

import java.util.LinkedHashMap;import java.util.Map;public class LRU { class LRUCache extends LinkedHashMap<Integer, Integer> { private int capacity; //最多能缓存多少数据 public L...

杨辉三角递归：public class 杨辉三角 { //递归 public int[][] helper_rec(int deep) { int[][] a = new int[deep][]; for (int i = 0; i < deep; i++) { a[i] = new int[i + 1]; } for (int i = 0; i < deep; i++) {

求根号aa表示求的是根号a，k表示小数保留几位牛顿迭代法：1、构建 y = x方 - a2、(b，b-a方)处的切线为 y-(b-a方)= 2b(x-b)，得到 y=2bx-b方-a3、切线与x轴交点的横坐标为 (b方+a)/2b4、将这个横坐标作为新的b，重复2、3、4步骤public class 根号a { //牛顿迭代法（推荐） public double helper(int a, int k) { double b = a; while

判断一个数字是否为2的幂将2的幂次方写成二进制形式后，很容易就会发现有一个特点：二进制中只有一个1，并且1后面跟了n个0； 因此问题可以转化为判断1后面是否跟了n个0就可以了。如果将这个数减去1后会发现，仅有的那个1会变为0，而原来的那n个0会变为1；因此将原来的数与去减去1后的数字进行与运算后会发现为零。最快速的方法：(number & number - 1) == 0...

LC121：最多只允许完成一笔交易dp[i]表示前i天所能获得的最大利润 public int maxProfit(int[] prices) { int len = prices.length; if (len <= 1) { return 0; } int[] dp = new int[len]; dp[0] = 0; int minPrice = prices[0];

public class T_15_ReverseList { public ListNode ReverseList(ListNode head) { ListNode pre = null; ListNode cur = head; while (cur != null) { ListNode next = cur.next; cur.next = pre; pre = cur;

LC 7题：整数反转（比如 -123）public class LC07 { public int reverse(int x) { long res = 0; //用int的话翻转后可能溢出，比如1999999999（-2147483648~2147483647） while (x != 0) { res = res * 10 +...

最开始要是 while (l <= r)mid与目标值之间的判断分为下面几种情况：mid < target 返回l 得到的是左边第一个等于target的下标 返回r 得到的是左边第一个小于target的下标mid <= target 返回r 得到的是右边第一个等于target的下标 返回l 得到的是右边第一个大于target的下标...

给定一个单链表的头节点 head,实现一个调整单链表的函数，使得每K个节点之间为一组进行逆序，并且从链表的尾部开始组起，头部剩余节点数量不够一组的不需要逆序。（不能使用队列或者栈作为辅助）例如：链表:1->2->3->4->5->6->7->8->null, K = 3。那么 6->7->8，3->4->5，1->2各位一组。调整后：1->2->5->4->3->8->7->6-&gt

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。示例：给你这个链表：1->2->3->4->5当 k = 2 时，应当返回: 2->1->4->3->5当 k = 3 时，应当返回: 3->2->1->4->5class Solution { public ListNode reverseK

插入排序来排序链表（时间复杂度O(n2)）/** * 对链表进行插入排序 O(n^2)。 输入: 4->2->1->3 ，输出: 1->2->3->4 * 思路： pre pre.next head (head.next)cur * 2 9 10 15 8 */publ...

###　int[] 2,3,5,10，返回这个数组中的其中一个数，返回每个数的几率是 2/20,3/20,5/20,10/20import java.util.ArrayList;import java.util.Random;public class test { public static void main(String[] args) { int[] a = new int[]{2, 3, 5, 10}; ArrayList<Integer&gt

class Solution { private int m; private int n; private int[][] grid; private boolean dfs(int row, int col, boolean[][] visited, List<List<Integer>> pathList) { if (row >= m || col >= n || grid[row][col] == 1 || vi

package random;public class quickSort { public static void sort(int[] a, int first, int last) { if (first >= last || a == null || a.length <= 1) { return; //每一趟结束的条件 ...

三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？思路：递归问题3个瓶子换1瓶水+1个空瓶子，两...

全排列（回溯法），LeetCode 46,47 ，剑指offer 271. 无重复的整数，全排列import java.util.ArrayList;import java.util.List;public class LC46 { public List<List<Integer>> permuteUnique(int[] nums) { ...

LeetCode 136：给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。思路：采用异或来解决。a ^ b ^ a = a ^ a ^ b = 0 ^ b = bpublic class LC136 { public int singleNumber(int[] nums) { int res = 0; ...

给定一个非空数组，返回此数组中第三大的数。如果不存在，则返回数组中最大的数。要求算法时间复杂度必须是O(n)。示例一:输入: [1, 2]输出: 2解释: 第三大的数不存在, 所以返回最大的数 2 .示例二:输入: [2, 2, 3, 1]输出: 1解释: 注意，要求返回第三大的数，是指第三大且唯一出现的数。存在两个值为2的数，它们都排第二。注意点：最开始定义two和three时...

给定一个由正整数组成且不存在重复数字的数组，找出和为给定目标正整数的组合的个数。思路：dp[i] 表示和为 i 的组合数关系式：dp[ i ] = dp[ i - nums[0] ] + dp[ i - nums[1] ] + … dp[ i - nums[len-1] ] ，条件为 i >= nums[j]dp[0] = 1,dp[0]表示组成0，一个数都不选就可以了，所以dp[...

给定一个非空字符串 s 和一个包含非空单词列表的字典 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。思路：dp[i]表示从 0 到 i 能否拆分。状态转移方程为：dp[i] = s[j–>i] in wordDict and dp[j]。需要定义dp[0]为 true，因为如果字符串本身就在 wordDict 中，就不必看dp了，可以直接判断为 tr...

给定不同面额的硬币和一个总金额。写出函数来计算可以凑成总金额的硬币组合数。假设每一种面额的硬币有无限个。 amount表示需要凑成的金额public class LC518 { public int change(int amount, int[] coins) { if (coins == null) { return 0; }...

给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。示例 1:输入: coins = [1, 2, 5], amount = 11输出: 3解释: 11 = 5 + 5 + 1思路：假设有三种金额：2，3，7。dp[n]表示凑出金额n的最少硬币数量则 dp[n] = min ...

给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。输入: [1, 5, 11, 5]，输出: true，数组可以分割成 [1, 5, 5] 和 [11].public class test { public boolean canPartition(int[] nums) { int sum = 0; for (i...

给定一个非负整数数组，a1, a2, …, an, 和一个目标数，S。现在你有两个符号 + 和 -。对于数组中的任意一个整数，你都可以从 + 或 -中选择一个符号添加在前面。返回可以使最终数组和为目标数 S 的所有添加符号的方法数。思路：所有使用 ‘+’ 的数的和：sum（P）；所有使用‘-’的数的和：sum（N）则：sum（P） - sum（N） = target;则：sum...

数组优点：构建简单，能在O(1)的时间里根据数组下标来查询某个元素。缺点：构建时需要分配一段连续的空间，查询某个元素时需要遍历整个数组，耗费O(n)的时间。删除和添加元素同样需要耗费O(n)的时间。...

给定一个无序的整数数组，找到其中最长上升子序列的长度。（动态规划）示例:输入: [10,9,2,5,3,7,101,18]输出: 4解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。public class LC300 { public int lengthOfLIS(int[] nums) { if (nums.length == 0) { ...