プログラミング通論 ’19 ＃ 13–2 分木と多分木

プログラミング通論 ’19 _＃ 13 – 2 _{分木と多分木}

久野 靖

(電気通信大学)

2019.4.20

今回は次のことが目標となります。

• 2

2

•

B

1 2 _{分探索木とバランス}

1.1 2

前回、配列を用いた表のデータ構造を取り扱いましたが、配列は基本的に値を「詰めて並べて」しま うため、キーの昇順

/

/

n

O ( n )

2

2

動的データ構造ではポインタを用いてノード

(node,

)

の節が複数あります。まず

2

2

1

個々の節には

(

) key

val

left

right

(subtree)

NULL

7 1

key val

left right

7

4 9

6

2 8

図

1: 2

ここで、

2

2

(binary search tree)

任意の節

n

n

k

n

k

n

k

図

1

2

7

2

4

6

7

4

6

4

1.2 2

2

NULL

API

itbl.h

itbl del

itbl pr

(

)

// itbl.h --- int table api.

struct itbl;

typedef struct itbl *itblp;

itblp itbl_new(); // allocate new tbl

void itbl_put(itblp t, int k, int v); // store value int itbl_get(itblp t, int k); // obtain value

//void itbl_delete(itblp t, int k); // delete key/value void itbl_pr(itblp t); // print contents

実装を見ます。節の構造体

struct ent

struct itbl

(

)

itbl get

get

get

NULL

-1

// bstree.c --- itbl impl with binary search tree.

#include <stdlib.h>

#include <stdio.h>

#include "itbl.h"

typedef struct ent *entp;

struct ent { int key, val; entp left, right; };

struct itbl { entp root; };

itblp itbl_new() {

itblp p = (itblp)malloc(sizeof(struct itbl));

p->root = NULL; return p;

}

static int get(entp p, int k) { if(p == NULL) { return -1; }

if(k == p->key) { return p->val; }

return get((k < p->key) ? p->left : p->right, k);

}

int itbl_get(itblp p, int k) { return get(p->root, k); }

では

itbl put

get

きますが、今度は渡して行くパラメタの方が

entp*

NULL

put

static void put(entp *p, int k, int v) { if(*p == NULL) {

entp q = *p = (entp)malloc(sizeof(struct ent));

q->left = q->right = NULL; q->key = k; q->val = v;

} else if(k == (*p)->key) { (*p)->val = v;

} else {

put((k < (*p)->key) ? &((*p)->left) : &((*p)->right), k, v);

} }

void itbl_put(itblp p, int k, int v) { put(&(p->root), k, v); }

最後に内容表示を見ましょう。

itbl pr

pr

pr

NULL

(

/

)

(

pr

)

static void pr(entp p) {

if(p->left != NULL) { printf("("); pr(p->left); printf(") "); } printf("%d:%d", p->key, p->val);

if(p->right != NULL) { printf(" ("); pr(p->right); printf(")"); } }

void itbl_pr(itblp p) {

if(p->root != NULL) { printf("("); pr(p->root); printf(")\n"); } }

では、これらを使って木構造のようすを見るためのプログラムを示します。コマンド引数として値 を指定すると、それらを鍵として次々に表に登録します

