代码随想录——贪心

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量4k 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41433002/article/details/123847232
版权

题目来自《代码随想录》

文章目录

455. 分发饼干

https://leetcode-cn.com/problems/assign-cookies/

	/**
	 * 执行用时：7 ms, 在所有 Java 提交中击败了99.93%的用户
	 * 内存消耗：42.5 MB, 在所有 Java 提交中击败了12.66%的用户
	 * @param g 孩子胃口值
	 * @param s 饼干值
	 * @return 能够满足多少个孩子的胃口
	 */
	public int findContentChildren2(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        int start = 0;
        int count = 0;
        for (int i = 0; i < s.length && start < g.length; i++) {
            if (s[i] >= g[start]) {
                start++;
                count++;
            }
        }
        return count;
    }
	
	/**
	 * 1. 平什么版
	 * 执行用时：8 ms, 在所有 Java 提交中击败了23.59%的用户
	 * 内存消耗：42.1 MB, 在所有 Java 提交中击败了63.17%的用户
	 * @param g 孩子胃口值
	 * @param s 饼干值
	 * @return 能够满足多少个孩子的胃口
	 */
	public int findContentChildren(int[] g, int[] s) {
		int ans = 0;
		Arrays.sort(g);
		Arrays.sort(s);
		int ind = 0;
		System.out.println(s.length);
		for(int i=0; i<g.length; i++) {
			System.out.println("i=" + i + "，ind:" + ind);
			while(ind < s.length) {
				System.out.println("第" + i + "个孩子胃口：" + g[i] + "，第" + ind + "个饼干：" + s[ind]);
				if(g[i] <= s[ind]) {
					System.out.println("满足胃口" );
					ans++;
					ind++;
					System.out.println("满足后ind变为" + ind );
					break;
				} else {
					ind++;
					System.out.println("不满足后ind变为" + ind );
				}
			}
			if(ind == s.length) break;
		}		
		return ans;
	}

376. 摆动序列

https://leetcode-cn.com/problems/wiggle-subsequence/

	/*
	 * 碰到【0，0，0】输出就是2，不对
	 */
	public int wiggleMaxLength(int[] nums) {
		if(nums.length <=2) {
			if( nums.length == 2 && nums[0] == nums[1]) return 1;
			return nums.length;
		}
		int ans = 2;
		int pre = 0; //前一对差
		int next = 0; //下一个差
		for(int i=1; i<nums.length-1; i++) {//判断从第二个到倒数第二个
			pre = nums[i-1] - nums[i];
			next = nums[i] - nums[i+1];
			if((pre > 0 && next < 0) || (pre < 0 && next >0)) ans++;
		}
		return ans;
	}
	
	/*
	 * 正确答案
	 */
	public int wiggleMaxLength2(int[] nums) {
		if(nums.length <=1) return nums.length;
		int up = 1;
		int down = 1;
		for(int i=1; i<nums.length; i++) {
			if(nums[i]-nums[i-1] > 0) up = down+1;
			if(nums[i]-nums[i-1] < 0) down = up+1;
		}		
		return Math.max(up, down);
	}

53. 最大子数组和

https://leetcode-cn.com/problems/maximum-subarray/

	//当前连续和为负数时，立马放弃
	public int maxSubArray(int[] nums) {
		int ans = Integer.MIN_VALUE;
		int curans = 0;
		for(int i=0; i<nums.length; i++) {
			curans += nums[i];
			if(curans > ans) ans = curans;
			if(curans < 0) curans = 0;
		}		
		return ans;
	}

122. 买卖股票的最佳时机 II

一遍过，蔑视中等题

	/*
	 * 执行用时：1 ms, 在所有 Java 提交中击败了87.62%的用户
	 * 内存消耗：41.5 MB, 在所有 Java 提交中击败了11.16%的用户
	 */
	public int maxProfit(int[] prices) {
		int ans = 0;
		for(int i=1; i<prices.length; i++) {
			if(prices[i]-prices[i-1] > 0) ans+=prices[i]-prices[i-1];
		}		
		return ans;	
	}

55. 跳跃游戏

