gcd is short for greatest common divisor If a,b are co-primes, we denote as $(a,b)=1, \text{which means } gcd(a,b)=1 $ We can use Euclid algorithm to calculate gcd of two numbers.
1 2 3 4
defgcd(a,b): while b!=0: a,b=b,a%b return a
0.1.1. Bezout’s identity
Let a and b be integers with greatest common divisord. Then, there exist integers x and y such that ax + by = d. More generally, the integers of the form ax + by are exactly the multiples of d.
we can use extended euclid algorithm to calculate x,y,gcd(a,b)
gcd.py
1 2 3 4 5
defxgcd(a,b): '''return gcd(a,b), x,y where ax+by=gcd(a,b)''' if b==0:return a,1,0 g,x,y = xgcd(b,a%b) return g,y,x-a//b*y
classprimeSieve: '''sieve of Eratosthenes, It will be more efficient when judging many times''' primes = [2,3,5,7,11,13] defisPrime(self,x): if x<=primes[-1]: return twoDivideFind(x,self.primes) while x>self.primes[-1]: left = self.primes[-1] right = (left+1)**2 lst = [] for i in range(left,right): for j in self.primes: if i%j==0:break else:lst.append(i) self.primes+=lst return twoDivideFind(x,lst)
deftwoDivideFind(x,li): a,b = 0, len(li) while a<=b: mid = (a+b)//2 if li[mid]<x:a=mid+1 elif li[mid]>x: b= mid-1 else:return mid return-1
Just like the Fermat and Solovay–Strassen tests, the Miller–Rabin test relies on an equality or set of equalities that hold true for prime values, then checks whether or not they hold for a number that we want to test for primality.
First, a lemma “Lemma (mathematics)”) about square roots of unity in the finite fieldZ/p**Z*, where p is prime and p > 2. Certainly 1 and −1 always yield 1 when squared modulo p; call these trivial “Trivial (mathematics)”) square roots of 1. There are no nontrivial square roots of 1 modulo p (a special case of the result that, in a field, a polynomial has no more zeroes than its degree). To show this, suppose that x is a square root of 1 modulo p*. Then:
In other words, prime p divides the product (x − 1)(x + 1). By Euclid’s lemma it divides one of the factors x − 1 or x + 1, implying that x is congruent to either 1 or −1 modulo p.
Now, let n be prime, and odd, with n > 2. It follows that n − 1 is even and we can write it as 2s·d, where s and d are positive integers and d is odd. For each a in (Z/n**Z*), either
or
To show that one of these must be true, recall Fermat’s little theorem, that for a prime number n:
By the lemma above, if we keep taking square roots of an−1, we will get either 1 or −1. If we get −1 then the second equality holds and it is done. If we never get −1, then when we have taken out every power of 2, we are left with the first equality.
The Miller–Rabin primality test is based on the contrapositive of the above claim. That is, if we can find an a such that
and
then n is not prime. We call a a witness “Witness (mathematics)”) for the compositeness of n (sometimes misleadingly called a strong witness, although it is a certain proof of this fact). Otherwise a is called a strong liar, and n is a strong probable prime to base a. The term “strong liar” refers to the case where n is composite but nevertheless the equations hold as they would for a prime.
Every odd composite n has many witnesses a, however, no simple way of generating such an a is known. The solution is to make the test probabilistic: we choose a non-zero a in Z/n**Z* randomly, and check whether or not it is a witness for the compositeness of n. If n is composite, most of the choices for a will be witnesses, and the test will detect n as composite with high probability. There is, nevertheless, a small chance that we are unlucky and hit an a which is a strong liar for n. We may reduce the probability of such error by repeating the test for several independently chosen a*.
For testing large numbers, it is common to choose random bases a, as, a priori, we don’t know the distribution of witnesses and liars among the numbers 1, 2, …, n − 1. In particular, Arnault [4] gave a 397-digit composite number for which all bases aless than 307 are strong liars. As expected this number was reported to be prime by the Maple “Maple (software)”) isprime() function, which implemented the Miller–Rabin test by checking the specific bases 2,3,5,7, and 11. However, selection of a few specific small bases can guarantee identification of composites for n less than some maximum determined by said bases. This maximum is generally quite large compared to the bases. As random bases lack such determinism for small n, specific bases are better in some circumstances.
from random import sample defquickMulMod(a,b,m): '''a*b%m, quick''' ret = 0 while b: if b&1: ret = (a+ret)%m b//=2 a = (a+a)%m return ret
defquickPowMod(a,b,m): '''a^b %m, quick, O(logn)''' ret =1 while b: if b&1: ret =quickMulMod(ret,a,m) b//=2 a = quickMulMod(a,a,m) return ret
defisPrime(n,t=5): '''miller rabin primality test, a probability result t is the number of iteration(witness) ''' if n<2: print('[Error]: {} can\'t be classed with prime or composite'.format(n)) return if n==2: returnTrue d = n-1 r = 0 while d%2==0: r+=1 d//=2 t = min(n-3,t) for a in sample(range(2,n-1),t): x= quickPowMod(a,d,n) if x==1or x==n-1: continue#success, for j in range(r-1): x= quickMulMod(x,x,n) if x==n-1:break else: returnFalse returnTrue
Suppose we need to factorize a number $n=pq$, where $p$ is a non-trivial factor. A polynomial modulo $n$, called
where c is a chosen number ,eg 1.
is used to generate a pseudo-random sequence: A starting value, say 2, is chosen, and the sequence continues as
, The sequence is related to another sequence$\{x_k\ mod \ p\}$ . Since $p$ is not known beforehand, this sequence cannot be explicitly computed in the algorithm. Yet, in it lies the core idea of the algorithm.
Because the number of possible values for these sequences are finite, both the$\{x_n\}$ sequence, which is mod $n$ , and $\{x_n\ mod\ p\}$ sequence will eventually repeat, even though we do not know the latter. Assume that the sequences behave like random numbers. Due to the birthday paradox, the number of$x_k$before a repetition occurs is expected to be $O(\sqrt{N})$ , where $N$ is the number of possible values. So the sequence $\{x_n\ mod\ p\}$ will likely repeat much earlier than the sequence $x_k$. Once a sequence has a repeated value, the sequence will cycle, because each value depends only on the one before it. This structure of eventual cycling gives rise to the name “Rho algorithm”, owing to similarity to the shape of the Greek character ρ when the values $x_i\ mod \ p$ are represented as nodes in a directed graph.
This is detected by the Floyd’s cycle-finding algorithm: two nodes$i,j$ are kept. In each step, one moves to the next node in the sequence and the other moves to the one after the next node. After that, it is checked whether $\text{gcd}(x_i-x_j,n)\neq 1$. If it is not 1, then this implies that there ris a repetition in the $\{x_k\ mod\ p\}$ swquence
This works because if the $x_i\ mod\ p$is the same as$x_j\ mod\ p$, the difference between$x_i,x_j$ is necessarily a multiple of $p$. Although this always happens eventually, the resulting GCD is a divisor of $n$ other than 1. This may be$n$ itself, since the two sequences might repeat at the same time. In this (uncommon) case the algorithm fails, and can be repeated with a different parameter.
from random import randint from isPrime import isPrime from gcd import gcd
deffactor(n): '''pollard's rho algorithm''' if n==1: return [] if isPrime(n):return [n] fact=1 cycle_size=2 x = x_fixed = 2 c = randint(1,n) while fact==1: for i in range(cycle_size): if fact>1:break x=(x*x+c)%n if x==x_fixed: c = randint(1,n) continue fact = gcd(x-x_fixed,n) cycle_size *=2 x_fixed = x return factor(fact)+factor(n//fact)
0.4. Euler function
Euler function, denoted as $\phi(n)$, mapping n as the number of number which is smaller than n and is the co-prime of n.
e.g.: $\phi(3)=2$ since 1,2 are coprimes of 3 and smaller than 3, $\phi(4)=2$ ,(1,3)
Euler function is a kind of productive function and has two properties as follows:
$\phi(p^k) = p^k-p^{k-1}$, where p is a prime
$\phi(mn) = \phi(m)*\phi(n)$ where $(m,n)=1$
Thus, for every narural number n, we can evaluate $\phi(n)$ using the following method.
factorize n: , where $p_i$ is a prime and $k_i,l > 0$ .
calculate $\phi(n) $ using the two properties.
And , $\sigma(n)$ represents the sum of all factors of n. e.g. : $\sigma(9) = 1+3+9 = 14$
A perfect number _n_ is defined as $\sigma(n) = 2n$ The following is the implementation of this two functions.
1 2 3 4 5 6 7 8 9 10 11
from factor import factor from collections import Counter from functools import reduce from operator import mul defphi(n): st = set(factor(n)) return round(reduce(mul,(1-1/p for p in st),n))
defsigma(n): ct = Counter(factor(n)) return reduce(mul,(round((p**(ct[p]+1)-1)/(p-1)) for p in ct),1)
0.5. Modulo equation
The following codes can solve a linear, group modulo equation. More details and explanations will be supplied if I am not too busy.
Note that I use -- to represent $\equiv$ in the python codes.
from gcd import xgcd from euler import phi from isPrime import isPrime from factor import factor
defind(m,g): ''' mod m ,primary root g -> {n:indg n}''' return {j:i for i in range(m-1) \ for j in range(m) if (g**i-j)%m==0}
defgs(m,num=100): '''return list of m's primary roots below num''' p = phi(m) mp = factor(p) checkLst = [p//i for i in mp] return [i for i in range(2,num) if all((i**n-1)%m !=0for n in checkLst)]
defminG(m): p = phi(m) mp = factor(p) checkLst = [p//i for i in mp] i=2 while1: if all((i**n-1)%m !=0for n in checkLst):return i i+=1
classsolve: def__init__(self,equ=None): self.linearPat= re.compile(r'\s*(\d+)\s*--\s*(\d+)[\s\(]*mod\s*(\d+)') self.sol = [] #self.m = m #self.ind_mp = ind(m,minG(m)) defnoSol(self): print('equation {equ} has no solution'.format(equ=self.equ)) deferror(self): print("Error! The divisor m must be postive integer") defsolveLinear(self,a,b,m): '''ax--b(mod m): solve linear equation with one unknown return ([x1,x2,...],m) ''' a,b,m = self.check(a,b,m) g,x,y=xgcd(a,m) if a*b%g!=0: self.noSol() returnNone sol=x*b//g m0 = m//g sols = [(sol+i*m0)%m for i in range(g)] print('{}x--{}(mod {}), solution: {} mod {}'.format(a,b,m,sols,m)) return (sols,m) defcheck(self,a,b,m): if m<=0: self.error() returnNone if a<0:a,b=-a,-b ## important if b<0:b+= -b//m * m return a,b,m
defsolveHigh(self,a,n,b,m): ''' ax^n -- b (mod m) ind_mp is a dict of m's {n: indg n}''' ind_mp = ind(m,minG(m)) tmp = ind_mp[b] - ind_mp[a] if tmp < 0:tmp+=m sol = self.solveLinear(n,tmp,phi(m)) re_mp = {j:i for i ,j in ind_mp.items()} sols = [re_mp[i] for i in sol[0]] print('{}x^{}--{}(mod {}), solution: {} mod {}'.format(a,n,b,m,sols,m)) return sols,m
defsolveGroup(self,tups): '''tups is a list of tongyu equation groups, like [(a1,b1,m1),(a2,b2,m2)...] and, m1,m2... are all primes ''' mp = {} print('solving group of equations: ') for a,b,m in tups: print('{}x--{}(mod {})'.format(a,b,m)) if m in mp: if mp[m][0]*b!=mp[m][1]*a: self.noSol() return else:mp[m] = (a,b) product = 1 for i in mp.keys(): product *=i sol = [0] for i in mp: xs,m = self.solveLinear(product//i*mp[i][0],1,i) new = [] for x in xs: cur = x*product//i*mp[i][1] for old in sol: new.append(old+cur) sol = new sol= [i%product for i in sol] print('final solution: {} mod {}'.format(sol,product)) return sol,product def__call__(self): s=input('输入同余方程，用--代表同于号，形如3--5(mod 7)代表3x模7同余于5') li= self.linearPat.findall(s) li = [(int(a),int(b),int(m)) for a,b,m in li] print(self.solveLinear(li[0]))
if __name__ == '__main__': solver = solve() res = solver.solveLinear(3,6,9) print() res = solver.solveHigh(1,8,3,11) print() res = solver.solveGroup([(5,11,2),(3,8,5),(4,1,7)])
defisPrime(x): for i in range(2,int(x**0.5)+1): if x%i==0:returnFalse returnTrue defgetPrime(x): '''return a prime which is bigger than x''' for i in range(x,2*x): if isPrime(i):return i deffindAll(s,p): '''s: string p: pattern''' dic={} n,m = len(s),len(p) d=0#radix for c in s: if c notin dic: dic[c]=d d+=1 sm = 0 for c in p: if c notin dic:return [] sm = sm*d+dic[c]
ret = [] cur = 0 for i in range(m): cur=cur*d + dic[s[i]] if cur==sm:ret.append(0) tmp = n-m q = getPrime(m) cur = cur%q sm = sm%q exp = d**(m-1) % q for i in range(m,n): cur = ((cur-dic[s[i-m]]*exp)*d+dic[s[i]]) % q if cur == sm and p==s[i-m+1:i+1]: ret.append(i-m+1) return ret
defrandStr(n=3): return [randint(ord('a'),ord('z')) for i in range(n)]
if __name__ =='__main__': from random import randint s = randStr(50) p = randStr(1) print(s) print(p) print(findAll(s,p))
FSM
A FSM can be represented as $(Q,q_0,A,S,C)$, where
Q is the set of all states
$q_0$ is the start state
$A\in Q$ is a set of accepting states.
S is a finite input alphabet.
C is the set of transition functions: namely $q_j = c(s,q_i)$.
Given a pattern string S, we can build a FSM for string matching. Assume S has m chars, and there should be m+1 states. One is for the begin state, and the others are for matching state of each position of S.
Once we have built the FSM, we can run it on any input string.
KMP
Knuth-Morris-Pratt method
The idea is inspired by FSM. We can avoid computing the transition functions. Instead, we compute a prefix function P in O(m) time, which has only m entries.
Prefix funtion stores info about how the pattern matches against shifts of itself.
String w is a prefix of string x, if x=wy for some string y
String w is a suffix of string x, if x=yw for some string y
The k-character prefix of the pattern P [1..m] denoted by Pk.
Given that pattern prefix P [1..q] matches text characters T [(s+1)..(s+q)], what is the least shift s’> s such that P [1..k] = T [(s’+1)..(s’+k)] where s’+k=s+q?
At the new shift s’, no need to compare the first k characters of P with corresponding characters of T. Method: For prefix $p_i$, find the longest proper prefix of $p_i$ that is also a suffix of $p_i$.
For example: p = ababaca, Then, $p_5$ = ababa, pre[5] = 3. Namely $p_3$=aba is the longest prefix of p that is also a suffix of $p_5$.
Time approximation: finding prefix function take O(m), matching takes O(m+n)
defgetPrefixFunc(s): '''return the list of prefix function of s''' length = 0 i = 1 n = len(s) ret = [0] while i<n: if s[i]==s[length]: length +=1 ret.append(length) i+=1 else: if length==0: ret.append(0) i+=1 else: length = ret[length-1] return ret
deffindAll(s,p): pre = getPrefixFunc(p) i = j =0 n,m = len(s),len(p) ret = [] while i<n: if s[i]==p[j]: i+=1 j+=1 if j==m: ret.append(i-j) j=pre[j-1] else: if j==0: i+=1 else: j = pre[j-1] return ret defrandStr(n=3): return [randint(ord('a'),ord('z')) for i in range(n)]
if __name__ =='__main__': from random import randint s = randStr(50) p = randStr(1) print(s) print(p) print(findAll(s,p))
Boyer-Moore
The longer the pattern is, the faster it works.
Starts from the end of pattern, while KMP starts from the beginning.
Works best for character string, while KMP works best for binary string.
KMP and Boyer-Moore
Preprocessing existing patterns.
Searching patterns in input strings.
Sunday
features
simplification of the Boyer-Moore algorithm;
uses only the bad-character shift;
easy to implement;
preprocessing phase in O(m+sigma) time and O(sigma) space complexity;
searching phase in O(mn) time complexity;
very fast in practice for short patterns and large alphabets.
description
The Quick Search algorithm uses only the bad-character shift table (see chapter Boyer-Moore algorithm). After an attempt where the window is positioned on the text factor y[j .. j+m-1], the length of the shift is at least equal to one. So, the character y[j+m] is necessarily involved in the next attempt, and thus can be used for the bad-character shift of the current attempt.
The bad-character shift of the present algorithm is slightly modified to take into account the last character of x as follows: for c in Sigma, qsBc[c]=min{i : 0 < i leq m and x[m-i]=c} if c occurs in x, m+1 otherwise (thanks to Darko Brljak).
The preprocessing phase is in O(m+sigma) time and O(sigma) space complexity.
During the searching phase the comparisons between pattern and text characters during each attempt can be done in any order. The searching phase has a quadratic worst case time complexity but it has a good practical behaviour.
For instance,
In this example, t0, …, t4 = a b c a b is the current text window that is compared with the pattern. Its suffix a b has matched, but the comparison c-a causes a mismatch. The bad-character heuristics of the Boyer-Moore algorithm (a) uses the “bad” text character c to determine the shift distance. The Horspool algorithm (b) uses the rightmost character b of the current text window. The Sunday algorithm (c) uses the character directly right of the text window, namely d in this example. Since d does not occur in the pattern at all, the pattern can be shifted past this position.
defgetPos(pattern): dic = {} for i,j in enumerate(pattern[::-1]): if j notin dic: dic[j]= i return dic deffind(s,p): dic = getPos(p) ps = pp = 0 ns = len(s) np = len(p) while ps<ns and pp<np: if s[ps] == p[pp]: ps,pp = ps+1,pp+1 else: idx = ps+ np-pp if idx >=ns:return-1 ch = s[idx] if ch in dic: ps += dic[ch]+1-pp else: ps = idx+1 pp = 0 if pp==np:return ps-np else: return-1 deffindAll(s,p): ns = len(s) np = len(p) i = 0 ret = [] while s: print(s,p) tmp = find(s,p) if tmp==-1: break ret.append(i+tmp) end = tmp+np i +=end s = s[end:] return ret
defrandStr(n=3): return [randint(ord('a'),ord('z')) for i in range(n)]
deftest(n): s = randStr(n) p = randStr(3) str_s = ''.join((chr(i) for i in s)) str_p = ''.join((chr(i) for i in p)) n1 = find(s,p) n2 = str_s.find(str_p) # 利用已有的 str find 算法检验 if n1!=n2: print(n1,n2,str_p,str_s) returnFalse returnTrue if __name__ =='__main__': from random import randint n = 1000 suc = sum(test(n) for i in range(n)) print('test {n} times, success {suc} times'.format(n=n,suc=suc))
WildCard matching
wild card:
* matches 0 or any chars
? matches any single char.
Given a string s which doesn’t include wild card, and a pattern p which includes wild card,
Judge if they are matching.
Idea
Using dynamic programming.
n = length(s), m = length(p)
dp[m+1][n+1]: bool
i:n, j:m dp[j][i] represents if s[:i+1] matches p[:j+1]
initialzation : dp[0][0] = True, dp[0][i],dp[j][0] = False, only if p startswith ‘*’, dp[1][0] = True.
if p[j] = ‘*’: dp[j][i] = dp[j-1][i] or dp[j][i-1] elif p[j] = ‘?’: dp[j][i] = dp[j-1][i-1] else : dp[j][i] = dp[j-1][i-1] and s[i] == p[j]
defisMatch(self, s, p): """ :type s: str :type p: str pattern str including wildcard :rtype: bool """ n,m = len(s),len(p) last = [False]*(n+1) last[0] = True for j in range(m): if p[j]=='*': for i in range(n): last[i+1] = last[i+1] or last[i] elif p[j]=='?': last.pop() last.insert(0,False) else: li = [False] for i in range(n): li.append( last[i] and p[j]==s[i]) last = li return last[-1]
]]>
<p>See more on <a href="https://github.com/mbinary/algorithm" target="_blank" rel="noopener">github</a></p>
<p>In this article, I will show you some kinds of popular string matching algorithm and dynamic programming algorithm for wildcard matching.</p>
图算法https://mbinary.xyz/graph.html2018-09-06T19:10:00.000Z2021-04-23T08:02:23.258Z
for v in V: v.d = MAX v.pre = None v.isFind = False root. isFind = True root.d = 0 que = [root] while que !=[]: nd = que.pop(0) for v in Adj(nd): ifnot v.isFind : v.d = nd.d+1 v.pre = nd v.isFind = True que.append(v)
时间复杂度 $O(V+E)$
2.2. DFS
$\Theta(V+E)$
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
defdfs(G): time = 0 for v in V: v.pre = None v.isFind = False for v in V : # note this, ifnot v.isFind: dfsVisit(v) defdfsVisit(G,u): time =time+1 u.begin = time u.isFind = True for v in Adj(u): ifnot v.isFind: v.pre = u dfsVisit(G,v) time +=1 u.end = time
for v in V: v.minAdjEdge = MAX v.pre = None root.minAdjEdge = 0 que = priority-queue (G.V) # sort by minAdjEdge whilenot que.isempty(): u = que.extractMin() for v in Adj(u): if v in que and v.minAdjEdge>w(u,v): v.pre = u v.minAdjEdge = w(u,v)
建堆 $O(V)$ //note it's v, not vlgv
主循环中
extractMin: $O(VlgV)$
in 操作 可以另设标志位, 在常数时间完成, 总共 $O(E)$
设置结点的 minAdjEdge, 需要$O(lgv)$, 循环 E 次,则 总共$O(ElgV)$
defdag-shortest-path(G,s): initialize(G,s) for u in topo-sort(G.V): for v in Adj(v): relax(u,v,w(u,v))
4.6. Bellman-Ford 算法
$O(VE)$
1 2 3 4 5 6 7 8 9
defbellman-ford(G,s): initialize(G,s) for ct in range(|V|-1): # v-1 times for u,v as edge in E: relax(u,v,w(u,v)) for u,v as edge in E: if v.distance > u.distance + w(u,v): returnFalse returnTrue
第一个 for 循环就是进行松弛操作, 最后结果已经存储在 结点的distance 和 pre 属性中了, 第二个 for 循环利用三角不等式检查有不有负值圈.
defdijkstra(G,s): initialize(G,s) paths=[] q = priority-queue(G.V) # sort by distance whilenot q.empty(): u = q.extract-min() paths.append(u) for v in Adj(u): relax(u,v,w(u,v))
deff(L, W): n = L.rows L_new = new matrix(row=n ,col = n) for i in range(n): for j in range(n): L_new[i][j] = MAX for k in range(n): L_new[i][j] = min(L_new[i][j], L[i][k]+w[k][j]) return L_new
deffloyd-warshall(W): n = len(W) D= W initialize pre for k in range(n): pre2 = pre.copy() for i in range(n): for j in range(n) if d[i][j] > d[i][k]+d[k][j]: d[i][j] =d[i][k]+d[k][j] pre2[i][j] = pre[k][j] pre = pre2 return d,pre
s = newNode G' = G.copy() G'.addNode(s) for v in G.V: G'.addArc(s,v,w=0) if BELLMAN-FORD(G' , w, s) ==FALSE error "the input graph contains a negative-weight cycle"
for v in G'.V: # computed by the bellman-ford algorithm, delta(s,v) is the shortest distance from s to v h(v) = delta(s,v) for edge(u,v) in G'.E: w' = w(u,v)+h(u)-h(v) d = matrix(n,n) for u in G: dijkstra(G,w',u) # compute delta' for all v in G.V for v in G.V: d[u][v] = delta'(u,v) + h(v)-h(u) return d
6. 最大流
G 是弱连通严格有向加权图, s为源, t 为汇, 每条边e容量 c(e), 由此定义了网络N(G,s,t,c(e)),
流函数 $f(e):E \rightarrow R$其中 $\alpha(v)$ 是以 v 为头的边集, $\beta(v)$是以 v 为尾的边集
defford-fulkerson(G,s,t): initialize flow f to 0 while exists an augmenting path p in residual network Gf: augment flow f along p return f
6.3.1. 残存网络
6.3.2. 增广路径
6.3.3. 割
6.4. 基本的 Ford-Fulkerson算法
1 2 3 4 5 6 7 8
defford-fulkerson(G,s,t): for edge in G.E: edge.f = 0 while exists path p:s->t in Gf: cf(p) = min{cf(u,v):(u,v) isin p} for edge in p: if edge in E: edge.f +=cf(p) else: reverse_edge.f -=cf(p)
defextract-min(H): z = H.min if z!=None: for chd of z: link chd to H.rootList chd.prt = None remove z from the rootList of H if z==z.right: H.min = None else: H.min = z.right consolidate(H) H.n -=1 return z
consolidate 函数使用一个 辅助数组degree来记录所有根结点(不超过lgn)对应的度数, degree[i] = nd 表示.有且只有一个结点 nd 的度数为 i.
defconsolidate(H): initialize degree withNone for nd in H.rootList: d = nd.degree while degree[d] !=None: nd2 = degree[d] if nd2.degree < nd.degree: nd2,nd = nd,nd2
make nd2 child of nd nd.degree = d+1 nd.mark = False# to balace the potential
remove nd2 from H.rootList degree[d] = None d+=1 else: degree[d] = nd for i in degree: if i!=None: link i to H.rootList if H.min ==None: H.min = i elseif H.min>i: H.min = i
defdecrease-key(H,x,k): if k>x.key: error x.key = k y=x.p if y!=Noneand x.key < y.key: cut(H,x,y) cascading-cut(H,y) if x.key < H.min.key: H.min = x defcut(H,x,y): remove x from the child list of y, decrementing y.degree add x to H.rootList x.prt = None x.mark = False
defcascading-cut(H,y): z- y,prt if z !=None: if y.mark ==False:y.mark = True else: cut(H,y,z) cascading-cut(H,z)
defsearch(self,key,withpath=False): nd = self.root fathers = [] whileTrue: i = nd.findKey(key) if i==len(nd): fathers.append((nd,i-1,i)) else: fathers.append((nd,i,i)) if i<len(nd) and nd[i]==key: if withpath:return nd,i,fathers else:return nd,i if nd.isLeafNode(): if withpath:returnNone,None,None else:returnNone,None nd = nd.getChd(i)
我实现时让 fathers 记录查找的路径, 方便在实现 delete 操作时使用(虽然有种 delete 方法可以不需要, 直接 from up to down with no pass by),
Locate and delete the item, then restructure the tree to retain its invariants, OR
Do a single pass down the tree, but before entering (visiting) a node, restructure the tree so that once the key to be deleted is encountered, it can be deleted without triggering the need for any further restructuring
defdelete(self,key):#to do '''search the key, delete it , and form down to up to rebalance it ''' nd,idx ,fathers= self.search(key,withpath=True) if nd isNone : return del nd[idx] self.keyNum-=1 ifnot nd.isLeafNode(): chd = nd.getChd(idx) # find the predecessor key whilenot chd.isLeafNode(): fathers.append((chd,len(chd)-1,len(chd))) chd = chd.getChd(-1) fathers.append((chd,len(chd)-1,len(chd))) nd.insert(idx,chd[-1]) del chd[-1] if len(fathers)>1:self.rebalance(fathers) defrebalance(self,fathers): nd,keyIdx,chdIdx = fathers.pop() while len(nd)<self.degree-1: # rebalance tree from down to up prt,keyIdx,chdIdx = fathers[-1] lbro = [] if chdIdx==0else prt.getChd(chdIdx-1) rbro = [] if chdIdx==len(prt) else prt.getChd(chdIdx+1) if len(lbro)<self.degree and len(rbro)<self.degree: # merge two deficient nodes beforeNode,afterNode = None,None if lbro ==[]: keyIdx = chdIdx beforeNode,afterNode = nd,rbro else: beforeNode,afterNode = lbro,nd keyIdx = chdIdx-1# important, when choosing keys = beforeNode[:]+[prt[keyIdx]]+afterNode[:] children = beforeNode.getChildren() + afterNode.getChildren() isLeaf = beforeNode.isLeafNode() prt.delChd(keyIdx+1) del prt[keyIdx] nd.update(keys,isLeaf,children) prt.children[keyIdx]=nd self.nodeNum -=1 elif len(lbro)>=self.degree: # rotate when only one sibling is deficient keyIdx = chdIdx-1 nd.insert(0,prt[keyIdx]) # rotate keys prt[keyIdx] = lbro[-1] del lbro[-1] ifnot nd.isLeafNode(): # if not leaf, move children nd.insert(0,nd=lbro.getChd(-1)) lbro.delChd(-1) else: keyIdx = chdIdx nd.insert(len(nd),prt[keyIdx]) # rotate keys prt[keyIdx] = rbro[0] del rbro[0] ifnot nd.isLeafNode(): # if not leaf, move children #note that insert(-1,ele) will make the ele be the last second one nd.insert(len(nd),nd=rbro.getChd(0)) rbro.delChd(0) if len(fathers)==1: if len(self.root)==0: self.root = nd self.nodeNum -=1 break nd,i,j = fathers.pop()
if __name__ =='__main__': bt = bTree() from random import shuffle,sample n = 20 lst = [i for i in range(n)] shuffle(lst) test= sample(lst,len(lst)//4) print(f'building b-tree with {lst}') for i in lst: bt.insert(i) #print(f'inserting {i}) #print(bt) print(bt) print(f'serching {test}') for i in test: nd,idx = bt.search(i) print(f'node: {repr(nd)}[{idx}]== {i}') for i in test: print(f'deleting {i}') bt.delete(i) print(bt)
classnode: def__init__(self,keys=None,isLeaf = True,children=None): if keys isNone:keys=[] if children isNone: children =[] self.keys = keys self.isLeaf = isLeaf self.children = [] def__getitem__(self,i): return self.keys[i] def__delitem__(self,i): del self.keys[i] def__setitem__(self,i,k): self.keys[i] = k def__len__(self): return len(self.keys) def__repr__(self): return str(self.keys) def__str__(self): children = ','.join([str(nd.keys) for nd in self.children]) returnf'keys: {self.keys}\nchildren: {children}\nisLeaf: {self.isLeaf}' defgetChd(self,i): return self.children[i] defdelChd(self,i): del self.children[i] defsetChd(self,i,chd): self.children[i] = chd defgetChildren(self,begin=0,end=None): if end isNone:return self.children[begin:] return self.children[begin:end] deffindKey(self,key): for i,k in enumerate(self.keys): if k>=key: return i return len(self) defupdate(self,keys=None,isLeaf=None,children=None): if keys isnotNone:self.keys = keys if children isnotNone:self.children = children if isLeaf isnotNone: self.isLeaf = isLeaf definsert(self,i,key=None,nd=None): if key isnotNone:self.keys.insert(i,key) ifnot self.isLeaf and nd isnotNone: self.children.insert(i,nd) defisLeafNode(self):return self.isLeaf defsplit(self,prt,t): # form new two nodes k = self[t-1] nd1 = node() nd2 = node() nd1.keys,nd2.keys = self[:t-1], self[t:] # note that t is 1 bigger than key index nd1.isLeaf = nd2.isLeaf = self.isLeaf ifnot self.isLeaf: # note that children index is one bigger than key index, and all children included nd1.children, nd2.children = self.children[0:t], self.children[t:] # connect them to parent idx = prt.findKey(k) if prt.children !=[]: prt.children.remove(self) # remove the original node prt.insert(idx,k,nd2) prt.insert(idx,nd = nd1) return prt
classbTree: def__init__(self,degree=2): self.root = node() self.degree=degree self.nodeNum = 1 self.keyNum = 0 defsearch(self,key,withpath=False): nd = self.root fathers = [] whileTrue: i = nd.findKey(key) if i==len(nd): fathers.append((nd,i-1,i)) else: fathers.append((nd,i,i)) if i<len(nd) and nd[i]==key: if withpath:return nd,i,fathers else:return nd,i if nd.isLeafNode(): if withpath:returnNone,None,None else:returnNone,None nd = nd.getChd(i) definsert(self,key): if len(self.root)== self.degree*2-1: self.root = self.root.split(node(isLeaf=False),self.degree) self.nodeNum +=2 nd = self.root whileTrue: idx = nd.findKey(key) if idx<len(nd) and nd[idx] == key:return if nd.isLeafNode(): nd.insert(idx,key) self.keyNum+=1 return else: chd = nd.getChd(idx) if len(chd)== self.degree*2-1: #ensure its keys won't excess when its chd split and u nd = chd.split(nd,self.degree) self.nodeNum +=1 else: nd = chd defdelete(self,key):#to do '''search the key, delete it , and form down to up to rebalance it ''' nd,idx ,fathers= self.search(key,withpath=True) if nd isNone : return del nd[idx] self.keyNum-=1 ifnot nd.isLeafNode(): chd = nd.getChd(idx) # find the predecessor key whilenot chd.isLeafNode(): fathers.append((chd,len(chd)-1,len(chd))) chd = chd.getChd(-1) fathers.append((chd,len(chd)-1,len(chd))) nd.insert(idx,chd[-1]) del chd[-1] if len(fathers)>1:self.rebalance(fathers) defrebalance(self,fathers): nd,keyIdx,chdIdx = fathers.pop() while len(nd)<self.degree-1: # rebalance tree from down to up prt,keyIdx,chdIdx = fathers[-1] lbro = [] if chdIdx==0else prt.getChd(chdIdx-1) rbro = [] if chdIdx==len(prt) else prt.getChd(chdIdx+1) if len(lbro)<self.degree and len(rbro)<self.degree: # merge two deficient nodes beforeNode,afterNode = None,None if lbro ==[]: keyIdx = chdIdx beforeNode,afterNode = nd,rbro else: beforeNode,afterNode = lbro,nd keyIdx = chdIdx-1# important, when choosing keys = beforeNode[:]+[prt[keyIdx]]+afterNode[:] children = beforeNode.getChildren() + afterNode.getChildren() isLeaf = beforeNode.isLeafNode() prt.delChd(keyIdx+1) del prt[keyIdx] nd.update(keys,isLeaf,children) prt.children[keyIdx]=nd self.nodeNum -=1 elif len(lbro)>=self.degree: # rotate when only one sibling is deficient keyIdx = chdIdx-1 nd.insert(0,prt[keyIdx]) # rotate keys prt[keyIdx] = lbro[-1] del lbro[-1] ifnot nd.isLeafNode(): # if not leaf, move children nd.insert(0,nd=lbro.getChd(-1)) lbro.delChd(-1) else: keyIdx = chdIdx nd.insert(len(nd),prt[keyIdx]) # rotate keys prt[keyIdx] = rbro[0] del rbro[0] ifnot nd.isLeafNode(): # if not leaf, move children #note that insert(-1,ele) will make the ele be the last second one nd.insert(len(nd),nd=rbro.getChd(0)) rbro.delChd(0) if len(fathers)==1: if len(self.root)==0: self.root = nd self.nodeNum -=1 break nd,i,j = fathers.pop() def__str__(self): head= '\n'+'-'*30+'B Tree'+'-'*30 tail= '-'*30+'the end'+'-'*30+'\n' lst = [[head],[f'node num: {self.nodeNum}, key num: {self.keyNum}']] cur = [] ndNum =0 ndTotal= 1 que = [self.root] while que!=[]: nd = que.pop(0) cur.append(repr(nd)) ndNum+=1 que+=nd.getChildren() if ndNum==ndTotal: lst.append(cur) cur = [] ndNum = 0 ndTotal =len(que) lst.append([tail]) lst = [','.join(li) for li in lst] return'\n'.join(lst) def__iter__(self,nd = None): if nd isNone: nd = self.root que = [nd] while que !=[]: nd = que.pop(0) yield nd if nd.isLeafNode():continue for i in range(len(nd)+1): que.append(nd.getChd(i))
用在衍生函数中的索引号码是32位的整数。为了区分密钥是从正常衍生函数中衍生出来还是从强化衍生函数中产出，这个索引号被分为两个范围。索引号在0和2^31–1(0x0 to0x7FFFFFFF)之间的是只被用在常规衍生。索引号在2^31和2^32– 1(0x80000000 to 0xFFFFFFFF)之间的只被用在强化衍生。
一个典型的场景是，A 要发给 B 一份信息. A 先对文件进行摘要，然后用自己的私钥进行加密，将文件和加密串都发给B。B 收到文件和加密串后，用 A 的公钥来解密加密串，得到原始的数字摘要，跟对文件进行摘要后的结果进行比对。
9.4. 数字证书
数字证书用来证明某个公钥是谁的，并且内容是正确的。
数字证书内容可能包括版本、序列号、签名算法类型、签发者信息、有效期、被签发人、签发的公开密钥、CA 数字签名、其它信息等等，一般使用最广泛的标准为 ITU 和 ISO 联合制定的 X.509 规范。 其中，最重要的包括 签发的公开密钥 、 CA 数字签名 两个信息。因此，只要通过这个证书就能证明某个公钥是合法的，因为带有 CA 的数字签名。
把相同的秋随机投到 b 个盒子里,问在每个盒子里至少有一个球之前,平均至少要投多少个球? 称投入一个空盒为击中, 即求取得 b 次击中的概率 设投 n 次, 称第 i 个阶段包括第 i-1 次击中到 第 i 次击中的球, 则第 i 次击中的概率为 $p_i=\frac{b-i+1}{b}$ 用 $n_i$表示第 i 阶段的投球数,则 $n=\sum_{i=1}^b n_i$ 且 $n_i$服从几何分布, $E(n_i)=\frac{b}{b-i+1}$, 则由期望的线性性,
这个问题又被称为 赠券收集者问题(coupon collector’s problem),即集齐 b 种不同的赠券,在随机情况下平均需要买 blnb 张
8.2. 序列
抛 n 次硬币, 期望看到的连续正面的次数 答案是 $\Theta(logn)$ 记 长度至少为 k 的正面序列开始与第 i 次抛, 由于独立, 所有 k 次抛掷都是正面的 概率为 $P(A_{ik})=\frac{1}{2^k}$,对于 $k=2\lceil lgn\rceil$
9. 摊还分析
9.1. 聚合分析(aggregate analysis)
一个 n 个操作的序列最坏情况下花费的总时间为$T(n)$, 则在最坏情况下, 每个操作的摊还代价为 $\frac{T(n)}{n}$
如栈中的 push, pop 操作都是 $O(1)$, 增加一个新操作 multipop,
1 2 3 4
defmultipop(stk,k): whilenot stk.empty() and k>0: stk.pop() k-=1
RB-INSERT(T, z) y ← nil[T] // 新建节点“y”，将y设为空节点。 x ← root[T] // 设“红黑树T”的根节点为“x” while x ≠ nil[T] // 找出要插入的节点“z”在二叉树T中的位置“y” do y ← x if key[z] < key[x] then x ← left[x] else x ← right[x] p[z] ← y // 设置 “z的父亲” 为 “y” if y = nil[T] then root[T] ← z // 情况1：若y是空节点，则将z设为根 elseif key[z] < key[y] then left[y] ← z // 情况2：若“z所包含的值” < “y所包含的值”，则将z设为“y的左孩子” else right[y] ← z // 情况3：(“z所包含的值” >= “y所包含的值”)将z设为“y的右孩子” left[z] ← nil[T] // z的左孩子设为空 right[z] ← nil[T] // z的右孩子设为空。至此，已经完成将“节点z插入到二叉树”中了。 color[z] ← RED // 将z着色为“红色” RB-INSERT-FIXUP(T, z) // 通过RB-INSERT-FIXUP对红黑树的节点进行颜色修改以及旋转，让树T仍然是一颗红黑树
RB-INSERT-FIXUP(T, z) while color[p[z]] = RED // 若“当前节点(z)的父节点是红色”，则进行以下处理。 do if p[z] = left[p[p[z]]] // 若“z的父节点”是“z的祖父节点的左孩子”，则进行以下处理。 then y ← right[p[p[z]]] // 将y设置为“z的叔叔节点(z的祖父节点的右孩子)” if color[y] = RED // Case 1条件：叔叔是红色 then color[p[z]] ← BLACK ▹ Case 1 // (01) 将“父节点”设为黑色。 color[y] ← BLACK ▹ Case 1 // (02) 将“叔叔节点”设为黑色。 color[p[p[z]]] ← RED ▹ Case 1 // (03) 将“祖父节点”设为“红色”。 z ← p[p[z]] ▹ Case 1 // (04) 将“祖父节点”设为“当前节点”(红色节点) elseif z = right[p[z]] // Case 2条件：叔叔是黑色，且当前节点是右孩子 then z ← p[z] ▹ Case 2 // (01) 将“父节点”作为“新的当前节点”。 LEFT-ROTATE(T, z) ▹ Case 2 // (02) 以“新的当前节点”为支点进行左旋。 color[p[z]] ← BLACK ▹ Case 3 // Case 3条件：叔叔是黑色，且当前节点是左孩子。(01) 将“父节点”设为“黑色”。 color[p[p[z]]] ← RED ▹ Case 3 // (02) 将“祖父节点”设为“红色”。 RIGHT-ROTATE(T, p[p[z]]) ▹ Case 3 // (03) 以“祖父节点”为支点进行右旋。 else (same as then clause with"right"and"left" exchanged) // 若“z的父节点”是“z的祖父节点的右孩子”，将上面的操作中“right”和“left”交换位置，然后依次执行。 color[root[T]] ← BLACK
deffixUpInsert(self,parent,nd): ''' adjust color and level, there are two red nodes: the new one and its parent''' whilenot self.checkBlack(parent): grand = self.getParent(parent) isLeftPrt = grand.left is parent uncle = grand.getChild(not isLeftPrt) ifnot self.checkBlack(uncle): # case 1: new node's uncle is red self.setBlack(grand, False) self.setBlack(grand.left, True) self.setBlack(grand.right, True) nd = grand parent = self.getParent(nd) else: # case 2: new node's uncle is black(including nil leaf) isLeftNode = parent.left is nd if isLeftNode ^ isLeftPrt: # case 2.1 the new node is inserted in left-right or right-left form # grand grand # parent or parent # nd nd parent.setChild(nd.getChild(isLeftPrt),not isLeftPrt) nd.setChild(parent,isLeftPrt) grand.setChild(nd,isLeftPrt) nd,parent = parent,nd # case 2.2 the new node is inserted in left-left or right-right form # grand grand # parent or parent # nd nd grand.setChild(parent.getChild(not isLeftPrt),isLeftPrt) parent.setChild(grand,not isLeftPrt) self.setBlack(grand, False) self.setBlack(parent, True) self.transferParent(grand,parent) self.setBlack(self.root,True)
4. 删除
算法导论上的算法
写的很简练👍
4.1. 二叉查找树删除结点
下面 z 是要删除的结点, y 是 其后继或者是它自己, x 是 y 的一个孩子(如果 y 的孩子为 nil,则为 nli, 否则 y 只有一个非 nil 孩子, 为 x)
当 z 孩子全是 nil (y==z): 直接让其双亲对应的孩子为 nil
当 z 只有一个非 nil 孩子 x (y==z):
如果 z 为根, 则让 x 为根.
让 y 的双亲连接到 x
当 z 有两个非nil孩子(y!=z): 复制其后继 y 的内容到 z (除了指针,颜色) , 将其后继 y 的孩子(最多只有一个 非 nil ,不然就不是后继了)连接到其后继的双亲, 删除 其后继y,
即3 如果要删除有两个孩子的结点 z , 则找到它的后继y(前趋同理), 可以推断 y 一定没有左孩子, 右孩子可能有,可能没有. 也就是最多一个孩子. 所以将 y 的值复制到 x 位置, 现在相当于删除 y 处的结点. 这样就化为 删除的结点最多一个孩子的情况.
4.2. 调整颜色与旋转
可以发现只有当 y 是黑色,才进行颜色调整以及旋转(维持红黑性质), 因为如果删除的是红色, 不会影响黑高度, 所有红黑性质都不会破坏 伪代码如下, (我的python代码见文末)
defgetChild(self,isLeft): if isLeft: return self.left else: return self.right def__bool__(self): return self.val isnotNone def__str__(self): color = 'B'if self.isBlack else'R' val = '-'if self.parent==Noneelse self.parent.val returnf'{color}-{self.val}' def__repr__(self): returnf'node({self.val},isBlack={self.isBlack})' classredBlackTree: def__init__(self,unique=False): '''if unique is True, all node'vals are unique, else there may be equal vals''' self.root = None self.unique = unique
@staticmethod defcheckBlack(nd): return nd isNoneor nd.isBlack @staticmethod defsetBlack(nd,isBlack): if nd isnotNone: if isBlack isNoneor isBlack: nd.isBlack = True else:nd.isBlack = False defsetRoot(self,nd): if nd isnotNone: nd.parent=None self.root= nd deffind(self,val): nd = self.root while nd: if nd.val ==val: return nd else: nd = nd.getChild(nd.val>val) defgetSuccessor(self,nd): if nd: if nd.right: nd = nd.right while nd.left: nd = nd.left return nd else: while nd.parent isnotNoneand nd.parent.right is nd: nd = nd.parent returnNoneif nd is self.root else nd.parent defrotate(self,prt,chd): '''rotate prt with the center of chd''' if self.root is prt: self.setRoot(chd) else: prt.parent.setChild(chd, prt.parent.left is prt) isLeftChd = prt.left is chd prt.setChild(chd.getChild(not isLeftChd), isLeftChd) chd.setChild(prt,not isLeftChd)
definsert(self,nd): if nd.isBlack: nd.isBlack = False
if self.root isNone: self.setRoot(nd) self.root.isBlack = True else: parent = self.root while parent: if parent == nd : returnNone isLeft = parent > nd chd = parent.getChild(isLeft) if chd isNone: parent.setChild(nd,isLeft) break else: parent = chd self.fixUpInsert(parent,nd) deffixUpInsert(self,parent,nd): ''' adjust color and level, there are two red nodes: the new one and its parent''' whilenot self.checkBlack(parent): grand = parent.parent isLeftPrt = grand.left is parent uncle = grand.getChild(not isLeftPrt) ifnot self.checkBlack(uncle): # case 1: new node's uncle is red self.setBlack(grand, False) self.setBlack(grand.left, True) self.setBlack(grand.right, True) nd = grand parent = nd.parent else: # case 2: new node's uncle is black(including nil leaf) isLeftNode = parent.left is nd if isLeftNode ^ isLeftPrt: # case 2.1 the new node is inserted in left-right or right-left form # grand grand # parent or parent # nd nd self.rotate(parent,nd) #parent rotate nd,parent = parent,nd # case 3 (case 2.2) the new node is inserted in left-left or right-right form # grand grand # parent or parent # nd nd
defcopyNode(self,src,des): '''when deleting a node which has two kids, copy its succesor's data to his position data exclude left, right , isBlack ''' des.val = src.val defdelete(self,val): '''delete node in a binary search tree''' if isinstance(val,node): val = val.val nd = self.find(val) if nd isNone: return self._delete(nd) def_delete(self,nd): y = None if nd.left and nd.right: y= self.getSuccessor(nd) else: y = nd py = y.parent x = y.left if y.left else y.right if py isNone: self.setRoot(x) else: py.setChild(x,py.left is y) if y != nd: self.copyNode(y,nd) if self.checkBlack(y): self.fixUpDel(py,x)
deffixUpDel(self,prt,chd): ''' adjust colors and rotate ''' while self.root != chd and self.checkBlack(chd): isLeft =prt.left is chd brother = prt.getChild(not isLeft) # brother is black lb = self.checkBlack(brother.getChild(isLeft)) rb = self.checkBlack(brother.getChild(not isLeft)) ifnot self.checkBlack(brother): # case 1: brother is red. converted to case 2,3,4
elif lb and rb: # case 2: brother is black and two kids are black. # conveted to the begin case self.setBlack(brother,False) chd = prt prt= chd.parent else: if rb: # case 3: brother is black and left kid is red and right child is black # rotate bro to make g w wl wr in one line # uncle's son is nephew, and niece for uncle's daughter nephew = brother.getChild(isLeft) self.setBlack(nephew,True) self.setBlack(brother,False)
# case 4: brother is black and right child is red brother.isBlack = prt.isBlack self.setBlack(prt,True) self.setBlack(brother.getChild(not isLeft),True)
defsort(self,reverse = False): ''' return a generator of sorted data''' definOrder(root): if root isNone:return if reverse: yieldfrom inOrder(root.right) else: yieldfrom inOrder(root.left) yield root if reverse: yieldfrom inOrder(root.left) else: yieldfrom inOrder(root.right) yieldfrom inOrder(self.root)
defdisplay(self): defgetHeight(nd): if nd isNone:return0 return max(getHeight(nd.left),getHeight(nd.right)) +1 deflevelVisit(root): from collections import deque lst = deque([root]) level = [] h = getHeight(root) ct = lv = 0 while1: ct+=1 nd = lst.popleft() if ct >= 2**lv: lv+=1 if lv>h:break level.append([]) level[-1].append(str(nd)) if nd isnotNone: lst += [nd.left,nd.right] else: lst +=[None,None] return level defaddBlank(lines): width = 1+len(str(self.root)) sep = ' '*width n = len(lines) for i,oneline in enumerate(lines): k = 2**(n-i) -1 new = [sep*((k-1)//2)] for s in oneline: new.append(s.ljust(width)) new.append(sep*k) lines[i] = new return lines
lines = levelVisit(self.root) lines = addBlank(lines) li = [''.join(line) for line in lines] length = 10if li==[] else max(len(i) for i in li)//2 begin ='\n'+ 'red-black-tree'.rjust(length+14,'-') + '-'*(length) end = '-'*(length*2+14)+'\n' return'\n'.join([begin,*li,end]) def__str__(self): return self.display()
defgenNum(n =10): nums =[] for i in range(n): while1: d = randint(0,100) if d notin nums: nums.append(d) break return nums
defbuildTree(n=10,nums=None,visitor=None): if nums isNoneor nums ==[]: nums = genNum(n) rbtree = redBlackTree() print(f'build a red-black tree using {nums}') for i in nums: rbtree.insert(node(i)) if visitor: visitor(rbtree,i) return rbtree,nums deftestInsert(nums=None): defvisitor(t,val): print('inserting', val) print(t) rbtree,nums = buildTree(visitor = visitor,nums=nums) print('-'*5+ 'in-order visit' + '-'*5) for i,j in enumerate(rbtree.sort()): print(f'{i+1}: {j}')
deftestSuc(nums=None): rbtree,nums = buildTree(nums=nums) for i in rbtree.sort(): print(f'{i}\'s suc is {rbtree.getSuccessor(i)}')
deftestDelete(nums=None): rbtree,nums = buildTree(nums = nums) print(rbtree) for i in sorted(nums): print(f'deleting {i}') rbtree.delete(i) print(rbtree)
@total_ordering classnode: def__init__(self,low,high,left=None,right=None,isBlack=False): self.val = low # self.val is the low self.high = high self.max = high self.left = left self.right = right self.parent=None self.isBlack = isBlack def__lt__(self,nd): return self.val < nd.val def__eq__(self,nd): return nd isnotNoneand self.val == nd.val defsetChild(self,nd,isLeft = True): if isLeft: self.left = nd else: self.right = nd if nd isnotNone: nd.parent = self defgetChild(self,isLeft): if isLeft: return self.left else: return self.right def__bool__(self): return self.val isnotNone def__str__(self): color = 'B'if self.isBlack else'R' returnf'{color}[{self.val},{self.high}]-{self.max}' def__repr__(self): returnf'intervalNode({self.val},{self.high},{self.max},isBlack={self.isBlack})' defoverlap(self,low,high): return self.val<=high and self.high>=low defsetMax(self): l = 0if self.left isNoneelse self.left.max r = 0if self.right isNoneelse self.right.max self.max = max(self.high, l, r) return self.max
classintervalTree(redBlackTree): defsearch(self,low,high): nd = self.root while nd isnotNoneandnot nd.overlap(low,high): if nd.left isnotNoneand nd.left.max>=low: nd = nd.left else:nd = nd.right return nd definsert(self,nd): super(intervalTree,self).insert(nd) while nd isnotNone: nd.setMax() nd = nd.parent defdelete(self,val): nd = self.find(val) if nd isnotNone: nd.max = 0 tmp = nd.parent while tmp isnotNone: tmp.setMax() tmp = tmp.parent super(intervalTree,self).delete(val) defrotate(self,prt,chd): '''rotate prt, and return new prt, namyly the original chd''' super(intervalTree,self).rotate(prt,chd) prt.setMax() chd.setMax() defcopyNode(self,src,des): des.val = src.val des.high = src.high des.setMax()
from random import randint, shuffle defgenNum(n =10,upper=10): nums ={} for i in range(n): while1: d = randint(0,100) if d notin nums: nums[d] = (d,randint(d,d+upper)) break return nums.values()
defbuildTree(n=10,nums=None,visitor=None): #if nums is None or nums ==[]: nums = genNum(n) tree = intervalTree() print(f'build a red-black tree using {nums}') for i in nums: tree.insert(node(*i)) if visitor: visitor(tree,i) return tree,nums deftestInsert(nums=None): defvisitor(t,val): print('inserting', val) print(t) tree,nums = buildTree(visitor = visitor,nums=nums) print('-'*5+ 'in-order visit' + '-'*5) for i,j in enumerate(tree.sort()): print(f'{i+1}: {j}') return tree
deftestSuc(nums=None): tree,nums = buildTree(nums=nums) for i in tree.sort(): print(f'{i}\'s suc is {tree.getSuccessor(i)}')
deftestDelete(nums=None): tree,nums = buildTree(nums = nums) print(tree) for i in nums: print(f'deleting {i}') tree.delete(i[0]) print(tree) return tree
if __name__=='__main__': lst = [(0,3),(5,8),(6,10),(26,26),(25,30),(8,9),(19,20),(15,23),(16,21),(17,19)] #lst = None #testSuc(lst) tree = testInsert(lst) #tree,_= buildTree(lst) while1: a =int( input('low:')) b =int( input('high:')) res = tree.search(a,b) print(res)from redBlackTree import redBlackTree
definsert(self, word): """ Inserts a word into the trie. :type word: str :rtype: void """ ifnot word:return nd = self.root for i in word: if i in nd: nd = nd[i] else: newNode= node(i) nd[i] = newNode nd = newNode else:nd.isKey = True defsearch(self, word,matchAll='.'): """support matchall function eg, 'p.d' matchs 'pad' , 'pid' """ self.matchAll = '.' return self._search(self.root,word) def_search(self,nd,word): for idx,i in enumerate(word): if i==self.matchAll : for j in nd: bl =self._search(nd[j],word[idx+1:]) if bl:returnTrue else:returnFalse if i in nd: nd = nd[i] else:returnFalse else:return nd.isKey defstartsWith(self, prefix): """ Returns if there is any word in the trie that starts with the given prefix. :type prefix: str :rtype: bool """ nd = self.root for i in prefix: if i in nd: nd= nd[i] else:returnFalse returnTrue defdisplay(self): print('preOrderTraverse data of the Trie') self.preOrder(self.root,'') defpreOrder(self,root,s): s=s+root.val if root.isKey: print(s) for i in root: self.preOrder(root[i],s)
classwinnerTree: '''if i<lowExt p = (i+offset)//2 else p = (i+n-1-lowExt)//2 offset is a num 2^k-1 just bigger than n p is the index of tree i is the index of players lowExt is the double node num of the lowest layer of the tree ''' def__init__(self,players,reverse=False): self.n=len(players) self.tree = [0]*self.n players.insert(0,0) self.players=players self.reverse=reverse self.getNum() self.initTree(1) defgetNum(self): i=1 while2*i< self.n:i=i*2 if2*i ==self. n: self.lowExt=0 self.s = 2*i-1 else: self.lowExt = (self.n-i)*2 self.s = i-1 self.offset = 2*i-1 deftreeToArray(self,p): return2*p-self.offset if p>self.s else2*p+self.lowExt-self.n+1 defarrayToTree(self,i): return (i+self.offset)//2if i<=self.lowExt else (i-self.lowExt+ self.n-1)//2 defwin(self,a,b): return a<b if self.reverse else a>b definitTree(self,p): if p>=self.n: delta = p%2#!!! good job notice delta mark the lchild or rchlid return self.players[self.treeToArray(p//2)+delta] l = self.initTree(2*p) r = self.initTree(2*p+1) self.tree[p] = l if self.win(l,r) else r return self.tree[p] defwinner(self): idx = 1 while2*idx<self.n: idx = 2*idx if self.tree[2*idx] == self.tree[idx] else idx*2+1 num = self.treeToArray(idx) num = num+1if self.players[num] !=self.tree[1] else num return self.tree[1],num defgetOppo(self,i,x,p): oppo=None if2*p<self.n:oppo=self.tree[2*p] elif i<=self.lowExt:oppo=self.players[i-1+i%2*2] else: lpl= self.players[2*p+self.lowExt-self.n+1] oppo = lpl if lpl!=x else self.players[2*p+self.lowExt-self.n+2] return oppo defupdate(self,i,x): ''' i is 1-indexed which is the num of player and x is the new val of the player ''' self.players[i]=x p = self.arrayToTree(i) oppo =self.getOppo(i,x,p) self.tree[p] = x if self.win(x,oppo) else oppo p=p//2 while p: l = self.tree[p*2] r = None if2*p+1<self.n:r=self.tree[p*2+1] #notice this !!! else:r = self.players[2*p+self.lowExt-self.n+1] self.tree[p] = l if self.win(l,r) else r p=p//2
from functools import total_ordering @total_ordering
classnode: def__init__(self,val,freq=1,s=1,left=None,right=None): self.val=val self.freq=freq self.s=s if left isNoneor right isNone: self.left = left if left isnotNoneelse right self.right =None else: if left.s<right.s: left,right =right, left self.left=left self.right=right self.s+=self.right.s def__eq__(self,nd): return self.val==nd.val def__lt__(self,nd): return self.val<nd.val def__repr__(self): return'node(val=%d,freq=%d,s=%d)'%(self.val,self.freq,self.s)
classleftHeap: def__init__(self,root=None): self.root=root def__bool__(self): return self.root isnotNone @staticmethod def_merge(root,t):#-> int if root isNone:return t if t isNone:return root if root<t: root,t=t,root root.right = leftHeap._merge(root.right,t) if root.left isNoneor root.right isNone: root.s=1 if root.left isNone: root.left,root.right = root.right,None else: if root.left.s<root.right.s: root.left,root.right = root.right,root.left root.s = root.right.s+1 return root definsert(self,nd): ifnot isinstance(nd,node):nd = node(nd) if self.root isNone: self.root=nd return if self.root==nd: self.root.freq+=1 return prt =self. _findPrt(self.root,nd,None) if prt isNone: self.root=leftHeap._merge(self.root,nd) else : if prt.left==nd: prt.left.freq+=1 else:prt.right.freq+=1 defremove(self,nd): ifnot isinstance(nd,node):nd = node(nd) if self.root==nd: self.root=leftHeap._merge(self.root.left,self.root.right) else: prt = self._findPrt(self.root,nd,None) if prt isnotNone: if prt.left==nd: prt.left=leftHeap._merge(prt.left.left,prt.left.right) else: prt.right=leftHeap._merge(prt.right.left,prt.right.right) deffind(self,nd): ifnot isinstance(nd,node):nd = node(nd) prt = self._findPrt(self.root,nd,self.root) if prt isNoneor prt==nd:return prt elif prt.left==nd:return prt.left else:return prt.right def_findPrt(self,root,nd,parent): ifnot isinstance(nd,node):nd = node(nd) if root isNoneor root<nd:returnNone if root==nd:return parent l=self._findPrt(root.left,nd,root) return l if l isnotNoneelse self._findPrt(root.right,nd,root) defgetTop(self): return self.root defpop(self): nd = self.root self.remove(self.root.val) return nd deflevelTraverse(self): li = [(self.root,0)] cur=0 while li: nd,lv = li.pop(0) if cur<lv: cur=lv print() print(nd,end=' ') else:print(nd,end=' ') if nd.left isnotNone:li.append((nd.left,lv+1)) if nd.right isnotNone:li.append((nd.right,lv+1))
classitem: def__init__(self,key,val,nextItem=None): self.key = key self.val = val self.next = nextItem defto(self,it): self.next = it def__eq__(self,it): '''using keyword <in> ''' return self.key == it.key def__bool__(self): return self.key isnotNone def__str__(self): li = [] nd = self while nd: li.append(f'({nd.key}:{nd.val})') nd = nd.next return' -> '.join(li) def__repr__(self): returnf'item({self.key},{self.val})' classhashTable: def__init__(self,size=100): self.size = size self.slots=[item(None,None) for i in range(self.size)] def__setitem__(self,key,val): nd = self.slots[self.myhash(key)] while nd.next: if nd.key ==key: if nd.val!=val: nd.val=val return nd = nd.next nd.next = item(key,val)
defmyhash(self,key): if isinstance(key,str): key = sum(ord(i) for i in key) ifnot isinstance(key,int): key = hash(key) return key % self.size def__iter__(self): '''when using keyword <in>, such as ' if key in dic', the dic's __iter__ method will be called,(if hasn't, calls __getitem__ then ~iterate~ dic's keys to compare whether one equls to the key ''' for nd in self.slots: nd = nd.next while nd : yield nd.key nd = nd.next def__getitem__(self,key): nd =self.slots[ self.myhash(key)].next while nd: if nd.key==key: return nd.val nd = nd.next raise Exception(f'[KeyError]: {self.__class__.__name__} has no key {key}')
def__delitem__(self,key): '''note that None item and item(None,None) differ with each other, which means you should take care of them and correctly cop with None item especially when deleting items ''' n = self.myhash(key) nd = self.slots[n].next if nd.key == key: if nd.next isNone: self.slots[n] = item(None,None) # be careful else:self.slots[n] = nd.next return while nd: if nd.next isNone: break# necessary if nd.next.key ==key: nd.next = nd.next.next nd = nd.next def__str__(self): li = ['\n\n'+'-'*5+'hashTable'+'-'*5] for i,nd in enumerate(self.slots): li.append(f'{i}: '+str(nd.next)) return'\n'.join(li)
def shellSort(s,inc = None): if inc is None: inc = [1,3,5,7,11,13,17,19] num = len(s) inc.sort(reverse=True) for i in inc: for j in range(i,num): cur = j while cur>=i and s[j] > s[cur-i]: s[cur] = s[cur-i] cur-=i s[cur] = s[j] return s
defcmp(n1,n2,reverse=False): fac = -1if reverse else1 if n1 < n2: return -fac elif n1 > n2: return fac return0
defheapify(lst,reverse = False): for i in range(len(lst)): lst = one_heapify(lst,i,reverse) return lst defone_heapify(lst,cur,reverse = False): cur +=1 while cur>1: chd = cur-1 prt = cur//2-1 if cmp(lst[prt],lst[chd],reverse)<0: break lst[prt],lst[chd] = lst[chd], lst[prt] cur = prt+1 return lst defheapSort(lst,reverse = False): lst = lst.copy() hp = heap(lst,reverse) ret = [] while hp: ret.append(hp.popTop()) return ret
if __name__ == '__main__': from random import randint n = randint(10,20) lst = [randint(0,100) for i in range(n)] print('random : ', lst) print('small-heap: ', heapify(lst)) print('big-heap : ', heapify(lst,True)) print('ascend : ', heapSort(lst)) print('descend : ', heapSort(lst,True))
defpartition(a,b): pivot = lst[a] while a!=b: while a<b and lst[b]>pivot: b-=1 if a<b: lst[a] = lst[b] a+=1 while a<b and lst[a]<pivot: a+=1 if a<b: lst[b] = lst[a] b-=1 lst[a] = pivot return a
第二种实现
1 2 3 4 5 6 7 8 9
defpartition(a,b): pivot = lst[b] j = a-1 for i in range(a,b): if lst[i]<=pivot: j+=1 if i!=j: lst[i], lst[j] = lst[j], lst[i] lst[j+1],lst[b] = lst[b],lst[j+1] return j+1
defcountSort(lst,mn,mx): mark = [0]*(mx-mn+1) for i in lst: mark[i-mn]+=1 ret =[] for n,i in enumerate(mark): for j in range(i): ret.append(n+mn) return ret
基数排序有点不一样, 它是从低位比到高位, 这样才能把相同位有相同值的不同数排序. 对于 n 个数, 最高 d 位, 用下面的实现, 可时间复杂度为 $\Theta((n+d)*d)$
5.2. 实现
下面是一个整数版本的基数排序,比较容易实现
1 2 3 4 5 6 7 8 9 10 11
defradixSort(lst,radix=10): ls = [[] for i in range(radix)] mx = max(lst) weight = 1 while mx >= weight: for i in lst: ls[(i // weight)%radix].append(i) weight *= radix lst = sum(ls,[]) ls = [[] for i in range(radix)] return lst
from time import time from random import randint deftimer(funcs,span,num=1000000): lst = [randint(0,span) for i in range(num)] print('range({}), {} items'.format(span,num)) for func in funcs: data = lst.copy() t = time() func(data) t = time()-t print('{}: {}s'.format(func.__name__,t))
if __name__ == '__main__': timer([quickSort,radixSort],1000000000,100000) timer([quickSort,radixSort],1000000000000,10000) timer([quickSort,radixSort],10000,100000)
6. 桶排序(bucketSort)
适用于均匀分布的序列
设有 n 个元素, 则设立 n 个桶 将各元素通过数值线性映射到桶地址, 类似 hash 链表. 然后在每个桶内, 进行插入排序($O(n_i^2)$) 最后合并所有桶. 这里的特点是 n 个桶实现了 $\Theta(n)$的时间复杂度, 但是耗费的空间 为 $\Theta(n)$
from random import randint defselect(lst,i): lst = lst.copy() defpartition(a,b): pivot = lst[a] while a<b: while a<b and lst[b]>pivot: b-=1 if a<b: lst[a] = lst[b] a+=1 while a<b and lst[a]<pivot: a+=1 if a<b: lst[b] = lst[a] b-=1 lst[a]= pivot return a
def_select(a,b): if a>=b: return lst[a] # randomized select n = randint(a,b) lst[a],lst[n] = lst[n],lst[a] pos = partition(a,b) if pos>i: return _select(a,pos-1) elif pos<i: return _select(pos+1,b) else:return lst[pos] return _select(0,len(lst)-1)