(

// treedemo.c --- demonstration of bstree operation

#include <stdlib.h>

#include <stdio.h>

#include "itbl.h"

int main(int argc, char *argv[]) { int n = atoi(argv[1]);

itblp p = itbl_new();

for(int i = 1; i < argc; ++i) { int v = atoi(argv[i]);

if(v >= 0) { itbl_put(p, v, i); } // else { itbl_delete(p, -v); }

itbl_pr(p);

}

return 0;

}

では、実行のようすを見てみましょう。次々に節が追加されていくようすを図

2

所要時間を計測してみたい場合は前回の計測プログラムを使えばよいです。

% gcc8 bstreedemo.c itbl3.c

% ./a.out 5 2 1 7 6 9 (5:1)

((2:2) 5:1)

(((1:3) 2:2) 5:1)

(((1:3) 2:2) 5:1 (7:4))

(((1:3) 2:2) 5:1 ((6:5) 7:4))

(((1:3) 2:2) 5:1 ((6:5) 7:4 (9:6)))

5 5

2

5 2 1

7 5

2 1

5 2 1

7 6

5 2 1

7

6 9

図

2: 2

演習

1 2

OK

a.

ヒント

:

p->left = put(p->left, k, v)

put

NULL

NULL

put

b.

(get)

を除去してループに書き直してみなさい。

c.

(put)

d.

1

1.3 2

値の検索と追加は前述のように比較的簡単でしたが、削除には面倒なところがあります。削除したい 値をまず探しますが、その値が木のどこに位置していたかで「面倒さ」が違います。

•

(

NULL

)

OK

•

NULL

(

3

)

•

2

または「右の部分木で最小の鍵」となる

(

)

最後の場合についてもう少し説明しましょう。「左の部分木で最大の鍵」を用いるとして、最大の 鍵ということは左部分木を行けるだけ右へたどった所にある鍵です。そこが葉ならその節を削除して 持って来るだけですが、その節に左の子があるなら、左の子へのポインタを持って来る節へのポイン タが入っていた箇所に格納することで木に残します。ですが、葉の場合は左ポインタが

NULL

(

3

)

7

9 delete

9

7

9 delete

4

6

5

6

9 4

5 max of left subtree

moved node

4

6 4

max of left subtree pointer

copy

pointer copy

pointer copy

図

3: 2

演習

2 2

main

(

2

-2

2

)

1.4

AVL

2

(

)

(

)

n

O (log n )

(

)

n

O ( n )

この問題は古くから知られており、これを防ぐために「

2

AVL

(AVL tree)

AVL

2

すべての節において、左部分木の高さと右部分木の高さの差はたかだか

1

確かにこの条件が満たされていれば、木はバランスしていると言えますが、それを具体的にどう やって実現するのでしょうか。それには、鍵の挿入や削除において常にこの条件を満たすように

(

2

)

具体的にはまず、木の節数が

0

1

(

0)

1

1

削除により高さが

1

1

2

だとすれば、これまでは条件を満たしていて「挿入・削除により

AVL

2

2

(

AVL

)

4(

)

いずれのケースも書き換え矢線の左が「差が

2

(

)

0(

)

(

2

-2

)

まず

(A)

Y

X

X

-1

0

1

-1

(A)

0

(B)

1

(

)(C)

(D)

(E)

1

3

1ほかに代表的なものとして、AA木、赤黒木、スプレー木などがあります。

X Y -1

-2

t1 t2

t3

X

t1 Y

t3

Y Z

X t1

t2 t3

t4 1

-2

-1

Y Z

X t1 t2

t3 t4 1

-2

1

X Y

t1 t2

Z

t4 t3 -1

Y Z

X t1

t2 t3 t4 1

-2

X Y

t1 t2 Z

t4 t3

1

X Y

t1 t2 Z

t4 t3 t2

X -2 Y

t1 t2 t3

X

t1 Y

t3 t2

-1 1

A

B

C

D

E

図

4: AVL

のさらに右の子の節の

-1

1

0

-2

2

話を戻して

(A)

X

Y

(

)

X

Y

0

1

(

)

2

t1

X

t2

X

Y

t3

Y

(B)

2

(A)

(C)

(D)

(E)

3

1

(A)

(B)

1

-1

t1

t4

4

X

Z

(2

)

AVL

1

実際に

2

-2

2

2

なお、挿入時には「

1

1

OK

1

回転によってその部分木のバランスは回復しても、「部分木の高さが

1

(

)

演習

3

AVL

(

)

a.

ンス値を維持するようにしなさい。

itbl pr

b.

2

-2

2

c.

d.

AVL

2 _多分木と B _木

2.1

B

前節までで見てきたように、木構造では木の高さにより処理時間が決まってくるので、木のバランス を維持することが重要になります。バランスを維持する機能を組み込んだ木構造を平衡木

(baranced tree)

2

AVL

(

)

一方、多分木とは次数

(

)

2

B

(B-tree)

B

2

B

d

d

2 d

(

1)

1

B

( d + 1 ∼ 2 d + 1)

2-3 B

(2-3

)

3-5 B

(3-5

)

(

1

)

7 21

3 5 8 12 16 24 25 30 35 37

40 55 60 68

42 51 56 5859 62 63 70 77 33

図

5: B

(3-5

)

図

5

3-5

B

たとえば図

5

7

21

21

33

21

33

この性質を用いれば、

2

木の高さだけおりてゆけば鍵が見付かる

(

)

なお、実用的には

B

2

1

(4096

)

1

(

)

2.2 B

検索について分かったところで、鍵の追加がどのように働くかを見ます。図

6

3-5

27

5

2 d

2

(

23

)

3

23

23

41

B

しかし最初の「

27

23

親の節が満杯ならどうするのでしょうか。これらの答えは簡単で、まず

B

9 16 23 30

add 27

9 16 27 30

4-8 10-15 17-22 24-29 31-40 41

3 3 23 41

17-22 24-26 28-29

図

6: B

でのみ行います。そして、葉の節で鍵の個数が

2 d

27

また、親の節も

2 d

2 d

2 d

2

1

2

1

2.3

: 2-3

それでは例として、

2-3

AVL

各節には葉かどうかを表すフィールド

leaf

nkey

key

val

child

key[ i ]

child[ i ]

child[ i + 1]

2 d + 1

2 d

NULL

// btree23.c --- itbl impl with 2-3 B-tree.

#include <stdlib.h>

#include <stdio.h>

#include <stdbool.h>

#include "itbl.h"

#define D 1

typedef struct ent *entp;

struct ent { bool leaf;

int nkey, key[D*2+1], val[D*2+1];

entp child[D*2+1];

};

struct itbl { entp root; };

itblp itbl_new() {

itblp p = (itblp)malloc(sizeof(struct itbl));

p->root = NULL; return p;

}

検索ですが、まず根が

NULL

itbl get

get

get

k

k

− 1

static int get(entp p, int k) { int i;

for(i = 0; k >= p->key[i] && i < p->nkey; ++i) { if(k == p->key[i]) { return p->val[i]; }

}

return (p->leaf) ? -1 : get(p->child[i], k);

}

int itbl_get(itblp p, int k) {

return (p->root == NULL) ? -1 : get(p->root, k);

}

さていよいよ、ややこしい挿入の処理です。下請け用として、鍵と対応する値を指定して鍵を

1

newent2(

)

newent(

NULL)

i

cpent2

cpent

shift

i

i

1

static entp newent2(int k, int v, entp l, entp r) { entp p = (entp)malloc(sizeof(struct ent));

p->leaf = false; p->nkey = 1; p->key[0] = k; p->val[0] = v;

p->child[0] = l; p->child[1] = r; return p;

}

static entp newent(int k, int v) {

entp q = newent2(k, v, NULL, NULL); q->leaf = true; return q;

}

static entp cpent2(entp p, int i, entp l, entp r) {

entp q = newent2(p->key[i], p->val[i], l, r); return q;

}

static entp cpent(entp p, int i) {

entp q = cpent2(p, i, NULL, NULL); q->leaf = true; return q;

}

static void shift(entp p, int i) { for(int j = ++p->nkey; j > i; --j) {

p->key[j] = p->key[j-1]; p->val[j] = p->val[j-1];

p->child[j] = p->child[j-1];

} }

次のレベルの下請けとして、節が葉で位置

i

pleaf

1

2

(

pnode

put

)

NULL

節に入る鍵の上限までに余裕があるなら、

i

shift

NULL

i

0

1

2

static entp pleaf(entp p, int i, int k, int v) { if(p->nkey < D*2) {

shift(p, i); p->key[i] = k; p->val[i] = v; return NULL;

} else if(i == 0) {

return newent2(p->key[0], p->val[0], newent(k, v), cpent(p, 1));

} else if(i == 1) {

return newent2(k, v, cpent(p, 0), cpent(p, 1));

} else {

return newent2(p->key[1], p->val[1], cpent(p, 0), newent(k, v));

} }

中間ノードの場合は、葉の方から分割の情報が

(

)

q

pnode

q

NULL

NULL

shift

i

NULL

3

static entp pnode(entp p, entp q, int i) { if(q == NULL) { return NULL; }

entp r = NULL;

if(p->nkey < D*2) {

shift(p, i); p->key[i] = q->key[0]; p->val[i] = q->val[0];

p->child[i] = q->child[0]; p->child[i+1] = q->child[1];

} else if(i == 0) {

r = newent2(p->key[0], p->val[0],

newent2(q->key[0], q->val[0], q->child[0], q->child[1]), cpent2(p, 1, p->child[1], p->child[2]));

} else if(i == 1) {

r = newent2(q->key[0], q->val[0],

cpent2(p, 0, p->child[0], q->child[0]), cpent2(p, 1, q->child[1], p->child[2]));

} else {

r = newent2(p->key[1], p->val[1],

cpent2(p, 0, p->child[0], p->child[1]),

newent2(q->key[0], q->val[0], q->child[0], q->child[1]));

}

free(q); return r;

}

put

i

k

pleaf

pnode

static entp put(entp p, int k, int v) { int i;

for(i = 0; k >= p->key[i] && i < p->nkey; ++i) { if(k == p->key[i]) { p->val[i] = v; return NULL; } }

return p->leaf ? pleaf(p, i, k, v) : pnode(p, put(p->child[i], k, v), i);

}

void itbl_put(itblp p, int k, int v) { int k1, v1;

if(p->root == NULL) { p->root = newent(k, v); return; } entp r = put(p->root, k, v);

if(r != NULL) { free(p->root); p->root = r; } }

以上の下請けが用意されているとして、

itbl put

NULL

(

)

put

(

1

)

NULL

最後に、

B

2

:

static void pr(entp p) { int i;

if(p == NULL) { printf("NULL"); return; } if(p->leaf) {

if(p->nkey > 0) { printf("%d:%d", p->key[0], p->val[0]); } for(i = 1; i < p->nkey; ++i) {

printf(" %d:%d", p->key[i], p->val[i]);

} } else {

for(i = 0; i < p->nkey; ++i) { printf("("); pr(p->child[i]);

printf(") %d:%d ", p->key[i], p->val[i]);

}

printf("("); pr(p->child[i]); printf(")");

} }

void itbl_pr(itblp p) { printf("("); pr(p->root); printf(")\n"); }

では、先のテストプログラムと組み合わせて動かします。確かに、番号順に挿入しているのにすべ ての葉の深さは同じになるように木が作られて行きます。

% gcc8 treedemo.c btree32.c

% ./a.out 1 2 3 4 5 6 7 8 9 10 (1:1)

(1:1 2:2)

((1:1) 2:2 (3:3)) ((1:1) 2:2 (3:3 4:4))

((1:1) 2:2 (3:3) 4:4 (5:5)) ((1:1) 2:2 (3:3) 4:4 (5:5 6:6))

(((1:1) 2:2 (3:3)) 4:4 ((5:5) 6:6 (7:7))) (((1:1) 2:2 (3:3)) 4:4 ((5:5) 6:6 (7:7 8:8)))

(((1:1) 2:2 (3:3)) 4:4 ((5:5) 6:6 (7:7) 8:8 (9:9)))

(((1:1) 2:2 (3:3)) 4:4 ((5:5) 6:6 (7:7) 8:8 (9:9 10:10)))

演習

4 2-3

B

3-5

(

)

(

:

0/1/2

2-3

変更しないで大丈夫なはずです。

) 2.4 B

ここまでは挿入だけを扱って来ましたが、

B

2

削除の結果、鍵の数が

d

(

7)

9 16 23

3 27 41

30 31-40 28-29 24-26 17-22 10-15 4-8

9 16 27 30

31-40 28-29 24-26 17-22 10-15 4-8

3 23 41

図

7:

隣接する節の鍵の数も

d

2

1

2 d

d

1

1

演習

5 2-3

演習

6

B

本日の課題

13A

「演習

1

6

1

(

23:59

)

1. sol

CED

/home3/staff/ka002689/prog19upload 13a

2.

(

)

@@@

3.

1

4.

(

)

(

)

5.

Q1. 2

Q2. AVL

B

Q3.

(

)