ybw

leetcode算法笔记

汉明距离两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。给出两个整数 x 和 y，计算它们之间的汉明距离。示例:输入: x = 1, y = 4输出: 2解释:1 (0 0 0 1)4 (0 1 0 0) ↑ ↑上面的箭头指出了对应二进制位不同的位置。class Solution { public int hammingDistance(int x, int y) { int xor=x^y;

常见的数据结构可分为「线性数据结构」与「非线性数据结构」具体为：「数组」、「链表」、「栈」、「队列」、「树」、「图」、「散列表」、「堆」。一、数组数组是将相同类型的元素存储于连续内存空间的数据结构，其长度不可变。// 初始化一个长度为 5 的数组 arrayint[] array = new int[5];// 元素赋值array[0] = 2;array[1] = 3;array[2] = 1;array[3] = 0;array[4] = 2;//或者可以使用直接赋值的初始化方

/** * 插值查找算法 * mid=(left+right)/2=left+(right-left)/2 * mid=left+(right-left)-(findVal-arr[left])/(arr[right]-arr[left]) */public class InsertValueSearch { public static void main(String[] args) { int[] arr = new int[100]; for (int

/** * 使用二分查找的前提是该数组是有序的 */public class BinarySearch { public static void main(String[] args) { //测试一 int[] arr = {1, 8, 10, 89, 1000, 1000, 1234}; int resIndex = binarySearch(arr, 0, arr.length - 1, 123); System.out.p

public class SeqSearch { public static void main(String[] args) { int[] arr = {1, 9, 11, -1, 34, 89}; int index = seqSearch(arr, -11); if (index == -1) { System.out.println("没有查找到"); } else { Sys

/** * 基数排序(radix sort) O(nk) * 1、将所有待比较数值统一为同样的数位长度，数位较短的数前面补零， * 然后，从最低位开始，依次进行一次排序，这样从最低位排序一直到 * 最高位排序完成以后，数列就变成一个有序序列 */public class RadixSort { public static void main(String[] args) { int[] arr = {53, 3, 542, 748, 14, 214};

/** * 归并排序 * O(nlog2^n） */public class MergetSort { public static void main(String[] args) { int[] arr = {8, 4, 5, 7, 1, 3, 6, 2};//merge 7 int[] temp = new int[arr.length]; mergeSort(arr, 0, arr.length - 1, temp);

/** * 快速排序 * 时间复杂度：O(nlog2^n） * <p> * 快速排序式对冒泡排序的一种改进，基本思想是： * 通过一趟排序将要排序的数据分割成独立的两部分， * 其中一部分的所有数据都比另一部分的所有数据要小， * 然后再按此方法对这两部分数据分别进行快速排序， * 整个排序过程可以递归进行，以此达到整个数据变成有序序列 */public class QuickSort { public static void main(String[] a

/** * 希尔排序 * 插入排序的改进 */public class ShellSort { public static void main(String[] args) { //1、测试希尔排序 int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0,}; shellSort2(arr); System.out.println(Arrays.toString(arr)); //

public class InsertSort { public static void main(String[] args) { //1、测试排序 System.out.println("测试一:"); int[] arr = {101, 34, 119, 1, -1, 999}; insertSort(arr); System.out.println(Arrays.toString(arr));

/** * 选择排序 * 1、选择排序共有n-1轮排序 * 2、每一轮排序，又是一个循环 * <p> * 2.1先假定当前这个数是最小数 * 2.2然后和后面的每个数进行比较，如果发现有比当前数更小的数，就重新确定最小数，得到下标 * 2.3当遍历到数组的最后时，就得到本轮最小数和下标 * 2.3交换 */public class SelectSort { public static void main(String[] args) { //1、测试

/** * 排序算法 Sort Algorithms * <p> * 1、内部排序： * 插入排序（直接插入排序O(n^2)，希尔排序O(nlog2^n））， * 选择排序（简单选择排序O(n^2)，堆排序O(nlog2^n））， * 交换排序（冒泡排序O(n^2)，快速排序O(nlog2^n））， * 归并排序，O(nlog2^n）, * 基数排序O(log2^n) * <p> * 2、外部排序 * <p> * 算法的时间复杂度 * 常数阶&l

public class Queue8 { int max = 8;//表示共有多少个皇后 int[] array = new int[max];//保存皇后放置位置的结果 static int count = 0; public static void main(String[] args) { //测试 Queue8 queue8 = new Queue8(); queue8.check(0); Sy..

说明：//使用递归回溯来给小球找路1、map表示地图2、i,j表示从地图的哪个位置开始出发（1，1）3、如果小球能到map[6][5]位置，则说明路找到4、约定：当map[i][j]为0表示该点没有走过，1表示墙，2表示通路，3、表示该点已经走过，但是走不通5、在走迷宫时，需要确定一个策略，下-右-上-左public class MiGong { public static void main(String[] args) { //二维数组模拟迷宫 in

/** * 递归 * <p> * 递归就是方法自己调用自己，每次调用时传入不同的变量， * 递归有助于编程者解决复杂的问题； * <p> * 递归需要遵守的重要规则： * 1、执行一个方法时，就创建一个新的受保护的独立空间（栈空间） * 2、方法的局部变量时独立的，不会相互影响 * 3、如果方法中使用的时引用类型变量（数组），就会共享该引用类型的数据。 * 4、递归必须向退出递归的条件逼近，否则就是无线递归了 * 5、当一个方法执行完毕，或者遇到return，就

/** * 中缀表达式转后缀表达式 * 1+((2+3)*4)-5 -> 1 2 3 + 4 * + 5 * * <p> * 1）初始化两个栈：运算栈s1和储存中间结果的栈s2; * 2)从左至右扫描中缀表达式； * 3）遇到操作数时，将其压入s2； * 4）遇到运算符时，比较其与s1栈顶运算符的优先级； * <p> * 1.如果s1为空，或栈顶运算符为左括号“（”，则直接将次运算符入栈； * 2.否则，若优先级比栈顶运算符的高，也将运算符压入s1;

/** * 前缀表达式 * 3+4）*5-6对应的前缀表达式就是-*+3456 * <p> * 从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时， * 弹出栈顶的两个数，用运算符对它们做相应的计算，并将结果入栈； * 重复上述过程直到表达式式最左端，最后运算得出的值即为表达式的结果 * <p> * 例如：（3+4）*5-6对应的前缀表达式就是-*+3456，针对前缀表达式求值步骤如下： * <p> * 1）从右至左扫描，将6、5、4、3压入

/** * 使用栈完成表达式的计算思路 * <p> * 1、通过一个index值，来遍历我们的表达式 * 2、如果我们发现是一个数字，就直接入数栈 * 3、如果扫描到的是一个符号，就分如下情况 * <p> * 3.1、如果发现当前的符号栈为空，就直接入栈 * 3.2、如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或者 * 等于栈中的操作符，就需要从数栈中pop出一个符号，进行运算， * 将得到的结果入数栈，然后将当前的操作符入符号栈， * 如果当前

/** * 用数组模拟栈 * 栈是一个先入后出(FILO-First In Last Out)的有序列表 * 插入和删除只能在线性表的一端进行的一种特殊线性表， * 允许插入和删除的一端为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底（Bottom） */public class ArrayStackDemo { public static void main(String[] args) { ArrayStack arrayStack = new Arr

/** * Josephu问题为：设编号为1，2，...n的n个人围坐一圈，约定编号为k(1<=k<=n)的人从1开始报数， * 数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依此类推， * 直到所有人都出列为止，由此产生一个出队编号的序列。 * <p> * 假如： n=5.即有5个人 * k=1，从第一个人开始报数 * m=2，数2下 * 出圈顺序为：2，4，1，5，3 * <p> * 步骤： * 1、先创建一个辅助指针hel

/** * 双向链表增删改查 * 单向链表查找的方向只能是一个方向，而双向链表可以向前或者向后查找 * 单向链表不能自我删除，需要辅助节点，而双向链表可以自我删除， */public class DoubleLinkedListDemo { public static void main(String[] args) { System.out.println("测试双向链表"); //先创建节点 HeroNode2 hero1 = new H

/** * 1、链表是以节点的方式来存储，链式存储。 * 2、每个节点包含data域，next域：指向下一个节点。 * 3、链表的各个节点不一定连续存储。 * 4、链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定。 */public class SingleLinkedListDemo { public static void main(String[] args) { //先创建节点 HeroNode hero1 = new HeroNode

/** * 队列是一个有序列表，可以用数组或是链表来实现。 * 先入先出 */public class CircleArrayQueueDemo { public static void main(String[] args) { System.out.println("测试数组模拟环形队列"); CircleArray queue = new CircleArray(4);//队列的有效数据最大时3 char key = ' ';

/** * 稀疏数组 * row col val * * * * * * * * * * * * * <p> * 第一行存储的 有多少行 和多少列 第三个代表有多少值 * <p> * 二维数组转稀疏数组： * 1、遍历原始的二维数组，得到有效数据的个数sum * 2、根据sum就可以创建稀疏数组sparseArr int[sum+1][3] * 3、将二维数组的有效数据存入到稀疏数组 * <p> * 稀疏数组转原始的