가입 기반 트리 알고리즘

컴퓨터 과학에서 조인 기반 트리 알고리즘은 이진 검색 트리의 자체 균형을 맞추기 위한 알고리즘 클래스입니다.이 프레임워크는 다양한 균형 잡힌 이진 검색 트리에 대해 고도로 병렬화된 알고리즘을 설계하는 것을 목표로 합니다.알고리즘 프레임워크는 단일 조작 ^[1]결합을 기반으로 합니다.이 프레임워크에서는 join 조작에 의해 다른 밸런싱 방식의 모든 밸런싱 기준이 캡처되며 다른 모든 기능 join에는 다른 밸런싱 방식 간에 일반적인 구현이 이루어집니다.가입 기반 알고리즘은 적어도4개의 밸런싱 방식에 적용할 수 있습니다.AVL 나무, 적색-검은색 나무, 무게 균형이 잡힌 나무 및 나무 꼭대기.

결합 $(L,k,R)$ , $(L,k,R)$ , $(L,k,R)$ ) { $displaystyle ( L$ , $k$ , $R )$ } takes takes 、 k scheme scheme scheme scheme scheme binary binary binary binary binary binary binary binary binary binary balanced2개의 바이너리 밸런스 $트리$ L { $displaystyle$ R }과 $L$ $R$ 키 $k$ { $displaystyle$ k $k$ 를 $(L,k,R)$ 입력으로 하여 순차적으로 트래버스가 이루어지는 새로운 밸런스드 바이너리 $트리$ t{ $displaystyle$ t $}$ 를 $t$ 출력합니다.L $(\displaystyle$ L $L$ 의 L(\ $displaystyle$ K $)$ 의 $k$ 다음R $(\displaystyle$ R $R$ 의 순서대로 트래버스가 이루어집니다.특히 트리가 검색 트리인 경우, 트리의 순서가 키의 전체 순서를 유지하는 L $(\displaystyle$ L $)$ 의 $L$ 모든 키가 $k$ 보다 작다는 조건을 충족해야 합니다.{\ $displaystyle$ k $}$ 및 $k$ R {\ $displaystyle$ R $}$ 의 $R$ 모든 키가k {\ $displaystyle$ k $k$ 보다 큽니다 $.$

역사

가입 연산은 Tarjan에 의해 최악의 경우 로그 시간으로 실행되는 빨간색-검은색 트리에 대해 처음 정의되었습니다.이후 Sleator와 Tarjan은 상각된 로그 시간으로 실행되는 스플레이 트리의 결합 알고리즘을 설명했습니다.이후 애덤스는 무게 균형 나무까지 결합을 확장하여 결합, 교차 및 집합 차이를 포함한 빠른 집합 집합 기능에 사용했다.1998년 Belloch와 Reid-Miller는 treaps에 대한 결합을 확장하여m\ $displaystyle$ m $}$ 및 $m$ $tfrac$ { $n$ $})$ $크기$ 의 $트리$ 2개에 대해 설정 함수의 경계를 O $m$ ( $1$ + { \ $tfrac {n}$ { $m$ $}$ )로 $O(m\log(1+{\tfrac {n}{m}}))$ $O(m\log(1+{\tfrac {n}{m}}))$ 했습니다.그들은 또한 분할-정복 방식을 사용하여 애덤스의 알고리즘에서 병렬화를 이끌어냈다.2016년 Bleloch 등은 공식적으로 결합 기반 알고리즘을 제안했고, 4가지 다른 균형 체계에 대한 결합 알고리즘을 공식화했다.AVL 나무, 적색-검은색 나무, 무게 균형이 잡힌 나무 및 나무 꼭대기.같은 연구에서 그들은 결합, 교차 및 차이에 대한 애덤스의 알고리즘이 네 가지 균형 체계 모두에 대해 작업 최적이라는 것을 증명했다.

결합 알고리즘

함수 $(t_{1},k,t_{2})$ join ( $(t_{1},k,t_{2})$ 1, $(t_{1},k,t_{2})$ , $(t_{1},k,t_{2})$ $){$ $displaystyle$ ( $t_{1}$ , $k$ , $t_{2}$ }는 $(t_{1},k,t_{2})$ 트리의 재밸런싱을 고려하기 때문에 입력 밸런싱 방식에 따라 달라집니다.2개의 트리가 균형을 이룬 경우 join은 단순히 왼쪽 $서브트리 1$ t, $루트$ k 및 오른쪽 $서브트리 2$ t를 가진 새로운 노드를 만듭니다. $t$ 가₁ $t$ 보다₂ 무겁다고 가정합니다(이 "더 무겁다"는 균형 조정 방법에 따라 다름). 다른 경우에는 대칭입니다.조인(join)은 t와 $균형$ 을₂ 이루는 $노드$ c가 될 $때$ 까지₁ t의 오른쪽 척추를 따릅니다.이 시점에서 c를 대체할 왼쪽 자식 c, $루트$ k 및 오른쪽 $자식 2$ t를 $가진$ 새로운 노드가 생성됩니다.새 노드로 인해 밸런싱 불변성이 비활성화될 수 있습니다.이것은 회전으로 고정할 수 있습니다.

다음으로 다양한 밸런싱 방식에서의 Join 알고리즘을 나타냅니다.

AVL 트리의 Join 알고리즘은 다음과 같습니다.

함수 joinRightAVL(T_L, k, T_R)(l, k', c): = exposure(T)의_L 경우 h(T_R') + h(l) + 1 리턴 노드(l, k', T')의 경우 = 노드(c, k_R, T')의 경우 반환 노드(l, return node)(왼쪽 노드)의 경우 반환)AVL(c, k, T_R) T : = 노드(l, k', T') h(l) + 1 반환 T이면 rotateLeft(T) 함수 joinLeftAVL(T_L, k, T_R) /* 대칭을 반환하여 오른쪽 결합합니다.h(T_L)> h(T_R)+1return RightAVL(T_L, k, T_R)의 경우 AVL */ 함수 join(T_L_L, k, T_R)의 경우 h(T_R)> h(T_L)+1return Join LeftAVL(T_L, k, T_R_R)의 경우, T를 반환한다.

장소:

$h(v)$ ( $h(v)$ $){$ $displaystyle$ h $(v)}$ 는 $h(v)$ $노드$ v ${$ $displaystyle$ v $v$ 의 높이입니다.
${\text{expose}}(v)$ exposure ${\text{expose}}(v)$ ) \ $displaystyle$ { $text$ { ${\text{expose}}(v)$ } : ( $v$ ) \ $displaystyle$ l $l$ 、 $k$ \ $displaystyle$ k $v$ $k$ 、 child child ${\text{expose}}(v)$ child child child $child$ child child r r $r$ $expose$ 、 l $(l,k,r)$ , $(l,k,r)$ , $(l,k,r)$ r $){$ $displaystyle$ $(l,k,r)$ , $k$ , $r$ ) $(l,k,r)$ 。
${\text{Node}}(l,k,r)$ creates a node with left child $l$ , key $k$ , and right child $r$ .

레드-블랙 트리의 결합 알고리즘:

만약 r(TL))⌊r(TR)/2⌋×2반환 Node(TL, ⟨k, red⟩, TR) 다른(L'⟨k의, c'⟩, R')기능:= expose(TL)T자형:=Node(L'⟨k의, c'⟩,(R',joinRightRB k, TR)한 경우-c'=및 T'.right.color)T'.right.right.color) 붉은 색 T'.right.right.color 검은:(T. 검은 반환 rotateLeft = joinRightRB(TL, k, TR)의)만약(T'.color) 붉은 색)과(T'.right.color) 붉은 색)T'.color: 검은 수익률 T은 만약 ⌊r(TR)/2⌋>⌊r(TL)/2⌋×2/* 대칭*/= 그밖에도 T'함수 joinLeftRB(TL, k, TR)/**/기능 join(TL, k, TR)만약 ⌊r(TL)/2⌋ 을 joinRightRB에 대칭, ⌊r(TR)/2⌋×2T자형:=joinRightRB(TL, k, TR)하고 있다.  다른 만약 TL.색상 = 검은색 및 T_R = 검은색 반환 노드(T_L, "k, 빨간색", T_R) 그렇지 않으면 노드(T_L, "k, 검은색", T_R)가 반환됩니다.

장소:

$r(v)$ $v$ 의 r $r(v)$ ( $r(v)$ $){$ $displaystyle$ r $(v)}$ 는 $r(v)$ $v$ 검은색 노드의 2배, 빨간색 노드의 2배를 의미합니다.
${\text{expose}}(v)$ exposure ${\text{expose}}(v)$ ( $v$ ) \ $displaystyle$ { $text$ { } ( v ${\text{expose}}(v)$ ) \ $displaystyle$ l $(l,\langle k,c\rangle ,r)$ 、 $k$ \ $displaystyle$ k $(l,\langle k,c\rangle ,r)$ 、 $c$ \ $displaystyle$ $c$ $}$ $(l,\langle k,c\rangle ,r)$ ${\text{expose}}(v)$ $r$ expose $v$ $child$ child child child child $expose$ expose expose expose $(l,\langle k,c\rangle ,r)$ l , k 、 $(l,\langle k,c\rangle ,r)$ $r 、 k$ r r r r r r r r r r r r r r $rlelelele$ r r r r r r $rlelelelelelelelelele$ expose expose expose expose expose expose expose expose expose expose expose expose expose expose expose expose expose expose expose expose $}}}$ expose $expose$ expose expose expose expose
$노드$ l , ${\text{Node}}(l,\langle k,c\rangle ,r)$ k , ${\text{Node}}(l,\langle k,c\rangle ,r)$ ${\text{Node}}(l,\langle k,c\rangle ,r)$ , ${\text{Node}}(l,\langle k,c\rangle ,r)$ ) { $displaystyle$ { $node$ } ( l , \ $langle$ k , $c$ \ $r$ ) $k$ 、 $k$ \ $displaystyle$ k $color$ c \ $displaystyle$ c $、$ r ) child child child child child $child$ r r r r $、$ \ $displaystyle$ r $r$ 。

