搜索[Tree-like算法]结果-低调大师优秀个人博客

精选列表

搜索[Tree-like算法]，共10000篇文章

一文带你全面了解限流算法

漏桶算法和令牌桶算法在思想上非常接近，而实现方向恰好相反，它们有如下的相同和不同之处：令牌桶算法以固定速率补充可以转发的请求数量（令牌），而漏桶算法以固定速率转发请求；令牌桶算法限制数量的是预算数，

2020-07-19

聊聊对称加密、非对称加密、Hash算法

、3DES、Blowfish、IDEA、RC4、RC5、RC6和AES 常用的对称加密算法： AES、DES 优点：生成密钥的算法公开、计算量小、加密速度快、加密效率高、密钥较短缺点：一方面：双方共同的密钥

2020-05-27

每日一博 | 无监督学习算法

无监督学习算法就是无监督的一种学习方法，太抽象，有一种定义（这种定义其实不够准确，无监督和监督之间界限模糊）是说如果训练集有标签的就是有监督学习，无标签的就是无监督，没有标签，意味着不知道结果。

2020-04-12

2021算法岗基础技能树怎么点？

0 - 前言注：本文默认传统算法是所有工程师的基础技能，所以后面提到的算法主要指机器学习以及深度学习等算法。

2020-04-12

几种常用的排序算法之JavaScript实现

