Leetcode
夜飞霜
这个作者很懒,什么都没留下…
展开
-
剑指Offer 56
[1,2,10,4,1,4,3,3]使用位运算,首先将数组所有元素异或运算,因为想x^x=0;所有最后的结果为只出现一次的两个数的异或结果,例:2^10;然后选取这两个数中一个位置相同值不同的值,例:2 :10, 10: 1010,其结果为1000。计算方法为,2^10结果莫一位结果为1的值x:1000然后使用x与数组相与,判断是否为0 ,以此将数组分为两部分,其中一部分包含10,另一部分包含2[1,2,4,1,4,3,3], [10],分别对这两个数组进行异或运算即为结果...原创 2021-04-23 10:57:34 · 83 阅读 · 0 评论 -
剑指Offer 52
方法一:使用两个栈,将两个链表进栈,出栈时,选最后一个相同的节点public class Solution { public ListNode getIntersectionNode(ListNode headA, ListNode headB) { Stack<ListNode> stack_1 = new Stack<>(); Stack<ListNode> stack_2 = new Stack<>();原创 2021-04-21 15:45:52 · 76 阅读 · 0 评论 -
剑指Offer 51
使用归并排序class Solution { public int reversePairs(int[] nums) { if(nums.length <= 1) return 0; int i = 0; int k = 1; int sum = 0; while(k < nums.length){ sum += gb(nums, i, k); if(i原创 2021-04-21 15:20:26 · 53 阅读 · 0 评论 -
剑指Offer 48
设置初始位置为0,记录出现的字符,每次出现已经被记录的字符时,使用此时的下标到初始位置的距离与最大值比较,大于则替换,并更改初始位置为上一次此字符的位置class Solution { public int lengthOfLongestSubstring(String s) { Map<Character, Integer> hashmap = new HashMap<>(); int sum = 0, index = 0;原创 2021-04-20 14:45:24 · 64 阅读 · 0 评论 -
剑指Offer 47
因为只会向右向下移动,所有从左到右,从上到下遍历棋盘,更新每个位置的值为可能最大值(加上右或者上位置的值)注意边界位置class Solution { public int maxValue(int[][] grid) { int m = grid.length; int n = grid[0].length; for(int i = 1; i < n; i++) grid[0][i] += grid[0][i原创 2021-04-16 16:07:52 · 47 阅读 · 0 评论 -
剑指Offer 46
动态规划将数值变为字符串,依次遍历,每次遍历字符时,观察其前面一个字符的值例如:xxxx12xxxx 当遍历到2时,dp(xxxx)和dp(xxxx1)的结果已知,则dp(xxxx12) =dp(xxxx) +dp(xxxx1),因为其可以有两种表达形式xxxx1 2和xxxx 12xxxx27xxxx 当遍历到7时,dp(xxxx)和dp(xxxx1)的结果已知,则dp(xxxx27) =dp(xxxx1),因为其表示形式只能是xxxx2 7,不存在xxxx 2...原创 2021-04-16 11:20:05 · 530 阅读 · 0 评论 -
剑指Offer 45
首先将数字变为字符串然后进行排序,自定义排序规则:字符串X,Y进行排序时比较X + Y < Y + X ? (X,Y) : (Y,X)class Solution { public String minNumber(int[] nums) { String[] strs = new String[nums.length]; for(int i = 0; i < nums.length; i++){ strs[i] = St原创 2021-04-16 10:37:13 · 50 阅读 · 0 评论 -
剑指Offer 44
首先确定,n 所对应的是几位数(如xxxx),然后确定第一个1000的起始位置m,然后使用(n - m) / 4(位数) + 1000,确定是哪一个确定的数,并用 4 -(n - m) % 4记录这个数从后往前第几位注:注意整型的内存范围,可以使用long代替class Solution { public int findNthDigit(int n) { if(n <= 9) return n; long m = n ++; lon.原创 2021-04-14 16:07:15 · 63 阅读 · 0 评论 -
剑指Offer 43
将函数用 get(num)表示则可以分为3种情况:1. 2xx 表示为2 * get(99) + 100 + get(xx) 其中 2 * get(99)为200以下个位和十位数值的1的个数和 100表示百位数值(100 ~ 199) get(xx) 表示201 到 2xx 之间个位和十位的1个数和2. 1xx 表示为1 * get(99) + (xx + 1) + get(xx) 同上 (xx + 1)表示百位数值1的个数3. 0xx 表示为 get(x...原创 2021-04-14 11:33:08 · 182 阅读 · 0 评论 -
剑指Offer 42
贪心算法:每次累加求和,当之前数据的和是小于0时,就不计算之前的和,和从0开始计算并在当和大于最大值时,更新最大值class Solution { public int maxSubArray(int[] nums) { int sum = nums[0]; int max = sum; for(int i = 1; i < nums.length; i++){ if(sum < 0)原创 2021-04-14 09:42:18 · 90 阅读 · 0 评论 -
剑指Offer 40
使用优先队列,将非负数变为非正数存储,结果变成非负数class Solution { public int[] getLeastNumbers(int[] arr, int k) { if(k == 0) return new int[0]; int[] nums = new int[k]; Queue<Integer> queue = new PriorityQueue<>(); for(int i =原创 2021-04-07 15:40:13 · 123 阅读 · 0 评论 -
剑指Offer 39
方法一:随机选择一个数,遍历整个数组看这个数是否是众数class Solution { public int majorityElement(int[] nums) { int number = nums.length; int num = 0; int item = -1; while(num <= number / 2){ item = nums[(int)(Math.random() * n原创 2021-04-07 15:11:54 · 59 阅读 · 0 评论 -
剑指Offer 38
首先将字符串变为字符数组并排序使用递归,在每次递归中,遍历字符数组中没有做标记的元素,加到字符串中,并将字符数组的元素做标记,递归,并在递归结束时,撤销标记,并删除字符串最后一个元素;注:考虑字符数组中有相同元素当字符数组所有元素均做了标记以后就将字符串加入字符串数组class Solution { List<String> str_s; char[] new_s; StringBuilder res; public String[] perm原创 2021-04-07 12:01:23 · 90 阅读 · 0 评论 -
剑指Offer 37
序列化:使用队列储存每个节点反序列化:使用队列和指针,指针指向队列首节点的左子树,然后指针向后移动一次,指针指向队列首节点的右子树,出队列并指针+1,此时指针又指向队列首节点的左子树;队列只存储有值得树public class Codec { // Encodes a tree to a single string. public String serialize(TreeNode root) { if(root == null) return "[]";原创 2021-04-07 11:18:28 · 115 阅读 · 0 评论 -
剑指Offer 36
中序遍历,使用两个指针,一个指针指向元素最小的节点(头节点),另一个指针指向当前遍历的节点(尾节点)class Solution { Node start = null; Node end = null; public Node treeToDoublyList(Node root) { if(root == null) return root; dfs(root); end.right= start; start原创 2021-04-02 15:26:47 · 83 阅读 · 0 评论 -
剑指Offer 35
使用HashMap存储原链表中每个节点的位置遍历两次,第一次仅仅依靠next 复制链表第二次,依靠HashMap建立random链接class Solution { public Node copyRandomList(Node head) { if(head == null) return null; Map<Node, Integer> hashmap = new HashMap<>(); List<No原创 2021-04-02 14:44:58 · 115 阅读 · 0 评论 -
剑指Offer 33
使用递归,传递的参数为数组左右边界,右边界即为跟节点,数组前半部分值必小于跟节点所对应的值,数组后半部分值必大于根节点指。固从后往前遍历,找到第一个小于跟节点的值,且之前的所有值均是小于根节点指的,否则就二叉搜索树的后序遍历结果。并以此为边界分割数组(既分割为左右子树)class Solution { public boolean verifyPostorder(int[] postorder) { return dfs(postorder, 0, postorder.le原创 2021-04-01 15:24:12 · 62 阅读 · 0 评论 -
剑指Offer 32
用队列储存每个不为空的节点class Solution { public int[] levelOrder(TreeNode root) { if(root == null) return new int[]{}; Queue<TreeNode> queue = new LinkedList<>(); List<Integer> list = new ArrayList<>(); q原创 2021-04-01 14:26:32 · 55 阅读 · 0 评论 -
剑指Offer 31
方法一使用栈和指针,首先指针为入栈的第一个位置i,当出栈为莫一个值时,说明入栈队列在这个值之前的所有值均入栈,因此将此值在入栈队列对应的下标j到指针i中的所有下标[1, j)入栈。更新指针i = j + 1;注;此时就j > i;若i > j, 表明,j对应值已经入栈,之间将其与栈的顶元素相比较,不相同则返回false;class Solution { public boolean validateStackSequences(int[] pushed, int[] pop原创 2021-04-01 11:09:08 · 85 阅读 · 0 评论 -
剑指Offer 29
一层一层遍历,每一层顺时针遍历四边class Solution { public int[] spiralOrder(int[][] matrix) { int m = matrix.length; if(m == 0) return new int[]{}; int n = matrix[0].length; if(n == 0) return matrix[0]; int dp = 0; int原创 2021-03-30 17:30:07 · 112 阅读 · 0 评论 -
剑指Offer 28
递归,判断左子树的左子树与右子树的右子树是否相同,左子树的右子树与右子树的左子树是否相同class Solution { public boolean isSymmetric(TreeNode root) { if(root == null) return true; return dfs(root.left, root.right); } private boolean dfs(TreeNode root_left, TreeNode roo原创 2021-03-30 16:51:07 · 108 阅读 · 0 评论 -
剑指Offer 27
交换左右子树class Solution { public TreeNode mirrorTree(TreeNode root) { if(root == null) return root; TreeNode left = root.left; root.left = mirrorTree(root.right); root.right = mirrorTree(left); return root; }原创 2021-03-30 16:42:31 · 97 阅读 · 0 评论 -
剑指Offer 26
分成两部第一步在A树中寻找与B根节点值相同的节点;第二步比较A树中是否包含B树结构class Solution { public boolean isSubStructure(TreeNode A, TreeNode B) { if(B == null) return false; return isSub(A, B); } private boolean isSub(TreeNode A, TreeNode B){ i原创 2021-03-30 16:38:33 · 57 阅读 · 0 评论 -
剑指Offer 25
注意,可能存在空链表使用头节点数值小的作为需返回的链表将另外一个链表的节点加入需返回的链表class Solution { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { if(l1 == null) return l2; if(l2 == null) return l1; if(l1.val > l2.val){ ListNode item原创 2021-03-30 16:21:53 · 58 阅读 · 0 评论 -
剑指Offer 24
递归,使用全局变量表示当前的尾节点class Solution { ListNode start; public ListNode reverseList(ListNode head) { if(head == null) return head; if(head.next == null) { start = head; return head; } ListNode no原创 2021-03-30 16:10:06 · 48 阅读 · 0 评论 -
剑指Offer 22
双指针,两个指针间隔K个节点,当前面的指针为空时,另一个指针既为答案class Solution { public ListNode getKthFromEnd(ListNode head, int k) { ListNode left = head; for(int i = 0; i < k; i++) left = left.next; ListNode right = head; while(l原创 2021-03-30 15:50:41 · 67 阅读 · 0 评论 -
剑指Offer 21
双指针,一个指针指向(前面需保存奇数的位置),另一个指针每次+1,当次指针所指数字为奇数时,就与另一个指针所指位置的元素互换class Solution { public int[] exchange(int[] nums) { int i= 0; for(int j = 0; j < nums.length; j++){ if(nums[j] % 2 == 1){ int item = nums[i原创 2021-03-30 15:36:47 · 88 阅读 · 0 评论 -
剑指Offer 20
需要考虑多种情况1. 字符串两边有多余的空格2. 小数可以没有整数部分或者小数部分3. e(E)前面必须包含整数或者小数4. 注意边界class Solution { public boolean isNumber(String s) { int i = 0; int len = s.length(); //去除两边的空格 if(len == 0) return false; while(s.ch原创 2021-03-30 15:32:35 · 49 阅读 · 0 评论 -
剑指Offer 19
运用动态规划,创建二维数组,表示dp[i][j] 表示 s前i个字符与,p中前j个字符 相匹配的结果考虑特殊字符*:如果p[j] = '*',dp[i][j] =dp[i][j - 2],如果s[i -1]==p[j-1]或者p[j-1]='.',则dp[i][j] =dp[i - 1][j] |dp[i][j - 2];例:s="aaa",p="a*""aaa"与"a*"是否想匹配,可以由"aa"与"a*","aaa"与"a"相匹配决定,而"aa"与"a*"是否匹配,也可以由"a"与...原创 2021-03-29 17:59:25 · 137 阅读 · 0 评论 -
剑指Offer 17
判断节点的下一个节点是否为空或节点下一个节点 的值是否等于给定值class Solution { public ListNode deleteNode(ListNode head, int val) { if(head == null) return head; if(head.val == val) return head.next; ListNode node = head; while(node.next != null &原创 2021-03-29 15:25:37 · 51 阅读 · 0 评论 -
剑指Offer 17
遍历class Solution { public int[] printNumbers(int n) { n = (int)Math.pow(10, n) - 1; int[] number = new int[n]; for(int i =0; i < n; i ++) number[i] = i + 1; return number; }}原创 2021-03-29 14:59:23 · 42 阅读 · 0 评论 -
剑指Offer 16
快速求幂求幂的时候不用一次一次相乘,可以每次平方,并将幂除以2例如:具体来说2的10次方,可以变换为:4的5次方4 * 4的4次方4 * 16的2次方4 * 256的一次方class Solution { public double myPow(double x, int n) { if(n == 0) return 1.0; //直接负最小值,变换成正最大值会出错,范围不一样 long new_n = n原创 2021-03-29 12:10:49 · 98 阅读 · 0 评论 -
剑指Offer 15
简单的位运算即可public class Solution { public int hammingWeight(int n) { int sum = 0; for(int i = 0; i < 32; i++){ sum += n & 1; n >>= 1; } return sum; }}原创 2021-03-27 11:58:46 · 101 阅读 · 0 评论 -
剑指Offer 14
所以大于3的整数,其拆分过后的乘积最大值,都可以是全由2,3组成,例:5 = 2 + 3;2 * 3 > 56 = 3 + 3, 2 + 2 + 2; 3 * 3 > 6,2 * 2 * 2 > 6所以运用动态规划num[i] = max(num[i - 3] * 3, num[i - 2] * 2);class Solution { public int cuttingRope(int n) { if(n == 2) return 1;...原创 2021-03-27 10:22:47 · 64 阅读 · 0 评论 -
剑指Offer 13
n = 81 2 3 4 5 6 7 8 * 2 3 4 5 6 7 82 3 4 5 6 7 8 * * 3 4 5 6 7 83 4 5 6 7 8 * * *4 5 6 7 8.....8 * * * * * * * *2 3 4 5 6 7 83 4 5 6 7 84 5 6 7 8.....不存在 1 2 31 true false true2 true true true此种结构,(2,1)的...原创 2021-03-27 10:02:10 · 90 阅读 · 0 评论 -
剑指Offer 12
深度优先,向四个方向遍历class Solution { int number_n, number_m, number_k; public boolean exist(char[][] board, String word) { number_n = board.length; if (number_n == 0) return false; number_m = board[0].length; number_k =原创 2021-03-25 16:30:57 · 50 阅读 · 0 评论 -
剑指Offer 11
从后往前遍历,寻找第一个非递减的值class Solution { public int minArray(int[] numbers) { int size = numbers.length; for (int i = size - 1; i > 0; i--) if (numbers[i] < numbers[i - 1]) return numbers[i]; return numbers[0];原创 2021-03-25 16:14:28 · 46 阅读 · 0 评论 -
剑指Offer 10
简单的动态规划即可,需要注意结果的范围class Solution { public int fib(int n) { if(n < 2) return n; int start = 0; int end = 1; for(int i = 2; i <= n; i++){ int item = start + end; start = end; e原创 2021-03-25 15:44:38 · 50 阅读 · 0 评论 -
剑指Offer 9
使用两个栈来代替队列,其中一个栈实现代替队列的入操作,另外一个栈代替队列的出操作。当需要出队列时,出栈为空,就将入栈的所有值移动到出栈,然后以出栈代替出队列;两个栈均为空,则返回-1;class CQueue { Stack<Integer> stack_push, stack_pop; public CQueue() { stack_push = new Stack<>(); stack_pop = new Stack<原创 2021-03-25 15:35:37 · 88 阅读 · 0 评论 -
剑指Offer 7
前需遍历的结果将中序遍历分为了两部分,如第一部分数量为i,对应前序遍历除第一个的前i个,第二部分数量为j,则对应前序遍历的后j个public class Offer_7 { Map<Integer, Integer> hashmap = new HashMap<>(); public TreeNode buildTree(int[] preorder, int[] inorder) { int len = preorder.length;原创 2021-03-25 14:48:14 · 99 阅读 · 0 评论