https://leetcode-cn.com/problems/jump-game/

  1. 递归思路
  2. 找能覆盖的最大面积
	public boolean canJump(int[] nums) {
		if(nums.length <= 1) return true;
		return digui(nums, nums.length-1);
	}

	public boolean digui(int[] nums, int s) {
		if(nums[0] >= s) {
			System.out.println("从第" + s + "格可以跳到起点");
			return true;
		}
		
		for(int i=s-1; i>=0; i--) {
			if(nums[i] >= s-i) {
				System.out.println("从第" + s + "格跳往第" + i + "格");
				return digui(nums, i);
			}
		}
		return false;
	}

45. 跳跃游戏 II

	/*
	 * 1. 从后往前遍历所有，这种递归会超时的
	 */
	LinkedList<Integer> path = new LinkedList<>();	
	
	int ans = Integer.MAX_VALUE;
	public int jump(int[] nums) {
		if(nums.length == 1) return 0;
		digui(nums, nums.length-1, 0);
		return ans;
    }
	
	public void digui(int[] nums, int s, int curstep) {
		if(nums[0] >= s) {
			curstep++;
			System.out.println("从第" + s + "格可以跳到起点，存入step为：" + curstep);
			if(curstep < ans) ans = curstep;
			path.add(curstep);
		}
		
		for(int i=s-1; i>=0; i--) {
			if(nums[i] >= s-i) {
				System.out.println("从第" + s + "格跳往第" + i + "格");
				digui(nums, i, curstep+1);
			}
		}
	}
	
	/*
	 * 2. 还是从后往前，不递归，每次只迈最大步。但这玩意效率也不高
	 * 执行用时：14 ms, 在所有 Java 提交中击败了24.58%的用户
	 * 内存消耗：42 MB, 在所有 Java 提交中击败了13.65%的用户
	 */

	public int jump2(int[] nums) {
		int ind = nums.length-1;
		int step = 0;
		while( ind > 0) {
			for(int i=0; i<ind; i++) {
				if(i+nums[i] >= ind) {
					ind = i;
					step++;
					break;
				}
			}
		}
		return step;
	}
	
	/*
	 * 3. 没有达到我上一次跳跃的最远距离，就不跳
	 * 这过程中储存下一次能跳的最远距离
	 * 达到我上一次跳的最远距离了，就跳，次数加一
	 * 执行用时：2 ms, 在所有 Java 提交中击败了44.78%的用户
	 * 内存消耗：42.1 MB, 在所有 Java 提交中击败了11.47%的用户
	 */
	public int jump3(int[] nums) {
		int res = 0;
		int cur = 0;//当前最远
		int next = 0; //下一步最远
		for (int i = 0; i <= cur && cur < nums.length - 1; ++i) {//在条约范围内
			next = Math.max(next, nums[i] + i);//这比的不是cur，比的是next
			if(i == cur) {
				cur = next;
				res++;
			}			
		}	
		return res;
	}

1005. K 次取反后最大化的数组和

	public int largestSumAfterKNegations(int[] nums, int k) {
        // 排序，把可能有的负数排到前面
        Arrays.sort(nums);
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            // 贪心：如果是负数，而k还有盈余，就把负数反过来
            if (nums[i] < 0 && k > 0) {
                nums[i] = -1 * nums[i];
                k--;
            }
            sum += nums[i];
        }
        Arrays.sort(nums);
        // 1. 如果k没剩，那说明能转的负数都转正了，已经是最大和，返回sum
        // 2. 如果k还剩偶数个就自己抵消掉，不用删减，
        // 3. 如果k还剩奇数个就减掉2倍最小正数。
        if( k%2 != 0) sum -= 2*nums[0];
        
        return sum;
	}

134. 加油站

https://leetcode-cn.com/problems/gas-station/

	/*
	 * 方法1：
	 * (1)如果gas和小于cost和，那就到不了(2)起点在gas和cost差最大的地方
	 * 答案错误！
	 * 如：gas = [5,8,2,8]， cost = [6,5,6,6]
	 */
	public int canCompleteCircuit(int[] gas, int[] cost) {
		int gassum = 0; // 能提供的汽油总和
		int costsum = 0; // 消耗的汽油总和
		int ans_index = 0; 
		int ans = 0;
		for(int i=0; i<gas.length; i++) {
			gassum += gas[i];
			costsum += cost[i];
			if( (gas[i]-cost[i]) > ans ) {
				ans = gas[i]-cost[i];
				ans_index = i;
			}
		}
		if( gassum < costsum ) ans_index = -1;
		return ans_index;
	}
	
	/*
	 * 方法2：
	 * 一直计算gas[i]-cost[i]的累加和，出现负数了，累加和置0，从下一位开始新的计算和记录
	 */
	public int canCompleteCircuit2(int[] gas, int[] cost) {
		int index = 0; //最终答案
		int tolsum = 0; //gas和-cost和
		int cursum = 0; //gas[i]-cost[i]的累加和，出现负数了，累加和置0
		
		for(int i=0; i<gas.length; i++) {
			tolsum += gas[i]-cost[i];
			cursum += gas[i]-cost[i];
			if( cursum < 0 ) {
				cursum = 0;
				index = i+1;
			}			
		}
		if( tolsum < 0) return -1;
		return index;
	}

