RGBMarco的博客

递归算法(deep是为了测试,实际生产不需要): 核心算法://递归算法int rank(Type key,Type a[],int lo,int hi,int deep){ if(lo > hi) return -1; int mid = lo + (hi - lo) / 2; printf("deep: %d lo: %d hi: %d\n",deep,lo,hi)

EdgeWeightedDigraph.h#pragma once#include <memory>#include <fstream>#include <stdexcept>template <typename T>class QSP;template<typename T>class EdgeWeightedDigraph{private: class Adjacent

核心算法 SortString.h#pragma once#include <memory>#include <string>class SortString{private: const int R = 256; std::string *row; int size;private: int toIndex(const std::string& s,co

TireST.h#pragma once#include <memory>#include <string>class TireST{private: class Node { private: std::unique_ptr<std::unique_ptr<Node>[]> list; bool end; public:

Qucik3String.h#pragma once#include <string>#include <memory>class Quick3String{private: std::string *row; int size;private: int toIndex(const std::string& s, const int& pos) {

TST.h#pragma once#include <memory>#include <string>class TST{private: class Node { private: std::unique_ptr<int> c; bool end; std::unique_ptr<Node> left;

构建图: DiWeightGraph.h#pragma once#include <memory>#include <fstream>#include <string>template <typename T>class DoCycle;template <typename T>class DiWeightGraph{public: class AdjacentcyLis

构建图:DiWeightGraph.h#pragma once#include <memory>#include <fstream>#include <string>template <typename T>class BellmanFordSP;template <typename T>class DoCycle;template <typename T>class DiDoCy

对test.txt 按组号进行排序 稳定性不变是该方法能应用于字符串排序的决定性因素Anderson 2Brown 3Davis 3Carcia 4Harris 1Jackson 3Johnson 4Jones 3Martin 1Martinez 2Miller 2Moore 1Robinson 2Smith 4Taylor 3Thomas 4Thompson 4

vi kmp.h#pragma once#include <string>class KMP{private: int **dfa; std::string pattern; int R;private: void init_DFA(const std::string& p) { dfa[p[0]][0] = 1; fo

Boyer-Moore.h#pragma once#include <memory>#include <string>class BoyerMoore{private: std::unique_ptr<int[]> right; std::string pattern;public: BoyerMoore(const std::string& p,const int

RabinKarp.h#pragma once#include <string>class RabinKarp{private: int R; int Q; long RM; long pattHash; std::string pattern;private: long partHash(const std::string& s,const

主要思路:该算法的主要算法主要是考虑权重和采用迭代的思想解决 第一步:我们首先得到一个线性序列,A[1……n],当只有A[1]时,我们得知,该线性序列最大子序列为A[1] 第二步:迭代该序列，我们得到A[1….j],第一次 进行第一步时j = 2,此时最大子序列为A[1]或A[1,2],我们可知A[1] + A[2]如果小于A[2]，我们可知，这两项的权重相当于正数序列加上一个负数,相当于加上...

形成堆： 首先形成堆,我们有两种处理(“上浮”和”下沉”) 上浮:在原堆尾添加元素时,通过比较添加元素和原堆(二叉树)中父节点关系,决定是否继续上浮 下沉:在原堆首添加元素时(此时添加元素是二叉树的根节点),通过比较父节点与左右节点,找出最大的节点,通过是否交换元素,判断是否需要继续下沉 上浮和下沉最坏情况都是lgn，其实就是和二叉树树高有关 T(n) = O(lgn) 总结:两种方法都...

快速排序是一种原址,不稳定的排序算法,最坏情况下运行时间为O(n^2),如果采用随机化选取主元或实际情况能达到快速排序划分子问题时能使两个子问题的问题规模划分是常数比例的,就能使运行时间保持在O(n * lgn),而划分的好坏只会改变其常数因子。 三向快速排序主要是解决序列存在大量相同元素时,通过快速排序平均还是需要O(n * lgn)，而三向快速排序在所有元素全部相同时只需要O(n)下面给...

#include &lt;iostream&gt;#include &lt;random&gt;#include &lt;stdio.h&gt;#include &lt;chrono&gt;using namespace std;void strassen_sub_multi_matrix(struct SubMatrix&amp;, struct SubMatrix&amp;, st...

#include &lt;stdio.h&gt;#include &lt;vector&gt;#include &lt;random&gt;#include &lt;chrono&gt;#include &lt;cmath&gt;#include &lt;algorithm&gt;#include &lt;iostream&gt;using namespace std;/*Au

数论是一个非常庞大的数学分支,这篇博客我会把学的数论知识,和算法慢慢分享出来(不定期更新),各种代码的正确性我会在代码注释里给出证明最大公约数: 最大公约数是数论很重要的组成部分(其实是数论模运算的重要应用),再看证明之前各位必须了解一下公约数及最大公约数的重要性质,下面我就简要的提下我证明所用到的性质。 符号说明:d | b表示d能整除b,即 b % d = 0 1.若d | a且 d...

Graph.h#pragma once#include <string>#include <sstream>#include <fstream>#include <iterator>#include <stack>#include <queue>class Graph{private: class EdgeList { public: clas

EdgeWeightedDigraph.h#pragma once#include <memory>#include <fstream>#include <stdexcept>template <typename T>class Dijkstra;template <typename T>class LazyDijkstra;template<typename T>class Ed

