weixin_52514567的博客

package 省份;public class Group { public static void main(String[] args) { // TODO Auto-generated method stub System.out.println(getProvince(new int[][]{{1,1,0},{1,1,0},{0,0,1}}));//2 System.out.println(getProvince(new int[][]{{1,0,0},{0,1,0},{0,0.

package 贪心;import java.util.Arrays;public class MaxSanJiao { public static void main(String[] args) { // TODO Auto-generated method stub System.out.println(MaxS(new int[]{5,7,20,4,6,9} )); } private static int MaxS(int[] a) { // TODO Auto-.

这道题的大概意思是 商家本省没有钱 只靠顾客来找钱假如第一个顾客 给了5块钱 现在商家就有了五块钱 第二个顾客来买水喝 除了20的找不开 5 ，跟10都能找开 本题的贪心策略就在于 找20 的时候 只用一张五块的跟一张十块的就能找开了 不用三张五块的局部最优解 不影响其他的解package 贪心;public class LeamonChange { //柠檬水找零 贪心算法 public static void main(String[] args) { // .

贪心算法的定义：贪心算法是指在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，只做出在某种意义上的局部最优解。贪心算法不是对所有问题都能得到整体最优解，关键是贪心策略的选择，选择的贪心策略必须具备无后效性，即某个状态以前的过程不会影响以后的状态，只与当前状态有关。解题的一般步骤是：1.建立数学模型来描述问题；2.把求解的问题分成若干个子问题；3.对每一子问题求解，得到子问题的局部最优解；4.把子问题的局部最优解合成原来问题的一个解。package 贪心;p.

广度优先遍历的思想 就是先入队列在 出队列 这样就解决了 不能分层遍历的情况package tree;import java.util.LinkedList;import java.util.Queue;import tree.TreeDeep.TreeNode;//广度优先遍历 从上到下遍历 要想逐层遍历 就要把节点放到队列去 先进先出 这样就能逐层便利了public class TreeNode2 { public static void main(String[]..

package tree;public class TreeDeep { public static void main(String[] args) { // TODO Auto-generated method stub TreeNode treeNode7=new TreeNode(7,null,null); TreeNode treeNode6=new TreeNode(6,treeNode7,null); TreeNode treeNode5=new TreeNode(5,

package tree;public class BinaryTreeNode { private Object data; //数值域 private BinaryTreeNode parent;//父节点 private BinaryTreeNode lChild; private BinaryTreeNode rChild; private int height;//当前节点的高度 private int size;//当前节点的节点个数 //根据数据创造一个节点

这道题用的思想是拉窗算法 长度为4 移动一格 加上下一格 减去第一格package suanfa.Max;public class AvgArray { public static void main(String[] args) { System.out.println(findMax(new int[]{1,12,-5,-6,50,3},4)); } private static double findMax(int[] num, int k) { // TODO Aut.

Java的set集合就是不能放相同的东西 刚好利用这一点package suanfa.Max;import java.util.HashSet;import java.util.Set;public class Double { //内部类 public static class ListNode{ ListNode next; int val; public ListNode(int val,ListNode next){ this.val=val; t

我们人脑自己判别优先顺序，以及得到后缀表达式后，在计算机中是如何的实现可以看一下我以前写的这篇文章当给一个中缀表达式以后，计算机是如何实现转为后缀的呢

package feibo;public class FeiDoubleZhen { public static void main(String[] args) { // TODO Auto-generated method stub System.out.println(DoubleZhen(10)); } public static int DoubleZhen(int num){ int low=0; int high=1; int sum=0;.

package feibo;public class Fei { public static void main(String[] args) { // TODO Auto-generated method stub System.out.println(cansoul(10)); System.out.println("+++++++++"); System.out.println(calculate(10)); } static int cansoul(int nums..

双指针算法package suanfa.Max;import java.util.Arrays;import java.util.HashMap;import java.util.Map;public class Test { public static void main(String[] args) { // TODO Auto-generated method stub System.out.println(Arrays.toString(soult(new int[]{1.

public static int[] soult(int nums[],int target){ //二分查找 for(int i=0;i<nums.length;i++){ int low=i;//定义low为最小值 int hight=nums.length-1; int mid=low+(hight-low)/2; while(low<=hight){ if(nums[mid]==target-nums[i]){ retu.

package suanfa.Max;import java.util.Arrays;import java.util.HashMap;import java.util.Map;public class Test { public static void main(String[] args) { // TODO Auto-generated method stub System.out.println(Arrays.toString(soult(new int[]{1,2,3,6.

package suanfa.Max;public class MaxProduct { public static void main(String[] args) { System.out.println(getMaxMin(new int[]{1,3,-1,-3,4,2})); } private static int getMaxMin(int[] nums) { // TODO Auto-generated method stub int min1=Integer.MAX.

牛顿迭代简单来说就是不断递归的过程话不多说直接上代码后面解释原理float my_sqrt(float number) { float new_guess; float last_guess; if (number < 0) { printf("Cannot compute the square root of a negative number!\n"); return -1; } new_guess =

不熟悉二分查找的复习一下二分查找二分查找详细分析package suanfa.快慢指针;public class binarySerach { public static void main(String[] args) { System.out.println(binarySerach(25)); } public static int binarySerach(int x){ int index=-1; int righ.

package suanfa.快慢指针;import java.util.Arrays;public class DoubleZhen { //返回中间元素的下标 public static void main(String[] args) { System.out.println(new int[]{1,6,5,8,4,3,5}); } public static int xiaobiao(int[] nums){ /*//jdk1.

public class MyArrayQueue {public Object[] elements;private static final int DEFAULT_CAPACITY=8;public int front;public int size;public int rear;public MyArrayQueue(){ elements=new Object[DEFAULT_CAPACITY];}public int getSize(){ return size;}

初学者在学习数据结构的时候总是考虑问题不太全面，上限，下限，容量空间，值的正负等问题那么 在这里 我将介绍一种简单的数组扩容的方法希望对你有帮助对数组进行初始化 大致分为三步：private Object[] elements; //初始化数组private static final int DEFAULT_CAPACITY=16; //初始化容量private int top; //栈顶指针第一步：定义新的数组，是默认数组的两倍大（这样方便）第二步：遍历旧数组，把值赋给新数组第

什么是双指针算法呢双指针算法概念因为这题给了限定 有序，O（1） 不能改变数组换成新的 所以用快慢指针就行package suanfa.快慢指针;/** * 因为这题给了限定 有序，O（1） 不能改变数组换成新的 所以用快慢指针就行 */public class ZhiZhen { public static void main(String[] args) { System.out.println(DoubleZhen(new int[]{1,2,2,3,.

什么式埃式筛选：简单来说 就是把素数的倍数筛选出去 比如2式素数 2的倍数都不是素数 2 4 6 8或者 23=6 24=8 等等直接去掉 这要就不用重复查找了package suanfa.统计个数;import java.util.Scanner;public class erato { // public static int bf(){ Scanner scanner = new Scanner(System.in); int

在我们平时用的最多的算法 就是暴力算法了这里在键盘上输入一个数字返回素数的个数要知道什么素数：除了1和他本身 没有别的除数就是素数 也就是 i%j！=0 就是素数 这里去掉了0和他本身代码package suanfa.统计个数;//暴力算法 这里也可以用双重for循环 都是一样的道理import java.util.Scanner;public class baoLi { // public static int bf(){ Scanner

如果从第一个节点开始的话 他的head的next是2节点 2节点的next是三节点这样 我们把2节点的next指向头节点 这样不是不就是控制了反转了吗？还有一个问题需要考虑 虽然 head.next.next =head 是头节点但是head.next的值还是第二个节点 所以 把 head.next=null 这样就不会 死循环了这就是本题的核心解法但是 这这样就找不到 第三个节点了呀所以 我们从最后一个节点开始找怎样获取最后一个节点了 递归的思想 如.

package java.link;import javax.swing.*;//用iterate控制链表反转 第一种public class LinkIterate { //定义静态内部类 定义一个节点 static class ListNode{ public int value; //节点的值 public ListNode next; //指针指向下一个节点 public ListNode(int value,.