135. 分发糖果

https://leetcode-cn.com/problems/candy/

	/*
	 * 一次是从左到右遍历，只比较右边孩子评分比左边大的情况。
	 * 一次是从右到左遍历，只比较左边孩子评分比右边大的情况。
	 */
	public int candy(int[] ratings) {
		int[] candy = new int[ratings.length];
		//1. 从左到右。右边比左边大，右边就加一。
		candy[0] = 1;
		for(int i=1; i<ratings.length; i++) {
			candy[i] = 1;
			if( ratings[i] > ratings[i-1]) {
				System.out.println(i + "位置上的值比" + (i-1) + "位置上的大");
				
				candy[i] = candy[i-1] + 1;
				System.out.println(i + "位置上的值加完1为" + candy[i]);
			}
		}		
		//2. 从右到左。左边比右边大，左边就加一
		//因为从左到右加过一次！所以要判断是从左边过来的大还是右边加一之后大！！
		for(int i=ratings.length-2; i>=0; i--) {
			if( ratings[i] > ratings[i+1]) {
				candy[i] = Math.max(candy[i], candy[i+1] + 1);
			}
		}		
		//3. 求和
		int ans = 0;
		for( int i: candy) {
			System.out.print(i + " ");
			ans += i;
		}
		return ans;
	}

860. 柠檬水找零

https://leetcode-cn.com/problems/lemonade-change/
一遍过

		/*
		 * 1. 10块的只能用5块的找
		 * 2. 20的：①10+5 ②5+5+5
		 * 注意这题是有顺序的，
		 */
	
	public boolean lemonadeChange(int[] bills) {
		int num5 = 0;
		int num10 = 0;
		int num20 = 0;		
		for(int i=0; i<bills.length; i++) {
			if( bills[i] == 5) num5++;
			if( bills[i] == 10) {
				if( num5 > 0) {//5块的够找10块的
					num5--;
					num10++;
				}else return false; //不够找，false
			}
			if( bills[i] == 20) {
				if( num10 > 0 && num5 > 0) {//1. 优先10+5的找
					num5--;
					num10--;
					num20++;
				}else if(num5 >= 3) {//2. 5块的有三张够找
					num5 -= 3;
					num20++;
				}else return false; // 都不够找，false
			}
		}	
		return true;
	}

406. 根据身高重建队列

https://leetcode-cn.com/problems/queue-reconstruction-by-height/

  1. 数组的sort
  2. 多维数组遍历
  3. 多维数组List之间转化
	public int[][] reconstructQueue(int[][] people) {
		// 身高从大到小排（身高相同k小的站前面）
        Arrays.sort(people, (a, b) -> {
            if (a[0] == b[0]) return a[1] - b[1];
            return b[0] - a[0];
        });
        int len = people.length;
        List<int[]> res= new ArrayList<>();
        for(int i = 0;i<len;i++){
            if (res.size() > people[i][1]){
                //结果集中元素个数大于第i个人前面应有的人数时，将第i个人插入到结果集的 people[i][1]位置
                res.add(people[i][1],people[i]);
            }else{
                //结果集中元素个数小于等于第i个人前面应有的人数时，将第i个人追加到结果集的后面
                res.add(res.size(),people[i]);
            }
        }
        return res.toArray(new int[len][2]);
	}

452. 用最少数量的箭引爆气球