무게 균형 트리의 결합 알고리즘:

함수 joinRightWB(T_L, k, T_R)(l, k', c): w(T_L) =_α w(T_R)가 노드(T_L_L, k, T_R)를 반환하고, T':= joinRightWB(c₁, k, T_R) (l₁, k₁, r) : w(l) =_α_α w(T')가 노드(l, k', T')를 반환하는 경우 w(l) = w₁(l) 및 w(l)+w(l₁) =_α w(r₁) return RotateLeft(l, relse) K')를 반환하는 경우 = 노출(T')w(T_L_R)_α > w(T_R)가 joinRightWB(T_L, k, T_R)를 반환하는 경우 w(T)_α > w(T_L)가 joinLeftWB(T_L, k, T_R)를 반환하는 경우 WB */ 함수 join(T_L, k, T_R)이 반환되는 경우 노드(T_L, k, T_R)를 반환한다.

장소:

$w(v)$ ( $w(v)$ ) $w(v)$ { $displaystyle$ w $(v)$ }는 $w(v)$ 노드v {\ $displaystyle$ v $v$ 의 무게입니다.
$w_{1}=_{\alpha }w_{2}$ 1 $=$ $w_{1}=_{\alpha }w_{2}$ w $w_{1}=_{\alpha }w_{2}$ {\ $displaystyle w_{1$ }= $_{\alpha} w_{2$ }}는 $w_{1}=_{\alpha }w_{2}$ $w_{1}$ $w_{2}$ $w_{1}$ 1 $w_{1}$ { $displaystyle w_{1$ }}, $w_{2}$ 2 {\ $displaystyle w_{$ 2 $w_{2}$ }}는 무게 밸런스가 α인 것을 의미합니다.
$w_{1}>_{\alpha }w_{2}$ 1 $w_{1}>_{\alpha }w_{2}$ > $w_{1}>_{\alpha }w_{2}$ $w_{1}>_{\alpha }w_{2}$ 2 $w_{1}>_{\alpha }w_{2}$ {\ $displaystyle w_{1}$ > $_{\alpha$ } $w_{2$ } }는 $w_{1}>_{\alpha }w_{2}$ $w_{1}$ 무게 $w_{1}$ 1 $w_{1}$ { $displaystyle$ $w_{$ $1}$ α-weight-balance에 대한 $w_{2}$ $w_{2}$ 2 ${{$ 보다 $w_{2}$ 무거운 것을 의미합니다.
${\text{expose}}(v)$ exposure ${\text{expose}}(v)$ ) \ $displaystyle$ { $text$ { ${\text{expose}}(v)$ } : ( $v$ ) \ $displaystyle$ l $l$ 、 $k$ \ $displaystyle$ k $v$ $k$ 、 child child ${\text{expose}}(v)$ child child child $child$ child child r r $r$ $expose$ 、 l $(l,k,r)$ , $(l,k,r)$ , $(l,k,r)$ r $){$ $displaystyle$ $(l,k,r)$ , $k$ , $r$ ) $(l,k,r)$ 。
${\text{Node}}(l,k,r)$ l ${\text{Node}}(l,k,r)$ , ${\text{Node}}(l,k,r)$ , ${\text{Node}}(l,k,r)$ ) { $style$ { $display$ { $Node$ $}$ ( l , $k$ , $r$ ) $k$ node node node $node$ r r $、$ k\ $display style$ k、 r $k$ \ $display style$ r $r$ ） left left left노드를 만듭니다.

가입 기반 알고리즘

다음 중 ${\text{expose}}(v)$ exposure ( $v$ ) \ $style {$ display { $expose$ } ( $v$ )는 ${\text{expose}}(v)$ $r$ 노드v의 $v$ $왼쪽$ $아이$ l \ $display$ $style$ l $l$ , k\ $display style$ k $}$ $(l,k,r)$ $및$ 오른쪽 $아이$ r \ $displaystyle$ $(l,k,r)$ r을 tuple $(l,k,r)$ ( $(l,k,r)$ , $k$ , k ${\text{Node}}(l,k,r)$ $r$ ) ${\text{Node}}(l,k,r)$ ${\text{Node}}(l,k,r)$ , ${\text{Node}}(l,k,r)$ k , ${\text{Node}}(l,k,r)$ $(l,k,r)$ $)$ 에 추출합니다. ${Node}}(l,k,r)$ 는 ${\text{Node}}(l,k,r)$ 왼쪽 $자식$ l(\ $displaystyle$ l $l$ $키$ k(\ $displaystyle$ k $)$ 및 $k$ $s_{2}$ $자식$ r $(\displaystyle$ r $r$ 을 가진 노드를 만듭니다. $s_{1}||s_{2}$ 1 $s_{1}||s_{2}$ $s_{1}||s_{2}$ (\ $displaystyle$ $s_$ ${$ $1$ } $s_{2}$ ${$ $2$ " " " " 는 2개의 $s_{2}$ $s_{1}$ 이 병렬로 실행됨을 의미합니다 $.$

분열되다

트리를 키 x보다 작은 트리와 키 x보다 큰 트리로 분할하려면 먼저 x를 트리에 삽입하여 루트 경로를 그립니다.이 삽입 후 x보다 작은 값은 모두 경로 왼쪽에 있고 x보다 큰 값은 모두 오른쪽에 있습니다.Join을 적용하면 패스의 키를 아래에서 위로 중간 노드로 하여 왼쪽의 모든 서브트리가 아래쪽에서 위로 병합되어 왼쪽 트리가 형성되고 오른쪽 부분이 비대칭이 됩니다.일부 응용 프로그램의 경우 분할은 트리에 x가 표시되는지 여부를 나타내는 부울 값도 반환합니다.분할 비용은 $O(\log n)$ ( $O(\log n)$ n $O(\log n)$ ) \ $displaystyle$ O ( \ $log$ n ) $O(\log n)$ 、트리의 높이 순서입니다.

분할 알고리즘은 다음과 같습니다.

기능 split(T, km그리고 4.9초 만)만약(T=nil)반환(영, 거짓, nil)그 밖의 다른(L, m, R):k< expose(T)=;입니다 나이(L', b, R'):)split(L, km그리고 4.9초 만)반환(L', b,(R', m, R에 가입하)= 다른 경우 k입니다.;입니다 나이(L', b, R'):split(R, km그리고 4.9초 만)대가((L, m, L'에 가입하), b, R'=)) 다른 반환(L, true,.R)

참가2

이 함수는 조인(join)과 유사하게 정의되지만 중간 키는 없습니다.먼저 왼쪽 트리의 마지막 키 $k$ (\ $style$ k)를 $k$ 분리한 후 왼쪽 트리의 나머지 부분을 오른쪽 트리와 $k$ (\ $style$ k $k$ 로 연결합니다.알고리즘은 다음과 같습니다.

함수 splitLast(T) (L, k, R) : R = nile return (L, k'), = splitLast(R) return (T', k') : = splitLast(R) return (L, k', k'), k') 함수 join2(L = nill return (그렇지 않으면 R') : = nill return (L)

n $크기$ 트리의 경우 비용은 O $O(\log n)$ n $O(\log n)$ )(\ $displaystyle$ O $(\log$ n $n$ 입니다 $O(\log n)$ .

삽입 및 삭제

조인 사용 시 삽입 및 삭제 알고리즘은 밸런싱 방식과는 무관할 수 있습니다.삽입의 경우 알고리즘은 삽입할 키를 루트 내의 키와 비교하여 키가 루트 내의 키보다 작거나 큰 경우 왼쪽/오른쪽 서브트리에 삽입하고 루트와 함께 2개의 서브트리를 결합합니다.삭제는 삭제할 키와 루트의 키를 비교합니다.같은 경우 2개의 서브트리에서 join2를 반환합니다.그렇지 않으면 대응하는 서브트리에서 키를 삭제하고 2개의 서브트리를 루트로 다시 결합합니다.알고리즘은 다음과 같습니다.

만약 k< 기능 insert(T, km그리고 4.9초 만)만약 T=수 Node(영, k, nil) 다른(L, k', R):, k의 남측 귀환 join(삽입(L,k), k', R) 다른 경우 k입니다.;k의 남측 귀환 join(L, k'삽입(R, km그리고 4.9초 만)) 다른 만약 T=수 제로 다른 T기능 delete(T, km그리고 4.9초 만) 돌아오(L, k', expose(T)=.R):)k < k > return join ( delete ( L , k ) , k ' return join ( L , k , k ' )return join ( L , k )그렇지 않으면 join 2 ( L , k )를 반환한다.

T = $|T|=n$ \ $displaystyle$ T $n이면$ 삽입과 삭제 모두 $O(\log n)$ O ( $O(\log n)$ n $O(\log n)$ ) \ $displaystyle$ O ( \ $log$ n ) 시간이 $O(\log n)$ $O(\log n)$ 합니다.

설정 함수

무게 균형 트리에 대해 합집합, 교차점 및 집합 차이의 여러 집합 연산이 정의되었습니다. $세트$ $A$ 와 B를 나타내는 2개의 무게 균형 트리 $t$ 와₁₂ t의 결합은 A $b$ B를 $나타내는$ $트리$ t이다.다음 재귀 함수는 이 결합을 계산합니다.

t₁₂ = nile이면₁ t를 반환한다₁₂. t = nile이면 telse를 반환한다₁(l₂₁, k₁, r):= exposure(t₁)(t_<, b, t_>) := split(t₂, k₁) l' := union(l₁, t_<) r' := union(r₁, t_>) r' r' := join(l, k₁') 반환한다.

마찬가지로, 교집합과 집합 차이의 알고리즘은 다음과 같습니다.

기능 intersection(t1, t2)만약 t1)영 또는 t2)수 전무 그 밖의 다른(l1, k1, r1):(t<, b, t>.)=split(t2시간 k1)나는 'expose(t1)=:)intersection(l1, t<.)r':)intersection(r1, t>.)만약b 반환 join(나는 'k1, r') 다른 돌아오join2(나는 'r')기능 difference(t1, t2).     만약 t1)대가 제로 전무.else = nill return₁ t else (l₁, k₁, r₁) : = expose(t₁) (t_<, b, t_>) : = split₂(t₁, k) l' = different₁(l_<, t) r' = difference₁(r_>, t') b가 join2(l', r')를 반환하면 r₂' elay(l, r₁')이다.

m $\displaystyle$ m $n(\geq m)$ $n(\geq m)$ n $n(\geq m)$ m $) 크기$ 의 $무게$ 균형 트리에 대해 각 결합, 교차 및 차이의 복잡도는 $O\left(m\log \left({\tfrac {n}{m}}+1\right)\right)$ log $O\left(m\log \left({\tfrac {n}{m}}+1\right)\right)$ ( $O\left(m\log \left({\tfrac {n}{m}}+1\right)\right)$ $m$ + 1) $O\left(m\log \left({\tfrac {n}{m}}+1\right)\right)$ { $display style$ O $\ left$ ( m \ lef ( m \ log \ lef ( { \ $tfrac$ { $n$ } + $1$ \ $right )$ } } 입니다 $O\left(m\log \left({\tfrac {n}{m}}+1\right)\right)$ .이 복잡도는 비교 횟수에 있어서 최적입니다.이후 노조, 교차로 또는 차이에 반복적인 호출은 서로 독립적이다 더욱 중요한 것은, 그들은 병렬로 언제 m=1{\displaystyle m=1}O{O(m\log n\log)\displaystyle}.[1](로그 ⁡ m로그 ⁡ n)는 평행하는 깊이를 실행할 수 있으면join-based 시행은single-ele의 똑같은 계산 적용된다.나야.큰 트리의 루트를 사용하여 작은 트리를 분할하는 경우 nt 삽입 또는 삭제.

빌드

트리 구축 알고리즘은 통합 알고리즘을 사용하여 분할 및 정복 방식을 사용할 수 있습니다.

n = 0이면 build(A[, n) n = 1이 node(nil, A[0], nil)를 반환하면 build(A, n/2) r' :=(A+n/2, n-n/2)이 반환 유니언(L, R)을 반환합니다.

이 알고리즘은 O $O(n\log n)$ log $O(n\log n)$ n $)\displaystyle$ O $(n\log$ n $)}$ 작업 $O(n\log n)$ 비용이 $O(n\log n)$ 들고 $O(\log ^{3}n)$ ( $O(\log ^{3}n)$ $O(\log ^{3}n)$ n $)\displaystyle$ O $(\log ^{3}n)}$ $O(\log ^{3}n)$ 입니다 $O(\log ^{3}n)$ .보다 효율적인 알고리즘은 병렬 정렬 알고리즘을 사용합니다.

함수 buildn = n이 0을 반환하는 경우 n이 0을 반환하는 경우 buildSorted(A[0], n) n = node(nil)를 반환하는 경우 n = build(A, n/2) r' := (A+n/2+1, n-n/2-1)를 반환하는 경우 build(l', build(l'), 함수는 "l"를 반환합니다.

이 알고리즘은 O $O(n\log n)$ n $)\displaystyle$ O $(n\log$ n $)$ 작업 $O(n\log n)$ 비용이 $O(n\log n)$ 들고 정렬 $O(n\log n)$ 이 $O(n\log n)$ ( $O(n\log n)$ $O(n\log n)$ n $)$ $작업$ $O(\log n)$ O $O(\log n)$ n $)\displaystyle$ O $($ $n\$ $log$ n $)$ 작업 깊이가 O $O(\log n)$ n $)$ 인 $O(\log n)$ $O(\log n)$ 것을 전제로 $O(\log n)$ .

필터

이 함수는 $술어$ p $\displaystyle$ p $p$ 를 만족하는 트리의 모든 엔트리를 선택하고 선택한 모든 엔트리가 포함된 트리를 반환합니다.2개의 서브트리를 재귀적으로 $필터링하여$ 루트가 p $\displaystyle$ p $p$ 를 충족하면 루트에 결합하고 그렇지 않으면 2개의 서브트리를 결합합니다.

function filter(T, p)     if T = nil         return nil     else         (l, k, r) := expose(T)         l' := filter(l, p)    r' := filter(r, p)         if p(k)             return join(l', k, r')         else             return join2(l', R)

This algorithm costs work $O(n)$ and depth $O(\log ^{2}n)$ on a tree of size $n$ , assuming $p$ has constant cost.

Used in libraries

The join-based algorithms are applied to support interface for sets, maps, and augmented maps ^[5] in libraries such as Hackage, SML/NJ, and PAM.^[5]

Notes

References

^ ^a ^b Blelloch, Guy E.; Ferizovic, Daniel; Sun, Yihan (2016), "Just Join for Parallel Ordered Sets", Symposium on Parallel Algorithms and Architectures, Proc. of 28th ACM Symp. Parallel Algorithms and Architectures (SPAA 2016), ACM, pp. 253–264, arXiv:1602.02120, doi:10.1145/2935764.2935768, ISBN 978-1-4503-4210-0
^ Tarjan, Robert Endre (1983), "Data structures and network algorithms", Data structures and network algorithms, Siam, pp. 45–56
^ Sleator, Daniel Dominic; Tarjan, Robert Endre (1985), "Self-adjusting binary search trees", Journal of the ACM, Siam
^ Adams, Stephen (1992), "Implementing sets efficiently in a functional language", Implementing sets efficiently in a functional language, Citeseer, CiteSeerX 10.1.1.501.8427.
^ ^a ^b Blelloch, Guy E.; Ferizovic, Daniel; Sun, Yihan (2018), "PAM: parallel augmented maps", Proceedings of the 23rd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, ACM, pp. 290–304

External links

PAM, the parallel augmented map library
Hackage, Containers in Hackage

[join-based-1] Blelloch, Guy E.; Ferizovic, Daniel; Sun, Yihan (2016), "Just Join for Parallel Ordered Sets", Symposium on Parallel Algorithms and Architectures, Proc. of 28th ACM Symp. Parallel Algorithms and Architectures (SPAA 2016), ACM, pp. 253–264, arXiv:1602.02120, doi:10.1145/2935764.2935768, ISBN 978-1-4503-4210-0

[join-tarjan-2] Tarjan, Robert Endre (1983), "Data structures and network algorithms", Data structures and network algorithms, Siam, pp. 45–56

[splaytree-3] Sleator, Daniel Dominic; Tarjan, Robert Endre (1985), "Self-adjusting binary search trees", Journal of the ACM, Siam

[adams-4] Adams, Stephen (1992), "Implementing sets efficiently in a functional language", Implementing sets efficiently in a functional language, Citeseer, CiteSeerX 10.1.1.501.8427.

[pam-5] Blelloch, Guy E.; Ferizovic, Daniel; Sun, Yihan (2018), "PAM: parallel augmented maps", Proceedings of the 23rd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, ACM, pp. 290–304

[1]

[5]

v t Well-known data structures
Types	Collection Container
Abstract	Associative array Multimap Retrieval Data Structure List Stack Queue Double-ended queue Priority queue Double-ended priority queue Set Multiset Disjoint-set
Arrays	Bit array Circular buffer Dynamic array Hash table Hashed array tree Sparse matrix
Linked	Association list Linked list Skip list Unrolled linked list XOR linked list
Trees	B-tree Binary search tree AA tree AVL tree Red–black tree Self-balancing tree Splay tree Heap Binary heap Binomial heap Fibonacci heap R-tree R* tree R+ tree Hilbert R-tree Trie Hash tree
Graphs	Binary decision diagram Directed acyclic graph Directed acyclic word graph
List of data structures

Search