程序彤的博客

c借助temp，提前将数组中偶数找到除2，直接查是否有相同。（注意指针不能相撞，0的条件）//// Created by 李威彤 on 2022/2/22.//#include <stdio.h>#include <stdbool.h>bool checkIfExist(int* arr, int arrSize){ int i=0,j,temp; for ( i = 0; i < arrSize; ++i) { if (arr

递归迷宫回溯（自定义策略 下右上左）package 递归;public class 迷宫回溯 { public static void main(String[] args) { // 1代表隔板，2代表已走过 3代表无路可走 int map[][] = new int[8][7]; for (int i = 0; i < map[0].length; i++) { map[0][i] = 1;

带小括号的中转后缀表达式：1.初始化两个栈，运算符栈s1和中间结果栈s22.从左至右扫描中缀表达式3.遇到数字时，将其压入s24.遇到运算符时，比较当前运算符与s1栈顶运算符的优先级：①如果s1为空，或s1栈顶运算符为左括号（，则直接将此运算符入栈。②否则，若优先级比栈顶运算符高，也将运算符压s1③否则，将s1栈顶的运算符弹出并压入到s2中，再次从开始与s1中新的栈顶运算符相比较。5.遇到括号时：①如果是（，则直接压入s1.②如果是），则依次弹出s1栈顶运算符并压入s2中直到遇到（为止。

不带括号。package 栈.数组模拟栈.中缀计算器;public class Calculator { public static void main(String[] args) { String s = "22+4*2-1"; // 9 ArrayStack numStack = new ArrayStack(10); ArrayStack operStack = new ArrayStack(10); int num1 =

package 链表.单链表crud;public class SingleLinkedListDemo { public static void main(String[] args) { SingleLinkedList sll = new SingleLinkedList(); HeroNode heroNode1 = new HeroNode(1, "虚空掠夺者"); HeroNode heroNode2 = new HeroNode(2,

package 数组.稀疏数组;public class 稀疏数组 { public static void main(String[] args) { // 11*11二维数组，第2行第三列白子9号，第3行第4列黑子6号，将棋盘中的两子的位置和号数 整理到 稀疏数组中 int arr[][] = new int[11][11]; for (int i = 0; i < 11; i++) { for (int j =

卡牌数组思路：声明一个计数数组，可统计出重复数的个数，索引下标即为当前数是几，存放出现重复的总次数。将数组中出现的每个数的总次数放到list集合中。// 当前长度对从2开始的数取模，如果是0，即8%2=0 8%3 8%4=0 8%5 8%6 8%7 8%8=0取模为0（2/4/8）的就是8的公约数。当是公约数时，先默认为true，如果找到当前数不能整除从2开始的j，代表集合里有重复次数不同的数，直接返回false。 public static boolean hasGroupsSizeX(int

单调数列思路：定义一个标志位布尔值，他只可能是true或false，单调也只有两种情况，递增或递减，故return返回递增true的情况和递减false的情况。判断是否有序即可，如果true，递增情况，当前数小于下一个数才递增，如果当前数大于下一个数，则返回false。else中逻辑同上。最终遍历到数组末尾则一直符合条件才会遍历到最后，故返回true。 public static boolean isDandiao(int[] arr){ return isSort(arr,true)

矩阵的转置思路：2*3的不是方阵矩阵的存在，使得必须额外声明一个二维数组newArr[ n ][ m ]，原二维数组为arr[ m ][ n ]，只需让而额外的二维数组的第[ i ] [ j ]上的元素赋值给新的额外的二维数组的第[ j ][ i ]位置上。 public static int[][] method(int[][] arr){ int m = arr.length; int n = arr[0].length; int[][] new

最大分组的位置思路：定义初始出现数量为1，从左向右遍历，如果后一个和当前的字符不相同，紧接着立刻判断当前数量如果大于2,也就是大于等于3时，使用Arrays工具将自定义一个数组转换成集合保存在大集合嵌套的集合中。之后再将count数量置为1。如果当前字符和后一个字符相同，则count数量++。这里注意当遍历到最后一个字符时，就必须直接进入一个if判断。也就是最后一个字符没有下一个字符的特殊情况。故使用或连接。if(i==n-1 || s.charAt(i)!=s.charAt(i+1)) public

使用最小花费爬楼梯动态规划法：额外声明一个dp数组，用于存放每轮循环对应的一个位置上的最小花费（最优解）由于可以选择下标为0或1的位置作为起始楼梯，故dp数组中的第一个位置和第二个位置上的最小花费均为0，因为无需付出任何代价即能从这两个位置任意开始指针i从2即第三个位置开始，若想到达第三个位置，可以从第二个位置走一步到达，也可以从第一个位置走两步到达。但选择第一个位置还是第二个位置是需要根据这个位置上的花费数决定，哪个位置上的花费数更小，就选哪个位置。即当前dp[i]的最小花费为第前两步的最小花

至少是其他数字两倍的最大数思路：先一次遍历出最大数，记录其最大数值和最大数的下标。再次遍历数组，判断如果当前数不为最大数时并且当前数的两倍如果大于最大数值，则返回-1,其他数字的两倍大于了最大数，不满足题意。否则最终 返回最大数的下标 int maxN = 0; int n = arr.length; int maxI = 0; for (int i = 0; i < n; i++) { if (arr[i] > ma

数组的度 public static int findShortestSubArray(int[] nums) { HashMap<Integer, int[]> map = new HashMap<>(); int n = nums.length; for (int i = 0; i < n; i++) { if (map.containsKey(nums[i])) {

非递减数列思路：其实continue在某种程度上来看是多余的。但此处可深刻理解continue的妙用，若我当前不进入if循环，如果没有continue，则直接会return返回一个还没有判断的结果。而使用了continue后，for循环的i指针会后移，直到进入一次if判断后，之后才return返回结果。从一开始，令第一个数为x，第二个数为y，如果找到第一个数大于第二个数时，先将第一个数变成和第二个数相等的较小数，此时再判断数组是否递增有序。若无序则先复原将数组改回最初的状态样子，再将第i+1上的元素改

图片平滑器 public static int[][] method(int[][] met) { int R = met.length, C = met[0].length; int[][] ans = new int[R][C]; for (int r = 0; r < R; ++r) for (int c = 0; c < C; ++c) { int count = 0;

三个数的最大乘积思路：法1：先排序，取前两个数和最后一个数求乘积，取后三个数求乘积。两个乘积数取最大一个即可。法2：线性遍历，定义出第一小数，第二小数，第一大数，第二大数，第三大数。结果只有第一小数乘第二小数乘第一大数，与第一大数乘第二大数乘第三大数，两乘积作比较取最大。如果当前数比第一小数还小，则将原先第一小数赋值成第二小数，当前数成为真正的第一小数。不然如果当前数只是比第二小数小，则将当前数赋值成第二小数，原先的第二小数已经不是第二小数了。如果当前数比第一大数还要大，则将第二大数赋值给第三大

种花问题思路：将当前预期种植的位置数即为计数器，当满足一定条件后计数器减1，当计数器成0时就返回true。如果当前数是1，指针后移两位继续判断。若当前指针指向的下一个数是1（前提是当前指针只能小于数组长度-1，即最多只能指向倒数第二个数，否则会出现数组角标越界），则指针只前移1位，即情况为0,1,0时，当前指针指向i=0，但是i+1位置的数为1，则当前指针只前移1位，继续判断。 public static boolean method(int[] arr,int n){ int cou

最大连续1的个数 public static int method(int[] arr){ int n = arr.length; int curC=0; int maxC=0; int i = 0; while (i < n) { if (arr[i] == 1) { curC++; } if (arr[i] ==

第三大数 public static int method(int[] arr){ ArrayList<Integer> list = new ArrayList<>(); Arrays.sort(arr); for (int num : arr) { if (!list.contains(num)) { list.add(num); }

丢失的数字 public static int method(int[] arr){ Arrays.sort(arr); // 先排序 int st = 0; int en = arr.length-1; int n = arr.length; if (arr[st] != 0) { // 第一个数必须是0 return 0; } if (arr[en]!=n){ /

重新排列字符串数组的索引为按每个字符的ascii位置，对应的位置+1操作，最终比较两数组对应的ascii索引位置的值是否相等 public static boolean method(String a,String b){ // 为空和长度不同 if (a == null || b == null || a.length() != b.length()) { return false; } int[] arrA =

public List<String> summaryRanges(int[] nums) { int n = nums.length; int i = 0; ArrayList<String> list = new ArrayList<>(); while (i < n) { int low = i++; // 若在原数组上遍历，必须先++，再比较前一.

寻找重复元素 public static boolean method(int[] arr) { HashSet<Integer> hashSet = new HashSet<>(); for (int num : arr) { boolean isAdd = hashSet.add(num); // set集合中没有此元素才返回true if (!isAdd) { // 如果取反是false，则存在重

两数之和2（有序数组）二分查找： /** * 二分查找 * @param arr * @param target * @return */ public static int[] method(int[] arr,int target){ int n = arr.length; for (int i = 0; i < n; i++) { int searchNum = target-a

杨辉三角2 public static List<Integer> method1(int numsRows){ ArrayList<List<Integer>> resList = new ArrayList<>(); for (int i = 0; i <= numsRows; i++) { // 这里必须加等号，否则少遍历循环一轮 ArrayList<Integer> tempL

杨辉三角声明两个集合，一个存放结果集合（集合嵌套），另一个存放当前循环所处理的集合（每轮新创建），固定情况，每第一个数均为1，内层循环初始轮次均向当前处理集合先添加1；当外层轮次和内层循环变量值相等时，意味着当前轮次=当前集合长度，即遍历到当前集合末尾，其必为1。除此两种情况外，将结果集合的第i-1（从0开始）个集合中的第j-1与j（杨辉三角特质，前一行的前一值与当前值的和为下一行的当前值）相加。 public static List<List<Integer>> method

加一指针指向末尾，向前移动，当前数+1，若为10，证明需要进位，指针才向前移动，否则，返回仅加1后的结果。若尾指针遍历到最前边，证明必为全9情况，数组长度加1，令第一个数为1。 public static int[] method(int[] nums) { for (int i = nums.length - 1; i >= 0; i--) { nums[i]++; nums[i] = nums[i] % 10; // 如果

查找插入位置法一：返回即左指针。 public static int method2(int[] nums, int target) { int left = 0, right = nums.length - 1; while (left <= right) { int mid = (left + right) / 2; if (nums[mid] < target) { lef

移除元素public static int method0413(int[] nums,int val){ int slow = 0; for (int fast = 0; fast < nums.length; fast++) { if (nums[fast] != val) { // 如果相同，就先跳过；如果不同，就需要将下一个值赋给前一个位置（因为此时前一个值必定和val相同）

删除重复数，返回最终数组长度快慢指针，符合条件慢指针才前进，否则j每轮循环均前进class Solution { public int removeDuplicates(int[] nums) { if(nums.length==0){ return 0; } int i = 0; for(int j = 1;j<nums.length;j++){ if(nums[i]!=num

快速排序 public static void quickSort(int[] nums,int start,int end){ if (start > end) { return; } int index = partition1(nums,start, end); quickSort(nums,index+1,end); quickSort(nums,start,index-1);

根据二叉树创建字符串思路很好理解，关键是创新想出与代码实现。精髓1：栈与二叉树的结合，先序遍历先将右孩子压入栈（更前提是将根节点压入栈，确保根节点所对应的右闭括号在最后一个，反正最终是会截取首尾括号滴）精髓2：弹栈即意味添加右闭括号。精髓3：若集合中未出现当前栈窥探出的栈顶元素值，将其元素值add进集合中，同时追加"(val"。 public String method(TreeNode top) { Stack<TreeNode> stack = new Stac

反转字符串2精髓点1:步长为i+2k，即0，0+22,4+22。（0,4,当8时以退出循环）每2k为一组，反转一组中前半一组字符串。精髓点2:判断下标越界 i+k-1为一组字符中的最后一个字符，若有残留字符，实际这组残留字符中的“最后一个字符”根本不存在，此时i+k-1>n，必须让右指针指向n-1。 public static String method(String s, int k) { char[] ch = s.toCharArray(); int n

重复字符串String s = “ababcababc”;// 1-5// 10被1整除 match=true charAt(1)!=charAt(0) match=false break;// 10被2整除 match=true charAt(2)==charAt(0) charAt(3)==charAt(1) charAt(4)!=charAt(2) match=false break;// 10被5整除 match=true charAt(5)==charAt(0) char

赎金信public static boolean method(String smallStr,String bigStr){ int[] start = new int[26]; for (char small : smallStr.toCharArray()) { // small为char，为什么使用的是indexOf(int ch寻找的字符,int Fromindex开始寻找的位置)呢？ 因为小杯子可以放进大盒子。 int

回文数public static String method(String s){ String aeiou = "AEIOUaeiou"; int n = s.length(); int start = 0; int end = n-1; char[] chars = s.toCharArray(); while (start < end) { while (start

分别反转字符串的每一个新单词输入：“m’I gnivol twl”输出：“I’m loving lwt”默认起始字符位置为start=0，start指向初始i循环如果当前字符不为空格 i++，最后i指向第一个空格定义一个p指针指向start，代表每个新单词的初始位置。核心：计算每个单词的终末位置：start+i-1-p，因为在-p，若使p++，则从后向前依次append()如果i指针指向空格，则i++，此时i必为下一个新单词的起始位置。public static String metho