HeatDeath的博客

1、常见hash算法的原理 http://blog.jobbole.com/106733/2、到底什么是hash? https://www.zhihu.com/question/267627073、加盐密码保存的最通用方法是？ https://www.zhihu.com/question/202993844、加盐密码哈希：如何正确使用 http://blog.jobbole.c...

QuickSortThreeWays.javapackage com.algorithm.sort;public class QuickSortThreeWays { private QuickSortThreeWays() { } public static void sort(Integer[] arr) { int n = arr.length;

基本介绍堆的实现通过构造二叉堆（binary heap），实为二叉树的一种；这种数据结构具有以下性质。任意节点小于（或大于）它的所有后裔，最小元（或最大元）在堆的根上（堆序性）。堆总是一棵完全树。即除了最底层，其他层的节点都被元素填满，且最底层尽可能地从左到右填入。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。n个元素序列{k1, k2… ki…kn},当且仅当满足下列

基本的堆排序HeapSortBasic.javapackage com.algorithm.sort;import com.dataStructure.heap.MaxHeap;public class HeapSortBasic { private HeapSortBasic() { } // 对整个arr数组使用 HeapSortBasic 排序 // HeapSo

package com.algorithm.sort;public class HeapSortInPlace { private HeapSortInPlace() { } public static void sort(Integer[] arr) { int n = arr.length; // 注意：我们堆的索引是从0开始的

package com.dataStructure.heap;import java.util.Arrays;public class IndexMaxHeap { // 最大索引堆中的数据 private Integer[] data; // 最大索引堆中的索引 private int[] indexes; private int count; pr

非递归int find(int[] arr, int target){ int l=0, r=arr.length-1; while(l<=r){ int mid = (r-l)/2 + l; if(arr[mid] == target) return mid; if(arr[mid] > target) r = mid-1;

基础// 二叉搜索树// 由于Key需要能够进行比较，所以需要extends Comparable<Key>public class BinarySearchTree<Key extends Comparable<Key>, Value> { // 树中的节点为私有的类，外界不需要了解二叉搜索树节点的具体实现 private class Node{ private

// -------------------------------------------------------------------- // 搜索 最小节点操作 // 寻找二叉搜索树的最小 key public Key minimum(){ Node minNode = minimum(root); return minNode.key;

代码 // 移除 指定 key 的节点操作 public void remove(Key key){ root = remove(root, key); } // 删除掉以node为根的二分搜索树中键值为key的节点, 递归算法 // 返回删除节点后新的二分搜索树的根 private Node remove(Node node, Key k

前驱// -------------------------------------------------------------------- // 查找 key 的前驱 public Key predecessor(Key key){ // 在二叉搜索树中查找 key 对应的节点 Node node = search(root, key);

package com.dataStructure.union_find;public class UnionFind1 { // 第一版的 Union-Find 本质是一个数组 private int[] id; // 数据个数 private int count; public UnionFind1(int n) { count = n;

QuickSortTwoWays.javapackage com.algorithm.sort;public class QuickSortTwoWays { private QuickSortTwoWays() { } public static void sort(Integer[] arr) { int n = arr.length; so

伪代码for each (unsorted) partitionrandomly select pivot, swap with first element storeIndex = pivotIndex + 1 for i = pivotIndex + 1 to rightmostIndex if element[i] < element[pivot] swap(i,

伪代码for each (unsorted) partitionset first element as pivot storeIndex = pivotIndex + 1 for i = pivotIndex + 1 to rightmostIndex if element[i] < element[pivot] swap(i, storeIndex); storeI

1、数学之美系列二十一 － 布隆过滤器（Bloom Filter） https://china.googleblog.com/2007/07/bloom-filter_7469.html2、【算法】哈希表、Bitmap与布隆过滤器 http://dogless.farbox.com/post/github/-suan-fa-ha-xi-biao-bitmapyu-bu-long-guo-l...

数组：数组是将元素在内存中连续存放，由于每个元素占用内存相同，可以通过下标迅速访问数组中任何元素。但是如果要在数组中增加一个元素，需要移动大量元素，在内存中空出一个元素的空间，然后将要增加的元素放在其中。同样的道理，如果想删除一个元素，同样需要移动大量元素去填掉被移动的元素。如果应用需要快速访问数据，很少或不插入和删除元素，就应该用数组。链表：链表恰好相反，链表中的元素在内存中不是...

1 概述符号表是一种用于存储键值对（key-value pair）的数据结构，我们平常经常使用的数组也可以看做是一个特殊的符号表，数组中的“键”即为数组索引，值为相应的数组元素。也就是说，当符号表中所有的键都是较小的整数时，我们可以使用数组来实现符号表，将数组的索引作为键，而索引处的数组元素即为键对应的值，但是这一表示仅限于所有的键都是比较小的整数时，否则可能会使用一个非常大的数组。散列表是对以上策

规则排序成本模型：在研究排序算法时，我们需要计算比较和交换的数量。对于不交换元素的算法，我们会计算访问数组的次数。排序算法可以分为两类：除了函数调用所需的栈和固定数目的实例变量之外无需额外内存的原地排序算法需要额外内存空间来存储另一份数组副本的其他排序算法选择排序首先，找到数组中最小的那个元素。其次，将它和数组的第一个元素交换位置。（如果第一个元素最小，那么它和自己交换位置）再次，在剩下

归并排序要将一个数组排序，可以先（递归地）将它分成两半分别排序，然后将结果归并起来。自顶向下的归并排序归并排序应用了分治的思想，如果它能将两个子数组排序，它就能够通过归并两个子数组来将整个数组排序。命题F：对于长度为 N 的任意数组，自顶向下的归并排序需要 (1/2)*NlgN 到 NlgN 次比较。命题G：对于长度为 N 的人艺术组，自顶向下的归并排序最多需要访问数组 6NlgN 次。因为递归会

伪代码重复（元素个数-1）次 把第一个没有排序过的元素设置为最小值 遍历每个没有排序过的元素 如果元素 < 现在的最小值 将此元素设置成为新的最小值 将最小值和第一个没有排序过的位置交换SelectSort(int[] arr){ int n = arr.length; for(int i = 0; i < n; i++){ int m

伪代码将第一个元素标记为已排序for each unsorted element X 'extract' the element X for j = lastSortedIndex down to 0 if current element j > X 将排序过的元素向右移一格 break loop and insert X hereInsertionSort(i

伪代码do swapped = false for i = 1 to indexOfLastUnsortedElement-1 if leftElement > rightElement swap(leftElement, rightElement) swapped = truewhile swapped int n = arr.length;

int n = arr.length;int h = 1;while(h < n/3){ h = h*3 + 1;}while(h >= 1){ for(int i = h; i < n; i++){ int temp = arr[i]; int j = i; for( ; j >=h; j-=h){ i

伪代码split each element into partitions of size 1recursively merge adjancent partitions for i = leftPartStartIndex to rightPartLastIndex inclusive if leftPartHeadValue <= rightPartHeadValue

package com.algorithm.sort;import java.util.Arrays;public class MergeSortBU { private MergeSortBU(){} // 将arr[l...mid]和arr[mid+1...r]两部分进行归并 private static void merge(Integer[] arr, int l, i

package com.dataStructure.union_find;public class UnionFind2 { // parent[i] 表示第一个元素所指向的父节点 private int[] parent; private int count; public UnionFind2(int n) { count = n;

基于 size 的优化package com.dataStructure.union_find;public class UnionFind3 { private int[] parent; // parent[i]表示第一个元素所指向的父节点 private int[] size; // sz[i]表示以i为根的集合中元素个数 private int count;

package com.dataStructure.union_find;public class UnionFind5 { private int[] parent; private int[] rank; private int count; public UnionFind5(int n) { count = n; parent =

BinaryHeap() 创建一个新的，空的二叉堆。insert(k)向堆添加一个新项。findMin() 返回具有最小键值的项，并将项留在堆中。delMin()返回具有最小键值的项，从堆中删除该项。如果堆是空的，isEmpty() 返回 true，否则返回 false。size() 返回堆中的项数。buildHeap(list)从键列表构建一个新的堆。

优先级队列的作用就像一个队列，你可以通过从前面删除一个项目来出队。然而，在优先级队列中，队列中的项的逻辑顺序由它们的优先级确定。最高优先级项在队列的前面，最低优先级的项在后面。因此，当你将项排入优先级队列时，新项可能会一直移动到前面。实现优先级队列的经典方法是使用称为二叉堆的数据结构。二叉堆将允许我们在 O(logn) 中排队和取出队列。二叉堆是很有趣的研究，因为堆看起来很像一棵树，但是当我们实现它

前序 在前序遍历中，我们首先访问根节点，然后递归地做左侧子树的前序遍历，随后是右侧子树的递归前序遍历。中序 在一个中序遍历中，我们递归地对左子树进行一次遍历，访问根节点，最后递归遍历右子树。 后序 在后序遍历中，我们递归地对左子树和右子树进行后序遍历，然后访问根节点。编写树遍历的代码惊人地优雅，主要是因为遍历是递归写的。# -*- coding:utf-8 -*-class BinaryTree(

分析树可以用于表示诸如句子或数学表达式的真实世界构造。在本节的其余部分，我们将更详细地检查分析树。 特别的，我们会看如何从完全括号的数学表达式构建分析树。如何评估存储在分析树中的表达式。如何从分析树中恢复原始数学表达式。我们知道，每当我们读一个左括号，我们开始一个新的表达式，因此我们应该创建一个新的树来对应于该表达式。 相反，每当我们读一个右括号，我们就完成了一个表达式。 我们还知道操作数将是

要记住这个表示重要的事情是 left 和 right 的属性将成为对 BinaryTree 类的其他实例的引用。 例如，当我们在树中插入一个新的左子节点时，我们创建另一个 BinaryTree 实例，并在根节点中修改self.leftChild 来引用新树节点。我们必须考虑两种插入情况。 第一种情况的特征没有现有左孩子的节点。当没有左孩子时，只需向树中添加一个节点。 第二种情况的特征在于具有现有左孩

6.1.目标要理解树数据结构是什么，以及如何使用它。查看树如何用于实现 map 数据结构。使用列表实现树。使用类和引用来实现树。实现树作为递归数据结构。使用堆实现优先级队列。6.2.树的例子现在我们已经研究了线性数据结构，如栈和队列，并且有一些递归的经验，我们将看一个称为树的常见数据结构。树在计算机科学的许多领域中使用，包括操作系统，图形，数据库系统和计算机网络。树数据结构与他们的植物

5.6.排序排序是以某种顺序从集合中放置元素的过程。例如，单词列表可以按字母顺序或按长度排序。城市列表可按人口，按地区或邮政编码排序。我们已经看到了许多能够从排序列表中获益的算法（回忆之前的回文例子和二分查找）。有许多开发和分析的排序算法。表明排序是计算机科学的一个重要研究领域。对大量项进行排序可能需要大量的计算资源。与搜索一样，排序算法的效率与正在处理的项的数量有关。对于小集合，复杂的排序方法可能

5.1.目标能够解释和实现顺序查找和二分查找。能够解释和实现选择排序，冒泡排序，归并排序，快速排序，插入排序和 shell 排序。理解哈希作为搜索技术的思想。引入映射抽象数据类型。使用哈希实现 Map 抽象数据类型。5.2.搜索我们现在把注意力转向计算中经常出现的一些问题，即搜索和排序问题。在本节中，我们将研究搜索。我们将在本章后面的章节中介绍。搜索是在项集合中查找特定项的算法过程。搜索

3.1.目标● 了解抽象数据类型：栈 stack、队列 queue、双端队列 deque 和列表 list； ● 用 Python 列表数据结构，来实现 stack/queue/deque 抽象数据类型的构建； ● 了解各种基本线性数据结构的性能和使用方法； ● 了解前缀、中缀和后缀表达式； ● 采用栈 stack 对后缀表达式进行求值； ● 采用栈 stack 将中缀表达式转换为后缀表达

4.1.目标本章的目标如下：要理解可能难以解决的复杂问题有一个简单的递归解决方案。学习如何递归地写出程序。理解和应用递归的三个定律。将递归理解为一种迭代形式。实现问题的递归公式化。了解计算机系统如何实现递归。4.2.什么是递归递归是一种解决问题的方法，将问题分解为更小的子问题，直到得到一个足够小的问题可以被很简单的解决。通常递归涉及函数调用自身。递归允许我们编写优雅的解决方案，解决可能

2.1.目标了解为何算法分析的重要性能够用大“O”表示法来描述算法执行时间了解在 Python 列表和字典类型中通用操作用大“O”表示法表示的执行时间了解 Python 数据类型的具体实现对算法分析的影响了解如何对简单的 Python 程序进行执行时间检测2.2.什么是算法分析算法分析主要就是从计算资源的消耗的角度来评判和比较算法。我们想要分析两种算法并且指出哪种更好，主要考虑的是哪一种