EdgeWeightedDigraph.h#pragma once#include <memory>#include <fstream>#include <stdexcept>template <typename T>class Dijkstra;template <typename T>class LazyDijkstra;template <typename T>class D

递归版二分查找： 核心算法:binarysearch.php //echo内容均为debug<?php //递归 function Rank($key,&$array,$lo,$hi,$deep) { if ($lo > $hi) { echo "$key 未找到<br/>"; return -

二项分布是数学的概念，定义及公式定理不在此说明. 注：递归版第三步及递推都依赖于C（M-1，N-1）+C（M-1，N）=C（M，N）的变形 递归版: （我给递归版注释了1 2 3 是为了解析非递归版(递推版)中同等的操作 1 2 3）方便我们理解是怎么让递归变成递推的double binomial(int N, int k, double p){ // 1 if (

二项分布是数学的概念，定义及公式定理不在此说明. 注：递归版第三步及递推都依赖于C（M-1，N-1）+C（M-1，N）=C（M，N）的变形 递归版: （我给递归版注释了1 2 3 是为了解析非递归版(递推版)中同等的操作 1 2 3）方便我们理解是怎么让递归变成递推的public static double binomial(int N,int k,double p) {

二项分布是数学的概念，定义及公式定理不在此说明. 注：递归版第三步及递推都依赖于C（M-1，N-1）+C（M-1，N）=C（M，N）的变形 递归版: （我给递归版注释了1 2 3 是为了解析非递归版(递推版)中同等的操作 1 2 3）方便我们理解是怎么让递归变成递推的function binomial($N,$k,$p) { // 1 if($N <

java版(非递归和·递归的方法返回查找到的第一个或最后一个相同元素值索引import edu.princeton.cs.algs4.StdOut;public class Main { // 非递归版 返回第一个相同值索引 public static int BSearch_F(int key,int[] a) { int lo = 0;

进阶版入口 递归处理的核心算法(加入·deep是为理解算法):import edu.princeton.cs.algs4.*;public class Main{ public static int rank(int key,int[] a) { int deep = 0; return rank(key,a,0,a.length - 1,deep

进阶版入口 递归版算法(deep变量是为了测试,实际生产可不需要): 核心算法:#include <iostream>#include <vector>#include <fstream>#include <iterator>#include <algorithm>#include <string>using namespace std;template<typename T,type

第一题 ： 统计数组两项相加为给定值的个数 看题很容易 三种解法 第一种用两个for循环暴力破解一样 第二种 一个for循环里通过二分查找-value(两项效果不明显) 第三种 通过排序 在通过排序的信息一遍for循环 下面几题上三种方法均适用(不过是加个for循环),前两种就不给代码了,下面贴出以下几题的第三种方法代码,有错误还望指出TwoSum.javaimport java.util.

public class BST<Key extends Comparable<Key>,Value> { private class Node { Node left = null; Node right = null; int count = 0; Key key; Value value;

BST.h#pragma once#include <stdexcept>#include <iterator>template<typename Key,typename Value>class BST{private: class Node { public: Node* left = nullptr; Node* right

400多行代码(其实还有好多API没完成),请接受恐惧的代码吧,下面也给出了测试代码BST.h#pragma once#include <stdexcept>#include <stack>template<typename Key, typename Value>class BST{private: class Node { public: No

DiGraph.h#pragma once#include <iterator>#include <fstream>#include <memory>#include <array>#include <iostream>#include <stack>#include <vector>#include <queue>class DiGraph{private: class

RedBlackBST#pragma once#include <stdexcept>template<typename Key,typename Value>class RedBlackBST{private: enum Color { BLACK = 0, RED = 1 }; class Node { public:

红黑树结点删除这是我到目前为止见过最难的算法,但还是要搞懂啊，网上的博客千篇一律都是 列出五大性质，画个图，然后自己把自己说晕，就贴个代码糊弄人，评论区都来挑错，这让我很痛苦啊,看到知乎上有人说算法第四版作者就是发明这算法的,不巧，我看的就是算法第四版(他把结点删除弄成习题了),后来，才发现起点就是重点啊,作者在习题里给了代码,可我没分析懂,看到书上作者对删除的描述和习题答案，就发现了作者代码的意

HashTable.h#pragma once#include <functional>#include <stdexcept>template<typename Key,typename Value,typename Hash = std::hash<Key>>class HashTable{private: class List { public:

HashTable.h#pragma once#include <functional>template<typename Key,typename Value,typename Hash = hash<Key>>class HashTable{private: Key** key = nullptr; Value** value = nullptr; int kvc

EdgeWeightedGraph.h#pragma once#include <memory>#include <stdexcept>#include <fstream>#include <iterator>#include <sstream>#include "priority_queue.h"template <typename T>class LazyPrimMST;tem

不定期更新/* *散列表:我们日常存储数据通常通过数组来达到目的,但是对于我们需要存储key-value *属性时,如果元素是日益增长的,我们开辟大空间或者动态申请数组(需要复制旧数组), *不免是种资源浪费,这时散列表就能起到很好的作用,通过散列函数将不同元素尽可能映射 *到不同槽,从而得到一种尽可能的达到数组(查找,插入,删除,更新)的高效(用下标为key), *而又不产生对资源...