https://leetcode-cn.com/problems/minimum-number-of-arrows-to-burst-balloons/

	//先排序，每有左边界超过上一个右边界的，答案加一
	public int findMinArrowShots(int[][] points) {
		if(points.length == 0) return 0;
        Arrays.sort(points, (p1, p2) -> p1[1] < p2[1] ? -1 : 1);
        int res = 1;
        int pre = points[0][1];
        for(int i=1; i<points.length; i++) {
        	if(points[i][0] > pre) {
        		res++;
        		pre = points[i][1];
        	}
        }   
        return res;
	}

435. 无重叠区间

https://leetcode-cn.com/problems/non-overlapping-intervals/

	//按右闭区间从小到大排序
	public int eraseOverlapIntervals(int[][] intervals) {
		if(intervals.length == 0) return 0;
		
		//得右边靠齐
        Arrays.sort(intervals, new Comparator<int[]>() {
            public int compare(int[] interval1, int[] interval2) {
                return interval1[1] - interval2[1];
            }
        });
        show(intervals);
        int res = 0;
        int pre = intervals[intervals.length-1][0];//最后一个的左区间
        System.out.println("最后一个区间的左为：" + pre);
        for(int i=intervals.length-2; i>=0; i--) {
        	if(intervals[i][1] > pre) {//当前右大于上一个左，重叠
        		System.out.println("倒数第" + (i+1) + "个区间的右后一个的左，即" 
        						+ intervals[i][1] + "大于" + pre);
        		res++;//答案加一，pre不变
        	}else{//当前左小于等于上一个左，没重叠
        		pre = intervals[i][0];//pre换人
        	}
        }   
        return res;
	}
	
	public void show(int[][] nums) {
		for(int i=0; i<nums.length; i++) {
			System.out.print("[");
			for(int j=0; j<nums[i].length; j++) {
				System.out.print(nums[i][j] + " ");
			}
			System.out.print("],");
		}
		System.out.print("\n");
	}
	
	//正解
    public int eraseOverlapIntervals2(int[][] intervals) {
        Arrays.sort(intervals, (a, b) -> {
            if (a[0] == a[0]) return a[1] - b[1];
            return a[0] - b[0];
        });

        int count = 0;
        int edge = Integer.MIN_VALUE;
        for (int i = 0; i < intervals.length; i++) {
            if (edge <= intervals[i][0]) {
                edge = intervals[i][1];
            } else {
                count++;
            }
        }

        return count;
    }

763. 划分字母区间

https://leetcode-cn.com/problems/partition-labels/

	public List<Integer> partitionLabels(String s) {
        List<Integer> list = new LinkedList<>(); //储存答案
        int[] edge = new int[26];
        char[] chars = s.toCharArray(); //统计每个字符出现的最后位置存入edge中
        for (int i = 0; i < chars.length; i++) {
            edge[chars[i] - 'a'] = i;
        }
        int idx = 0;//当前字符最远边界
        int last = -1;//已经分割出去的片段总长度片段长度
        for (int i = 0; i < chars.length; i++) {
        	//idx表示当前片段最小边界 = max（上个字符最远位置，当前字符最远位置）
            idx = Math.max(idx,edge[chars[i] - 'a']);
            if (i == idx) {//！！！如果当前字符最远位置和当前字符位置一样，得到答案
                list.add(i - last);
                last = i;
            }
        }
        return list;		
	}

56. 合并区间

https://leetcode-cn.com/problems/merge-intervals/
注意考虑最后一对有没有存进去

	public int[][] merge(int[][] intervals) {
		List<int[]> res = new LinkedList<>();
		Arrays.sort(intervals, (o1, o2) -> Integer.compare(o1[0], o2[0]));//按左边界从小到大排      
        show(intervals);
        //每有一个左小于上一个右，合并
        int l = intervals[0][0];//第一个左边界
        int r = intervals[0][1];//第一个右边界
        for(int i=1; i<intervals.length; i++) {
        	if(intervals[i][0] <= r ) {//如果左小于上一个右，l不变，r扩大
        		r = Math.max(intervals[i][1], r);//当前右和上一个右当中大的当新右
        	}else{//如果左大于上一个右，res.add，更新l r
        		res.add(new int[]{l, r});
                l = intervals[i][0];//更新左边界
                r = intervals[i][1];//更新右边界       		
        	}
        }
        res.add(new int[]{l, r});//最后一对没加，加一下
        return res.toArray(new int[res.size()][]);
	}

738. 单调递增的数字

