arr

欢迎斧正 1、统计 int[] arr={1,4,1,4,2,5,4,5,8,77,88,5,4,9,6,2,4,1,5}中每个数字出现的次数 @org.junit.Test public void test(){ HashMap<Integer, Integer> hashMap=new HashMap<>(); int[] arr={1,4,1,4,2,5,4,5,8,77,88,5,4,9,6,2,4,1,5}; for (int i = 0; i < arr.length; i++) { if(hashMap.get(arr[i])==null){ hashMap.put(arr[i],1); }else { hashMap.put(arr[i],hashMap.get(arr[i])+1); } } Set<Integer> integers = hashMap.keySet(); for (Integer integer : integers) { System.out.println(integer+"出现"+hashMap.get(integer)+"次"); } } 2、小明和小红去书店买同一本书，小明带的钱差4.98元，小红差1分钱，他俩的钱合起来还不够，问小明带多少钱，小红带多少钱，书的定价是多少 String[] names = {"小明", "小红",

题目： 输入一个整数数组，判断该数组是不是某二叉搜索树的后续遍历的结果。如果是则返回true，否则返回false 思路： 后序遍历的特点，最后一个数字为树的根节点的值，数组中前边的数字可以分为两部分，第一部分是左子树的值，都比根节点小，第二部分都是右子树的值，都比根节点大 代码： public class TwentyFirst { public boolean whetherPostOrder(int[] arr){ if(arr == null){ return false; } return checkPostOrder(arr, 0, arr.length - 1); } public static boolean checkPostOrder(int[] arr, int start, int end){ //如果需要处理的数据只有一个或者没有数据要处理了，就返回true if(start >= end){ return true; } //从左到右找第一个不小于根节点的元素的位置 int index = start; while(index < end - 1 && arr[index] < arr[end]){ index ++; } //从第一个不小于根节点元素的位置一直到根节点的位置 int right = index; while(index < end - 1

1: 二维数组 ( 理解 ) (1) 元素是一维数组的数组。 (2) 格式： A: 数据类型 [][] 数组名 = new 数据类型 [m][n]; B: 数据类型 [][] 数组名 = new 数据类型 [m][]; m 表示这个二维数组有多少个一维数组 这一次没有直接给出一维数组的元素个数，可以动态的给出。 举例： int[][] arr = new int[3][]; arr[0] = new int[2]; arr[1] = new int[3] arr[2] = new int[1]; 　　　　 C: 数据类型 [][] 数组名 = new 数据类型 [][]{{...},{...},{...}}; D: 数据类型 [][] 数组名 = {{...},{...},{...}}; 举例： int[][] arr = {{1,2,3},{4,6},{6}}; 　　　　 注意： A: 以下格式也可以表示二维数组 a: 数据类型 数组名 [][] = new 数据类型 [m][n]; b: 数据类型 [] 数组名 [] = new 数据类型 [m][n]; B: 注意下面定义的区别 int x; int y; int x,y; int[] x; int[] y[]; int[] x,y[]; (3) 案例 ( 掌握 ): A: 二维数组的遍历 /* 需求：遍历二维数组 两个明确：

1: 方法 ( 掌握 ) (1) 方法：就是完成特定功能的代码块。 注意：在很多语言里面有函数的定义，而在 Java 中，函数被称为方法。 (2) 格式： 修饰符 返回值类型 方法名 ( 参数类型 参数名 1, 参数类型 参数名 2...) { 方法体语句 ; return 返回值 ; } 修饰符：目前就用 public static 。后面再详细讲解其他修饰符 返回值类型：就是功能结果的数据类型 方法名：就是起了一个名字，方便我们调用该方法。 参数类型：就是参数的数据类型 参数名：就是变量 参数分类： 实参：实际参与运算的数据 形参：方法上定义的，用于接收实际参数的变量 方法体语句：就是完成功能的代码块 return ：结束方法 返回值：就是功能的结果，由 return 带给调用者。 (3)两个明确： 返回值类型：结果的数据类型 参数列表：参数的个数及对应的数据类型 (4) 方法调用 A: 有明确返回值的方法 a: 单独调用，没有意义 b: 输出调用，不是很好，因为我可能需要不结果进行进一步的操作。但是讲课一般我就用了。 c: 赋值调用，推荐方案 B:void 类型修饰的方法 a: 单独调用 (5) 案例： A: 求和方案 /* 需求：求两个数据之和的案例 两个明确： 返回值类型： int 参数列表： 2个，都是int类型。 */ public static int sum

  之前把常见的那几种算法看了好几次，看的时候也手写了一遍，可是等到过了 好几天又给忘了，所以决定记录下来分享一下，也方便自己以后查看😁 冒泡排序   冒泡排序是属于交换排序的一种，通过比较 相邻的两个数据 然后进行交 换，冒泡排序的时间复杂度为o(n^2)。 function BubbleSort(arr) { for(let i=0;i<arr.length;i++){ for(let j=0;j<arr.length-i-1;j++){ if(arr[j]>arr[j+1]){ [arr[j],arr[j+1]]=[arr[j+1],arr[j]]; //交换值 } } } return arr; } 选择排序   选择排序是通过 记录下标 的方式进行比较的，定义变量（index）等于当前 下标(i)，循环当前下标后面的元素，如果后面的元素比当前元素大（或者小），先不着急 交换元素，只 替换下标 （下标交换），一次循环过后最小元素下标的位置可以确定，最 终交换当前元素（arr[i]）值和最小（或最大）下标(arr[index])的值。选择排序的时间复杂度为o(n^2) // 选择 function chooseSort(arr){ for(let i = 0;i<arr.length;i++){ let index = i; //记录当前元素下标 for(let j =i+1

Problem: 给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。 例如，给定数组 nums = [-1，2，1，-4], 和 target = 1. 与 target 最接近的三个数的和为 2. (-1 + 2 + 1 = 2). 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/3sum-closest Answer: 1、暴力解法:时间复杂度O(n^3),超出时间限制。 2、O(n^2)的解法: 先将数组排序,对于每一个i从0到n - 1，令left = i + 1，right = size - 1，为了寻找更接近target的三数之和， 若三数之和大于target则让right - 1，若三数之和等于target则返回target，若三数之和小于target则让left + 1。 设排序后的数组arr为a, b, c, d, e, f。 令arr[i] = a, arr[left] = b, arr[right] = f。 若a + b + f < target，则令left + 1，即arr[left] = c， b不再有与小于f的数（如e）组合的可能，但由于e < f，a + b

Array是Javascript的原生对象 构造函数 var arr=new Array() 参数可以是单个数字表示产生长度为几的数组，但各个成员的值都为空，如果是多个数字的话，就表示数组成员；也可以是字符串数组等。但如果参数是空位的话，就会读取到undefined，而且读取不到键名 实例： var arr = new Array(3); arr.length // 3 arr // [ empty x 3] 判断是否为数组 Array.isArray()返回一个布尔值，表示是否为数组，返回值为布尔值 var arr = [1, 2, 3]; Array.isArray(arr) // true 方法 1：valueOf()表示对该对象求值，返回数组本身 var arr = [1, 2, 3]; arr.valueOf() // [1, 2, 3] 2：toString()返回数组的字符串形式，数组变字符串 var arr = [1, 2, 3]; arr.toString() // "1,2,3" 3：push（）在数组的末端添加一个或者多个元素，并返回添加新元素的数组长度，会改变原来的数组 var arr = [1,2]; console.log(arr.push(3));//3---返回添加新元素后的数组长度 4：pop()删除数组的最后一个元素，并返回该元素

1. arr.push() 从数组的最后添加元素,返回值为添加后的数组长度 let arr = [3,2,1] arr.push(9) console.log(arr) // [3,2,1,9] 2. arr.pop() 从数组的最后删除一个元素,一次只能删除一个,返回值是删除的元素 let arr = [1,2,3,4] console.log(arr.pop()) // 4 console.log(arr) // [1,2,3] 3. arr.shift() 从数组最前面删除一个元素,一次只能删除一个,返回值是删除的元素 let arr = [1,2,3,4] console.log(arr.shift()) // 1 console.log(arr) // [2,3,4] 来源： https://www.cnblogs.com/beline/p/11330187.html

排序算法主要包括：冒泡排序、快速排序、希尔排序、插入排序、选择排序、堆排序、归并排序、基数排序、桶排序 （1）.冒泡排序： 比较相邻的元素。如果第一个比第二个大，就交换它们两个； 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数； 针对所有的元素重复以上的步骤，除了最后一个； 重复步骤1~3，直到排序完成。 　/** * 冒泡排序 * * @param array * @return */ public int[] bubbleSort(int[] array){ if(array.length==0) return array; int temp=0; for(int i=0;i<array.length;i++){ for(int j=0;j<array.length-i;j++){ if (array[j + 1] < array[j]) { temp = array[j + 1]; array[j + 1] = array[j]; array[j] = temp; } } } } （2）.快速排序 　　快速排序的原理：选择一个关键值作为基准值，比基准值小的在左边序列，比基准值大的在右边序列（一般左右都是无序的），一般选择序列的第一个元素。 　　一次循环：从后往前比较，用基准值和最后一个值比较，如果比基准值小的就交换位置

memset赋值赋的是ASSCII码转为二进制赋值 比如 memset(,0xff,sizeof()),0xff转为二进制11111111，int为4字节所以最后为11111111111111111111111111111111为-1。(化为二进制补位，然后再赋值)。 而OIER通常都希望能够通过memset赋给数组一个最大值 ## 如何定义这个无穷大 这个主要还是看数据范围。 如果直接用int最大值或者和最大值同位数的值作为无穷大的话 比如 2147483647 + 999 爆了int ， 它就会从我们定义的无穷大变成负无穷大，这不满足我们的期望。 所以到底该用什么来当这个 —— 无穷大 经常会看到大佬啊神犇啊会用： memset( , 0x3f , sizeof ); 特意去试了下，发现 0x3f3f3f3f 真的是个非常精巧的常量 他的十进制是 1061109567也就是10^9级别的（和0x7fffffff一个数量级），作为一个oier， 一般场合下的题目数据都是小于10^9的，所以它可以作为无穷大使用而不致出现数据大于无穷大的情形 因为0x3f3f3f3f的每个字节都是0x3f！所以要把一段内存全部置为无穷大，我们只需要memset(a,0x3f,sizeof(a))（memset按字节赋值）。 所以在通常的场合下，0x3f3f3f3f真的是一个非常棒的选择。