qq_39579087的博客

二分如果一个排序数组中的元素互不相同，那么按照二分查找会返回目标元素的下标。如果有重复的元素，并且我们想得到第一个重复元素的下标，那么可以用如下代码： private int binarySearch(int[] nums, int target) { int l = 0, r = nums.length-1; while (l <= r) { int m = l + ((r-l)>>1);

这里就简单说一下步骤：先在所有边中选一条权值最小的检查这条边和结果集中的边是否构成了环，如果构成环，则回到第一步重新选择除这条边外权值最小的边；如果不构成环，那么将这条边加到结果集中重复上述过程直到所有的点都出现在结果集中用一个例子来理解：上图计算最小生成图的步骤如下：先选AC，AC并没有与结果集中的其他边(此时为空)构成环，因此将AC放到结果集中选CD，与结果集中的边(AC)不构成环，因此将CD放到结果集中选AB，同样不构成环，将AB放到结果集中选AD，此时与结果集中的边构成环(

这里主要记录一下时间复杂度为 O(数的位数) 的方法，原作者大神的解答在：https://leetcode-cn.com/problems/1nzheng-shu-zhong-1chu-xian-de-ci-shu-lcof/solution/mian-shi-ti-43-1n-zheng-shu-zhong-1-chu-xian-de-2/对于一个整数，它的位数是多少位呢？不妨举几个例子：如果是99，很显然，它是两位100，是三位可以用log10(m)，即以10为底，m为给出的数来表示一个数能

对数器时间复杂度是指常数操作的数量级，以冒泡排序为例：第一次在0 - n-1 范围内找一个最小的数和0位置的数交换，这个过程需要找n次，每次都需要执行取数、比较和交换三个常数操作，因此常数操作需要进行n次第二次在1 - n-1 范围内找一个最小的数和1位置的数交换，这个过程需要找n-1次，每次都需要执行取数、比较和交换三个常数操作，因此常数操作需要进行n-1次重复上述过程那么最后常数操作的次数是(n + n-1 + n-2 + … + 1)，这是等差数列，结果为：(n^2/2 + n/2)，

单纯的搜索二叉树并不能保证平衡，它的平衡性受制于输入数据，输入的顺序不好(1 2 3 4 5)会导致搜索二叉树变成一条线，这样的时间复杂度是O(n)下面是不同的平衡搜索二叉树AVL树最严格的平衡性，任何一个节点左子树和右子树高度差不超过1，意味着每插入一个数可能都要调整。以下两种树平衡性没有AVL树那么严格，只是在调整的时候策略不同。都能做到增删改查时间复杂度O(logn)，差的只是常数项红黑树SB树练习题 大楼轮廓给你一组数：(1,6,4) (2,4,3) (5,8,5) (7,10,2

LRU双向链表+哈希表class Node { String key; int value; Node pre; Node next; public Node(String key, int value) { this.key = key; this.value = value; }}class biLinkedList{ Node head; Node tail; public biLi

单调栈解决的问题：对于数组中的每一个数，可以找到这个数左面的最近的比他大的数和右面的最近的比他大的数。例子：3 1 4 2 5，对于1来说，左面距离他最近的且比他大的数是3，右面距离他最近的且比他大的数是4；对于4来说，左面距离他最近的且比他大的数没有，右面距离他最近的且比他大的数是5.如果用暴力法求，那么时间复杂度是O(n^2)，因为你要遍历数组中的每一个数，对于每次遍历，都对这个数的左侧与右侧再做一次遍历找到距离他最近的且比他大的值。而单调栈可以在O(n)内求解。理解：现有一数组：[3, 5,

窗口的加数与减数开始之前窗口的左右边界L和R都设为-1当R向右移动时，窗口中的元素也相应地增加；当L向右移动时，窗口中的元素也相应地减少。此外，在任何情况下，R和L都不能回退，L也不能大于R。窗口内的最大值由于窗口的L和R是可能随时变动的，因此窗口内的元素是不固定的，即最大值也是不固定的。你当然可以在每次窗口变动后遍历一下[L, R]来求最大值，但这样时间复杂度就是O(窗口的长度)。所以要使用一种新的方式来解决上述问题双端队列结构对于一组数，每次只在队列尾添加数据，同时要将队尾元素和

给你一个字符串，让你在末尾添加最少数量的字符，使得添加后的字符串为回文串关于这道题，可以用Manacher算法的思想来做。首先找到以给出的字符串最后一个字符结尾的最长回文串，然后从头开始，遇见最长回文串的开头就停止，将这段字串逆序贴在整个字符串的末尾就是答案，举个例子：假设给出的字符串是：abcxyzfzyx，可以看出以最后一个字符结尾的最长回文串是xyzfzyx，然后从字符串的头开始遍历，直到x的前一个位置，最后遍历得到的子串为abc，将abc逆序为cba贴在给出的字符串后面即为答案：abcxyz

这里就不从头说了，只说一下自己的一些理解关于next数组next数组是KMP算法的核心，下面记录一下自己的理解。假设已经求出了第i-1个位置的前缀和后缀，如上图的两个红色的圈，现在要求第i个位置的最长相同前缀和后缀，该如何求呢？可以这么想，既然i-1位置的最长相同前缀和后缀是两个红色的圈，那么如果第k个位置的值等于第i-1个位置的值，就说明第i个位置的最长前缀和后缀是i-1位置的最长前缀和后缀数+1，所以要分两种情况考虑：k位置的值和i-1位置的值相同，那么i位置的最长前后缀为i-1位置最长前

对于给出的字符串，从根节点出发，如果能复用边就复用，不能就弄一条新边。但这种结构查询bef的时候会判定be也是给出的字符串，但其实be只是由构建bef附带着得到的，因此用如下结构更好：在每个节点上附加一个值，表示有多少字符串是以到目前为止的字符串结尾的，对于上例来说，e和f之间的节点为0就代表没有字符串以be结尾。上述结构能够找到都有哪些字符串被添加进来了，但无法知道以某段字符串为前缀的字符串有哪些，例如我们不知道有多少字符串以be为前缀。因此在每个节点上再添加一个值，代表此节点被经过了多少次，见.

并查集的功能：查询：两个元素是否在同一个集合中合并：两个元素各自所在的集合合并概念先不介绍了，网上资料很多时间复杂度：设数据量为N，那么只要查询与合并的次数整体逼近了O(N)及以上，平均每次的的时间复杂度为O(1)练习题这题正常做的话其实不难，递归就可以，主要思路是每次找到值为1的位置就开始递归，并将遍历到的值为1的位置置为2，这样做是防止下次又递归到上次的位置，代码如下：public class Island { private int count; public

相同的输入得到相同的结果，不同的输入得到的结果在大样本的情况下在[0, HashSize]内是均匀分布的。推论： 对于若干输入，哈希函数将他们变换后，在结果集上是均匀分布的，那么对每一个变换的值都mod M，则这些结果在[0, M-1]内也是均匀分布的。一个快速获得多个不相关哈希函数的方法：先调用一个哈希函数，将它返回的结果，比如说16位。拆成两半，即前八位和后八位，然后按照下面的方式：h1 + 1 * h2h1 + 2 * h2h1 + 3 * h2…即可得到若干个互不相关的哈希函数。

关于二叉树的递归遍历就不写了，这里介绍一下非递归方式二叉树的非递归遍历二叉树结构如下： public static class Node { public intvalue; public Node left; public Node right; public Node(int value) { this.value = value; }先序需要按照根-左-右的方式遍历。所以将根节点压入栈后，先输出它的值。接着看看根节点有无右子树，如果有则把右节

用数组实现栈index表示向栈中压入一个数时的数组下标，即新来的数的位置下标就是index，之后index+1；同理当出栈时，先将index–然后再输出栈顶元素。public class ArrayStack { private Integer[] arr; private Integer index; public ArrayStack(int initSize) { if (initSize < 0) { throw new I

#include<stdio.h>#include<malloc.h>#include<time.h>#define MAX 10void swap(int a[],int pos1, int pos2){ int temp = a[pos1]; a[pos1] = a[pos2]; a[pos2] = temp;}void Heap_Adjust(int a[], int pos, int len){ int max

#include<stdio.h>#include<time.h>/*和插入排序类似思想是先设一个跳数(通常为: step / 3 + 1)，把一组数据分成多组，对多组分别进行插入排序然后缩小跳数，再次重复上述步骤直至跳数为1，也就是对所有数据进行一次插入排序（因为经过前面的操作，全体数据已变的基本有序），从而缩短时间*/#define MAX 10void Shell_sort(int a[], int length){ int step = le

#include<stdio.h>#include<malloc.h>#include<time.h>#define MAX 10int* Creat_Array(){ int* arr = (int *)malloc(sizeof(int) * MAX); srand((unsigned int)time(NULL)); for (int i = 0; i < MAX; i++) { arr[i] =

#include<stdio.h>#include<time.h>/*这是一种不稳定的排序算法，即两个相同元素的相对位置发生了改变：6 2 2 3*/#define MAX 10void Quick_sort(int a[], int start, int end){ if (start >= end) { return; } int i = start; int j = end; int t

#include<stdio.h>#include<time.h>/*和冒泡相似，只不过减少了交换次数大致思想是：先选定一个位置，比如说0，然后依次向后遍历，如果发现某个位置的值比0小，那么先不交换，而是用一个变量temp保存下来，接着向后走，这样一趟下来可以找到数组中最小元素的下标，将其与位置0元素交换，如此第一轮循环后便可将最小的元素放到0号位置。*/#define MAX 10void swap(int *a, int *b){ int temp

#include<stdio.h>#include<time.h>/*效率高的情况：1. 数据基本有序2. 元素个数小 */#define MAX 10void Insert_sort(int a[], int length){ for (int i = 1; i < length; i++) { int j; if (a[i] < a[i-1]) { int

冒泡排序(升、降及其改进)#include<stdio.h>#include<time.h>#define MAX 10void swap(int *a, int *b){ int temp = *a; *a = *b; *b = temp;}void Bubble_sort_descend(int arr[], int length){ for (int i = 0; i < length; i++) {

完全背包问题感谢这些朋友们的文章，给了我很大启发：https://blog.youkuaiyun.com/songyunli1111/article/details/94778914https://blog.youkuaiyun.com/na_beginning/article/details/62884939https://blog.youkuaiyun.com/qq_39445165/article/details/84...

0-1背包问题感谢这些朋友们的文章，给了我很大启发：https://blog.youkuaiyun.com/songyunli1111/article/details/94778914https://blog.youkuaiyun.com/na_beginning/article/details/62884939https://blog.youkuaiyun.com/qq_39445165/article/details/8...

多重背包问题感谢这些朋友们的文章，给了我很大启发：https://blog.youkuaiyun.com/songyunli1111/article/details/94778914https://blog.youkuaiyun.com/na_beginning/article/details/62884939https://blog.youkuaiyun.com/qq_39445165/article/details/84...