https://leetcode-cn.com/problems/monotone-increasing-digits/

	/*
	 * 局部最优：遇到strNum[i - 1] > strNum[i]的情况，
	 * 让strNum[i - 1]--，然后strNum[i]给为9，可以保证这两位变成最大单调递增整数。
	 * 全局最优：得到小于等于N的最大单调递增的整数。
	 * 
	 */
	public int monotoneIncreasingDigits(int n) {
		if (n==0)return 0;
        char[] chars= Integer.toString(n).toCharArray();
        //start记录从第几位开始后面都是9了。一开始设置最大值是为了防止本身就是递增的
        int start=Integer.MAX_VALUE;
        for (int i=chars.length-1;i>0;i--){
            if (chars[i]<chars[i-1]){
                chars[i-1]--;
                start=i;
            }
        }
        StringBuilder res=new StringBuilder();
        for (int i=0;i<chars.length;i++){
            if (chars[i]=='0'&&i==0)continue;//防止出现09这样的情况
            if (i>=start){//到了start的位置，后面全都搞成9
                res.append('9');
            }else res.append(chars[i]);//在start之前该是啥是啥
        }
        return Integer.parseInt(res.toString());
	}

714. 买卖股票的最佳时机含手续费

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/

	public int maxProfit(int[] prices, int fee) {
		int sum = 0;
		int buy = prices[0] + fee;
		for(int i=0; i<prices.length; i++) {
			if( prices[i] + fee < buy) {//有更低的买入价，更新
				buy = prices[i] + fee;
			} else if(prices[i] > buy) {//如果我现在已经能赚钱了
				sum += prices[i] - buy; //先把肯定能赚到的这一部分加上
				buy = prices[i]; 
				//这样接下来有两种情况
				//1. 如果后面的价格比我卖出的buy高，我依然可以赚到这部分钱
				//2. 如果后面的价格低了，有更低的价格买入价会更新的，我们赚了就跑了，完美
			}
		}
		return sum;
	}

968. 监控二叉树

https://leetcode-cn.com/problems/binary-tree-cameras/

	/*
	 * 2. 该节点无覆盖0（无摄像），本节点有摄像头1，本节点有覆盖2（无摄像）。空结点当做有覆盖
	 * 后序遍历，从下往上，从叶子节点的爹开始安装摄像头
	 */
	
	public int count = 0;//记录摄像头个数
	public int minCameraCover(TreeNode root) {
		if( trval(root) == 0) count++; //如果答案是0，说明就一个根，答案++
		return count;
	}
	private int trval(TreeNode root) {
		// 1. 空节点，该节点有覆盖，返回2
		if (root == null) {
			System.out.println("当前结点为空，返回2");
			return 2;
		}
		//后序遍历树
		int l = trval(root.left);
		int r = trval(root.right);		
		// 2. 左右节点都有覆盖无摄像，那当前点是无覆盖无摄像的
		if (l == 2 && r == 2) {
			System.out.println("当前结点" + root.val + "的左右孩子都为空，返回0");
			return 0;
		}
		// 4. 左右有一个孩子没有覆盖，那就该装个摄像头了
		// 注意第一次错在这了！！！左右有一个是0的优先级很高！！先判断！！！
		if( l == 0 || r == 0) {
			System.out.println("当前结点" + root.val + "的左右孩子有一个是0，返回1");
			count++;
			return 1;
		}
		// 3. 左右有一个有摄像，不用放摄像了，本结点被覆盖了
		if( l == 1 || r == 1) {
			System.out.println("当前结点" + root.val + "的左右孩子有一个是1，返回2");
			return 2;
		}
		
		return -1;//走不到这的
	}