@[toc] 插入排序 <html> <script> /* 1）算法简介插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。

2020-03-17

OpenSSH 8.2 发布，禁用 ssh-rsa 算法

另一方面关于 SHA-1 哈希算法，此前该算法被发现构造前缀碰撞攻击成本已降至低于 5 万美元（实际为 4.5 万美元），因此开发团队决定禁用ssh-rsa 公钥签名算法。

2020-02-17

Dubbo源码解析实战 - 负载均衡算法LoadBalance

1 简介本篇尽量用一些简单的数学式子和流程图和大家一起梳理一下这些集群容错算法. 2 灵魂拷问谈谈dubbo中的负载均衡算法及特点最小活跃数算法中是如何统计这个活跃数的简单谈谈你对一致性哈希算法的认识

2019-11-23

Zstandard 1.4.4已经发布，这个版本包括一些主要的性能改进和新的 CLI 特性，内容如下： v1.4.3 v1.4.4 silesia.tar 1440 MB/s 1600 MB/s enwik8 1225 MB/s 1390 MB/s calgary.tar 1360 MB/s 1530 MB/s api：从解析器中提取序列以进行分析的新功能修复了 ZSTD_initCStream_advanced() 快速模式的性能 cli：支持管道命名 TAR 扩展支持 --output-dir-flat=DIE新命令将目标文件生成到请求的目录中 --stream-size=#和--size-hint=#新命令 --exclude-compressed新命令更快 -t 测试模式改进了一些错误信息修复字典生成器中的死锁条件 build：带有 Emscripten 编译脚本的单文件解码器修复 Visual Studio 上的 zlibWrapper 编译修复gcc 旧版本的编译改进了 cmake 脚本的安装目录 pack：更改了 pkgconfig，以便更好地集成到 OpenWRT 中详情见发布说明。

2019-11-08

彩票调度算法——让进程们拼手气？

这篇文章主要想介绍下彩票调度（个人觉得这个算法非常有意思~ ），还有随机算法相对传统算法的一点优势，毕竟现在绝大多数算法都是追求确定性，尤其在操作系统，大家都希望一切可控，所以随机算法的出现听起来有些“

2019-11-04

数据结构与算法之约瑟夫问题

约瑟夫问题介绍：据说著名犹太历史学家 Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始，越过k-2个人（因为第一个人已经被越过），并杀掉第k个人。接着，再越过k-1个人，并杀掉第k个人。这个过程沿着圆圈一直进行，直到最终只剩下一个人留下，这个人就可以继续活着。问题是，给定了和，一开始要站在什么地方才能避免被处决？Josephus要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，于是逃过了这场死亡游戏。编程描述: 有N个孩子手拉手围成一圈，从第M个孩子开始报数，报到第K个孩子出队，然后从下一个孩子继续开始报数，问：所有孩子的出队顺序？如下图：约瑟夫问题的数据结构引出：图 1-1：问：用什么数据结构来处理这个问题比较合适呢？我们不妨将图1-1稍作处理，如下图1-2：如果我们将每一个小人看人一个node节点，每一个节点都有一个指针指向下一个节点，我们很容易的就想到一种数据结构便是单向链表，如果我们将该单项链表的尾和首相连，将尾部指向首部便是图1-1了，便很适合解决该约瑟夫问题，于是我们可以使用单向环形链表数据结构来模拟解决该问题。数据结构的实现基础类如下：模拟孩子的类Child: class Child { private int no; private Child next; public Child(int no) { this.no = no; } public int getNo() { return no; } public void setNo(int no) { this.no = no; } public Child getNext() { return next; } public void setNext(Child next) { this.next = next; } } 模拟约瑟夫环的类CircleSingleLinkedList: class CircleSingleLinkedList { private Child head; public void init(int n) { //todo } public void show() { //todo } public void delete(int no) { //todo } } CircleSingleLinkedList的方法实现：初始化创建带有N个节点的约瑟夫环：分析：我们只要做到将上一个节点的next指向下一个节点，最后一个节点的next指向第一个即可 public void init(int n) { Child cur; if (n < 1) { return; } else if (n == 1) { child = new Child(1); child.setNext(child); } else { child = new Child(1); child.setNext(child); cur = child; for (int i = 2; i <= n; i++) { cur = cur.getNext(); Child cd = new Child(i); cur.setNext(cd); cd.setNext(child); } } } 2.打印约瑟夫环：分析：从头结点遍历每一个节点，当节点的getNext()==head时，便遍历结束了，相当于遍历到了最后一个 public void show() { if (head == null) { return; } if (head.getNext() == head) { System.out.println(head.getNo()); return; } Child cur = head; while (cur.getNext() != head) { System.out.println(cur.getNo()); cur = cur.getNext(); } System.out.println(cur.getNo()); } 3.为约瑟夫环增加一个节点到最后:分析：从头结点遍历到最后，将最后一个节点的next指向增加的节点，将增加的节点next指向头结点head即可 public void addLast(Child child) { Child cur = head; while (cur.getNext() != head) { if (cur.getNo()==child.getNo()){ throw new RuntimeException("编号已存在！！"); } cur = cur.getNext(); } if (cur.getNo()==child.getNo()){ throw new RuntimeException("编号已存在！！"); } cur.setNext(child); child.setNext(head); } 4.删除一个约瑟夫环的节点：遍历约瑟夫环，找到待删除节点的上一个节点，将上一个节点的next指向待删除节点的next即可，但是如果是删除的头结点，则需要将头结点的下一个节点指定为头结点 public void delete(int no) { if (head == null) { return; } Child cur = head; while (cur.getNext() != head) { if (cur.getNext().getNo() == no) { cur.setNext(cur.getNext().getNext()); return; } cur = cur.getNext(); } if (cur.getNext().getNo() == no) { cur.setNext(cur.getNext().getNext()); head = cur.getNext(); } } 至此约瑟夫环的数据结构及基础方法如下： class CircleSingleLinkedList { private Child head; public void init(int n) { Child cur; if (n < 1) { return; } else if (n == 1) { head = new Child(1); head.setNext(head); } else { head = new Child(1); head.setNext(head); cur = head; for (int i = 2; i <= n; i++) { cur = cur.getNext(); Child cd = new Child(i); cur.setNext(cd); cd.setNext(head); } } } public void addLast(Child child) { Child cur = head; while (cur.getNext() != head) { if (cur.getNo()==child.getNo()){ throw new RuntimeException("编号已存在！！"); } cur = cur.getNext(); } if (cur.getNo()==child.getNo()){ throw new RuntimeException("编号已存在！！"); } cur.setNext(child); child.setNext(head); } public void show() { if (head == null) { return; } if (head.getNext() == head) { System.out.println(head.getNo()); return; } Child cur = head; while (cur.getNext() != head) { System.out.println(cur.getNo()); cur = cur.getNext(); } System.out.println(cur.getNo()); } public void delete(int no) { if (head == null) { return; } Child cur = head; while (cur.getNext() != head) { if (cur.getNext().getNo() == no) { cur.setNext(cur.getNext().getNext()); return; } cur = cur.getNext(); } if (cur.getNext().getNo() == no) { cur.setNext(cur.getNext().getNext()); head = cur.getNext(); } } } 在约瑟夫环数据结构上解决约瑟夫问题我们从beginNo个孩子开始报数，每一次报readNum个数，则如何进行出队呢？分析：从第beginNo个孩子作为游戏的开始，就相当于移动约瑟夫环的头结点，将第beginNo个节点作为头结点。我们需要一个辅助指针来进行出队，该指针初始指向尾节点。报数相当于移动头结点和辅助指针，头结点到出队的那一个节点，将辅助指针的next指向头结点的next便完成了出队。然后将辅助指针的next作为头结点即可，直到只剩下最后一个节点。及头结点和辅助指针指向的节点是同一个接点。 public void josephPop(int beginNo, int readNum) { if (head == null) { return; } Child helper = head; while (true) { if (helper.getNext() == head) { break; } helper = helper.getNext(); } for (int i = 1; i < beginNo; i++) { head = head.getNext(); helper = helper.getNext(); } while (head != helper) { for (int i = 0; i < readNum - 1; i++) { head = head.getNext(); helper = helper.getNext(); } System.out.println(head.getNo()); helper.setNext(head.getNext()); head = helper.getNext(); } System.out.println(helper.getNo()); } 至此约瑟夫环及约瑟夫问题模拟如下： class CircleSingleLinkedList { private Child head; public void init(int n) { Child cur; if (n < 1) { return; } else if (n == 1) { head = new Child(1); head.setNext(head); } else { head = new Child(1); head.setNext(head); cur = head; for (int i = 2; i <= n; i++) { cur = cur.getNext(); Child cd = new Child(i); cur.setNext(cd); cd.setNext(head); } } } public void addLast(Child child) { Child cur = head; while (cur.getNext() != head) { if (cur.getNo()==child.getNo()){ throw new RuntimeException("编号已存在！！"); } cur = cur.getNext(); } if (cur.getNo()==child.getNo()){ throw new RuntimeException("编号已存在！！"); } cur.setNext(child); child.setNext(head); } public void show() { if (head == null) { return; } if (head.getNext() == head) { System.out.println(head.getNo()); return; } Child cur = head; while (cur.getNext() != head) { System.out.println(cur.getNo()); cur = cur.getNext(); } System.out.println(cur.getNo()); } public void delete(int no) { if (head == null) { return; } Child cur = head; while (cur.getNext() != head) { if (cur.getNext().getNo() == no) { cur.setNext(cur.getNext().getNext()); return; } cur = cur.getNext(); } if (cur.getNext().getNo() == no) { cur.setNext(cur.getNext().getNext()); head = cur.getNext(); } } public void josephPop(int beginNo, int readNum) { if (head == null) { return; } Child helper = head; while (true) { if (helper.getNext() == head) { break; } helper = helper.getNext(); } for (int i = 1; i < beginNo; i++) { head = head.getNext(); helper = helper.getNext(); } while (head != helper) { for (int i = 0; i < readNum - 1; i++) { head = head.getNext(); helper = helper.getNext(); } System.out.println(head.getNo()); helper.setNext(head.getNext()); head = helper.getNext(); } System.out.println(helper.getNo()); } } 测试创建一个5个节点的约瑟夫环，从第一个节点开始报数，每次报3个数，出队顺序如下： public static void main(String[] args) { CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList(); circleSingleLinkedList.init(5); circleSingleLinkedList.josephPop(1, 3); } 出队顺序为：3 1 5 2 4

2019-09-10

初探|Zookeeper基础之Paxos算法详解（一）

对于 zk 理论的学习，最重要也是最难的知识点就是 Paxos 算法。所以我们首先学习 Paxos 算法。

2019-09-05

算法：二叉树代码示例

二叉树特点左节点值小于根节点值，右节点值大于根节点 public class BinaryTree { private Node root; @Data private static class Node { private int data; private Node left; private Node right; public Node(int data){ this.data = data; } } public Node find(int key){ Node current = root; while(current != null){ if(current.data > key){ current = current.left; } if(current.data < key){ current = current.right; } if(current.data == key){ return current; } } return null; } public boolean insert(int data){ Node newNode = new Node(data); if(root == null){ root = newNode; return true; }else{ Node current = root; Node parent = null; while (current != null){ parent = current; if(current.data > data){ current = current.left; if(current == null){ parent.left = newNode; return true; } } else{ current = current.right; if(current == null){ parent.right = newNode; return true; } } } } return false; } public Node findMax(){ Node current = root; while(current != null){ current = current.right; } return current; } public Node findMin(){ Node current = root; while (current != null) { current = current.left; } return current; } //删除没有子节点的节点 public boolean delete(int key){ Node current = root; Node parent = current; boolean isLeft = false; while (current.data != key){ parent = current; if(current.data > key){ isLeft = true; current = current.left; }else { isLeft = false; current = current.right; } if(current == null){ return false; } } if(current.left == null && current.right == null){ if(current == root){ root = null; } if(isLeft){ parent.left = null; }else{ parent.right = null; } return true; } return false; } }

2019-08-05

smart-socket内存管理：首次适应算法

比较常见的内存管理算法有以下几种：首次适应算法（First-Fit）从空闲分区表的第一个表目起查找该表，把最先能够满足要求的空闲区分配给作业，这种方法目的在于减少查找时间。

2019-05-13

python实现顺序查找和哈希查找算法

顺序查找顺序查找是按照序列原有顺序对数组进行遍历比较查询的基本查找算法，顺序查找是最简单的搜索算法，其实现如下： defsequential_search(items,item): foriinitems

2019-04-20

C++实用编程——随机生成迷宫算法

2.随机生成算法： void init_maze(void); //初始化迷宫 void gotoxy(int x, int y); //移动光标 void path_up(int *x, int *y

2018-12-31

OpenCV中MeanShift算法视频移动对象分析

MeanShift算法Mean Shift是一种聚类算法，在数据挖掘，图像提取，视频对象跟踪中都有应用。OpenCV在图像处理模块中使用均值迁移可以实现去噪、边缘保留滤波等操作。

2018-12-18

言简意赅了解十大常见AI算法

基本假设是条件独立性决策树 decision tree 多分类，回归是一种分类和回归算法。

2018-10-23

逻辑回归模型算法研究与案例分析

训练算法: 大部分时间将用于训练，训练的目的是为了找到最佳的分类回归系数。测试算法: 一旦训练步骤完成，分类将会很快。

2018-09-05

【算法导论】最大子数组——暴力求解

1. 暴力方法求解最大子数组问题：求出所有子数组的和并比较； 2. 伪代码 FIND-MAXIMUM-SUBARRAY(A) max = -∞ for i = 1 to A.length sum = 0 for j = i to A.length sum += A[j] if sum > max max = sum low = i high = j return (low, high, max) 3. 代码实现 java public class MaxArray { private static class Result { int low; int high; int sum; public Result(int low, int high, int sum) { this.low = low; this.high = high; this.sum = sum; } } static Result findMaximumSubarray(int[] A){ int max = Integer.MIN_VALUE; int low = 0; int high = 0; for (int i = 0; i < A.length; i++) { int sum = 0; for (int j = i; j < A.length; j++) { sum += A[j]; if (sum > max) { max = sum; low = i; high = j; } } } return new Result(low, high, max); } } python 之前用切片其实也是暴力求解 def find_maximum_subarray1(nums): max_sum = -float('inf') result = {} for i in range(len(nums)): total = 0 for j in range(i, len(nums)): print(j) total += nums[j] if total > max_sum: max_sum = total result["low"] = i result["high"] = j result["sum"] = max_sum return result C语言 typedef struct { int low; int high; int sum; } result; result find_maximum_subarray(int arr[], int len) { int max = -((unsigned)(~0) >> 1); int low, high, i, j; for (i = 0; i < len; i++) { int sum = 0; for(j = i; j < len; j++) { sum += arr[j]; if (sum > max) { max = sum; low = i; high = j; } } } result re; re.low = low; re.high = high; re.sum = max; return re; }

2018-09-02

Python数据结构与算法——顺序表

概念在程序中，经常需要将一组(通常为同一个类型的)数据元素作为整体管理和使用，需要创建这种元素组，用变量记录它们，传进传出函数等(例如，Python中的列表)。一组数据中包含的元素个数可能发生变化(可以增加或者删除元素)。对于元素增删改查的需求，最简单的解决办法就是将这一组元素当做一个序列，用元素序列里的位置和顺序，表示实际应用中的某种有意义的信息，或者表示数据之间的某种关系。这样的一组序列元素的组织形式，即可抽象为线性表，一个线性表是某类元素的一个集合，还记录着元素之间的一种顺序关系。线性表是最基本的数据结构之一。根据线性表的实际存储方式，分为两种实现模型：顺序表：将元素顺序地存放在一块连续的存储区里，元素间的顺序关系由它们的存储顺序自然表示链表：将元素存放再通过链接构造起来的一系列存储块中顺序表的基本形式数据元素本身连续存储，每个元素所占的存储单元大小相同，元素的下标是其逻辑地址，而元素存储的物理地址(实际内存地址)可以通过存储区的起始地址加上逻辑地址与存储单元大小的乘积计算而得即： L0c(i) = L0 + i * c 作图解释为下： 1_note_shunxubiao.png 32位操作系统中，一个整型占用4个字节(Byte)，因此列表my_list中四个整型占用字节数为16个字节，且每个元素所占用字节数相同所以访问指定元素时无需从头遍历，通过计算便可获得对应地址，其时间复杂度为O(1). 顺序表的基本形式的特殊形式如果元素的大小不统一，则须采用元素外置的形式，将实际数据元素另行存储，而顺序表中各单元位置保存对应元素的地址信息(即链接)。由于每个链接所需的存储量相同，通过上述公式，可以计算出元素链接的存储位置，而后顺着链接找到实际存储的数据元素。此时公式中的 c 则不再是数据元素大小，而是存储一个链接地址所需的存储量。顺序表的结构不考虑用Python语言具体实现，真正实现数据表结构的时候，怎么构造数据 2_note_顺序表的结构.png 出了存储数据的数据区之外，往往还会加上表头信息表头信息即：上图中上面的部分下面部分为数据区 (连续的存储空间，内存的概念见后面的图解) 构造一个数据表的时候，首先要预估数据需要多少的空间，指明数据存储所需空间，即数据区。如上图中所示，即为8个数据。那么就要向计算机申请8个空间，在表头指明一个顺序表的完整信息包括两部分，一部分是表中的元素集合，另一部分是为实现正确操作而需记录的信息，即有关表的整体情况的信息，这部分信息主要包括元素存储去的容量和当前表中已有的元素个数两项。顺序表的两种基本实现方式一体式结构： 3_note_顺序表的两种实现方式一.png 一体式结构，存储表信息的单元与元素存储区以连续的方式安排在一块存储区里，两部分数据的整体形成一个完整的顺序表对象，这种结构整体性强，易于管理。由于数据元素存储区域是表对象的一部分，顺序表创建后，元素存储区就固定了分离式结构： 4_note_顺序表的两种实现方式二.png 分离式结构，表对象里只保存与整个表有关的信息(容量个元素个数),实际数据元素存放在另一个独立的元素存储区里，通过链接与基本表对象关联。元素存储区替换一体式结构由于顺序表信息区与数据区连续存储在一起，所以想要更换数据区，就只能整体搬迁，即整个顺序表对象(存储顺序表的结构信息的区域)改变了。分离式结构想要更换数据区，只需要将表信息区中的数据区链接地址更新即可，而该顺序表对象不变。元素存储区扩充采用分离式结构的顺序表，若将数据区更换为存储空间更大的区域，则可以在不改变表对象的前提下对其数据存储区进行了扩充，所有使用这个表的地方都不必修改。只要程序的运行环境还有空闲存储，这种表结构就不会因为满了而导致操作无法进行。此种顺序表被称为动态顺序表，因为其容量可以在使用中动态变化。扩充的两种策略每次扩充增加固定数目的存储位置，如每次扩充增加8个元素位置，这种策略称为线性增长每次扩充容量加倍，如每次扩充增加一倍存储空间。特点：减少了扩充操作的执行次数，但可能会浪费空间资源。以空间换时间，推荐的方式。补充：内存： 5_内存.png 思维导图 6_顺序表思维导图.png 顺序表的操作增加元素 7_顺序表的操作.png 尾端加入元素，如图所示，直接在顺序表的元素末尾加上元素，其时间复杂度为O(1) 保序的加入元素，如图所示，将增加的元素50，放在索引为1的位置，则对应的其他元素则分别向后移动，此为保序，没有破坏增加元素之前的元素顺序，但因会让增加元素所在位置之后的元素都产生移动，其时间复杂度为O(n) 非保序的加入元素,其时间复杂度为O(1)，由于其会破坏顺序表原有的元素顺序，因此不常用删除元素 8_顺序表的操作_删除元素.png ) 删除表尾的元素，其时间复杂度为O(1) 保序的元素删除，时间复杂度为O(n) 非保序的元素删除，时间复杂度为O(1) Python 中的顺序表 Python 中的list和tuple两种类型采用了顺序表的实现技术 tuple 是不可变类型，即不变的顺序表，因此不支持改变其内部状态的任何操作，而其他方面，则与list的性质类似 list 的基本实现技术 Python 标准类型list 就是一种元素个数可变的线性表，可以加入和删除元素，并在各种操作中维持已有元素的顺序(即保序)，而且还具有以下行为特征：基于下标(位置) 的高效元素访问和更新，时间复杂度是O(1); 为满足该特征，应该采用顺序表技术，表中元素保存在一块连续的存储区中。允许任意加入元素，而且在不断加入元素的过程中，表对象的标识不变；为满足该特征，必须能更换元素存储区，并且为保证更换存储区时list对象的标识不变，只能采用分离式实现技术。在Python的官方实现中，list就是一种采用分离式技术实现的动态顺序表。因此，使用list.append()加入元素比在指定位置插入元素效率高。重点总结：在Python的官方实现中，list实现采用了下面的策略，在建立空表时，系统分配一块能容纳8个元素的存储区；在执行插入操作(insert和append)时，如果元素存储区满就换一块4倍大的存储区。但如果此时的表已经很大(目前的阈值为50000)，则改变策略，采用加一倍的方法。引入这种改变策略的方式是为了避免出现过多空闲的存储位置。作者：techLee 个人博客地址：www.limiao.tech 原创文章，转载请告知

2018-08-26

资源下载

更多资源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

WebStorm

WebStorm 是jetbrains公司旗下一款JavaScript 开发工具。目前已经被广大中国JS开发者誉为“Web前端开发神器”、“最强大的HTML5编辑器”、“最智能的JavaScript IDE”等。与IntelliJ IDEA同源，继承了IntelliJ IDEA强大的JS部分的功能。