平什么阿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【代码随想录】-贪心专题
一舟的博客
01-18 1080
有一堆钞票，你可以拿走十张，如果想达到最大的金额，你要怎么拿？每次拿最大就是局部最优。做题的时候，只要想清楚 局部最优 是什么，如果推导出全局最优，其实就够了。上述过于理论化，在实际做题中，很难按照上面四部去逐步思考。
代码随想录——贪心算法
weixin_44479862的博客
09-18 203
代码随想录——贪心算法
代码随想录：贪心算法
互勉
04-16 295
i从0开始累加rest[i]，和记为curSum，一旦curSum小于零，说明[0, i]区间都不能作为起始位置，因为这个区间选择任何一个位置作为起点，到i这里都会断油，那么起始位置从i+1算起，再从0计算curSum。本题的思路就是从后向前遍历，当遇到前一位大于当前位的时候，让前一位减减，当前位变位9，例如当n=98时，9>8，则9变为8，当前位的8变为9，输出答案89。以上代码中，应注意index的使用，同时也应注意%的特性，一个数%另一个数，如a%b，则得值永远不会大于b，在0-(b-1)区间。
代码随想录--贪心--分饼干
weixin_56194193的博客
09-13 313
对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j]。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。
LeetCode第五题：Longest Palindromic Substring（c++）详解
WangHuanToBeBest
04-21 421
LeetCode：第五题 Longest Palindromic Substring Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000. Example 1: Input: “babad” Output: “bab” N...
代码随想录算法PDF.rar
08-06
《代码随想录》是一本深受程序员喜爱的算法学习书籍，尤其对于初学者来说，它提供了深入浅出的讲解和实战演练。这本书的核心是通过实际编程来帮助读者理解和掌握算法，提升编程技能，特别是C++语言的应用。在C++这个...
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux ...
代码随想录知识算法讲解PDF
10-26
代码随想录贪心算法知识，非常管用
代码随想录知识星球精华 最强⼋股⽂
04-28
代码随想录知识星球精华（最强⼋股⽂） 这份PDF总结了 代码随想录知识星球 的全部精华内容，覆盖了⼏乎程序员学习必备的内容。 知识星球⾥很多录友拿到了⼤⼚offer，包括科班 和 ⾮科班的，⽽他们的每⽇学习总结都是...
代码随想录 面试大厂必备八股文
07-03
《代码随想录》是众多程序员面试准备的重要参考资料，尤其对于目标是大厂的开发者来说，这本书中的“面试大厂必备八股文”更是不容忽视的内容。这里的“八股文”并非传统意义上的文学形式，而是指在编程面试中经常被...
实现NFA到DFA的转化（C语言）
zqsen的博客
04-30 7576
简单记录一下，自动机课上的一个实验，用C语言实现NFA到DFA的转化，使用的是子集构造法。 子集构造法相信大家都会，直接甩代码。 先是把NFA和DAF的转移表存储在数据结构里，这里用了二维字符数组，先是定义了一个struct onechar,用来当作转移表的一格，这让我这个程序简单了不少，但是局限性是真的多。所以程序的状态只能使用当个字符表示，且设置的最大状态集数量是20。 typedef struct onechar { char block[MAX_NUM];//用于存储一个20个字符的字符数组 }o
C语言malloc(n*sizeof(char))解析
weixin_44412982的博客
09-07 1904
基本结构 (char*）malloc(n*sizeof(char)) 举个例子 char *ch = (char*)malloc(sizeof(char)*(2*len+1)); //申请(2*len+1)*1个连续字节的空间，定义*ch，指向该连续空间的首地址(sizeof(char)=1) 上面的2len+1相当于n，然后需要申请啥类型的连续空间只要一一对应即可，如：sizeof(char)对应char，若是需要int型则对应做修改即可。 例如： int *a=(int *)malloc(n*si
【代码随想录】贪心算法专栏（java版本含注释）
码农研究僧的博客
05-05 1366
所谓的贪心算法，就是局部最优到全局最优 关于该算法的学习路线如下： 代码随想录的贪心算法路线
「代码随想录」精讲了18道力扣上贪心算法经典题目，总结了这些！
代码随想录
12-31 1077
> 今天是2020年的最后一天，今天也是贪心系列大总结的一天，那么就用贪心总结篇来准备结束2020年吧
跟着代码随想录练算法——贪心（JS）
pingting_的博客
07-26 669
贪心的本质是选择每一阶段的局部最优，从而达到全局最优。
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1090
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java内存模型
weixin_44267758的博客
07-19 766
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 739
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1310
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
《代码随想录知识星球-学习手册PDF：精华八股文，实用知识全覆盖》
《代码随想录-八股文 PDF》是一份全面总结了《代码随想录知识星球》的精华内容的PDF文件。该文件涵盖了几乎每位程序员在学习过程中必备的知识点。录友们在知识星球中的每日总结对于准备求职的程序员来说是必备的学习...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

平什么阿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值