Go言語(Golang)におけるレシーバがnilを受け取ることを利用した二本木の実装

```go
package main

import (
	"fmt"
)

type IntTree struct { 
	val         int
	left, right *IntTree
}

// valをitに挿入する
func (it *IntTree) Insert(val int) *IntTree {
	if it == nil {
		return &IntTree{val: val}
	}
	if val < it.val {
		it.left = it.left.Insert(val)
	} else if val > it.val {
		it.right = it.right.Insert(val)
	}
	return it
}

// valがitに含まれるかをチェックし論理値を返す
func (it *IntTree) Contains(val int) bool {
	switch {
	case it == nil:
		return false
	case val < it.val:
		return it.left.Contains(val)
	case val > it.val:
		return it.right.Contains(val)
	default:
		return true
	}
}

func main() { 
	var it *IntTree
	it = it.Insert(5)
	it = it.Insert(3)
	it = it.Insert(10)
	it = it.Insert(2)
	fmt.Println(it.Contains(2))  // true
	fmt.Println(it.Contains(12)) // false
} 
```




```go
type IntTree struct { //liststart1
	val         int
	left, right *IntTree
}
```
- `IntTree`という構造体を定義します。この構造体は、整数の値（`val`）と、左と右の子ノード（`left`と`right`）を持っています。これにより、二分探索木（BST）を表現します。

```go
// valをitに挿入する
func (it *IntTree) Insert(val int) *IntTree {
```
- `Insert`メソッドを定義します。このメソッドは、整数`val`を木に挿入するためのものです。`it`は`IntTree`のポインタです。

```go
	if it == nil {
		return &IntTree{val: val}
	}
```
- `it`が`nil`の場合、新しい`IntTree`のインスタンスを作成し、`val`をその値に設定して返します。

```go
	if val < it.val {
		it.left = it.left.Insert(val)
	} else if val > it.val {
		it.right = it.right.Insert(val)
	}
```
- `val`が現在のノードの値より小さい場合、左の子ノードに対して`Insert`を再帰的に呼び出します。逆に、大きい場合は右の子ノードに対して呼び出します。

```go
	return it
}
```
- 最後に、現在のノード（`it`）を返します。これにより、木全体の構造が保持されます。

```go
// valがitに含まれるかをチェックし論理値を返す
func (it *IntTree) Contains(val int) bool {
```
- `Contains`メソッドを定義します。このメソッドは、整数`val`が木に存在するかどうかをチェックします。

```go
	switch {
	case it == nil:
		return false
```
- `it`が`nil`の場合、木に値は含まれないので`false`を返します。

```go
	case val < it.val:
		return it.left.Contains(val)
```
- `val`が現在のノードの値より小さい場合、左の子ノードに対して`Contains`を再帰的に呼び出します。

```go
	case val > it.val:
		return it.right.Contains(val)
```
- `val`が現在のノードの値より大きい場合、右の子ノードに対して`Contains`を再帰的に呼び出します。

```go
	default:
		return true
	}
```
- `val`が現在のノードの値と等しい場合、木に値が含まれているので`true`を返します。

```go
func main() { //liststart2
```
- `main`関数を定義します。プログラムのエントリーポイントです。

```go
	var it *IntTree
```
- `IntTree`のポインタ`it`を宣言しますが、まだ初期化はされていません。

```go
	it = it.Insert(5)
```
- `5`を木に挿入し、その結果を`it`に再代入します。最初のノードが作成されます。

```go
	it = it.Insert(3)
```
- `3`を木に挿入します。`3`は`5`より小さいので、左の子ノードとして追加されます。

```go
	it = it.Insert(10)
```
- `10`を木に挿入します。`10`は`5`より大きいため、右の子ノードとして追加されます。

```go
	it = it.Insert(2)
```
- `2`を木に挿入します。`2`は`5`より小さく、さらに`3`よりも小さいので、`3`の左に追加されます。

```go
	fmt.Println(it.Contains(2))  // true
```
- `2`が木に含まれているかをチェックし、結果を出力します。`true`が出力されます。

```go
	fmt.Println(it.Contains(12)) // false
```

## `IntTree`がどのように構築されるか

#### 初期状態
最初は、`it`は`nil`です。

```go
var it *IntTree
```

#### `it = it.Insert(5)`
- `it`が`nil`なので、`Insert`メソッドは新しい`IntTree`インスタンスを作成します。
- `val`は`5`です。
- 新しいノードが作成され、`5`がその値になります。
- `it`はこの新しいノードを指すようになります。

```
   5
  / \
nil nil
```

#### `it = it.Insert(3)`
- 現在のノードは`5`です。
- `3 < 5`なので、左の子ノードに挿入します。
- 左の子ノードは`nil`なので、`Insert`メソッドは新しいノードを作成します。
- `val`は`3`です。
- 新しいノードが作成され、`3`がその値になります。

```
   5
  / \
  3 nil
 / \
nil nil
```

#### `it = it.Insert(10)`
- 現在のノードは`5`です。
- `10 > 5`なので、右の子ノードに挿入します。
- 右の子ノードは`nil`なので、`Insert`メソッドは新しいノードを作成します。
- `val`は`10`です。
- 新しいノードが作成され、`10`がその値になります。

```
   5
  / \
  3  10
 / \  / \
nil nil nil
```

#### `it = it.Insert(2)`
- 現在のノードは`5`です。
- `2 < 5`なので、左の子ノード（`3`）に進みます。
- 現在のノードは`3`です。
- `2 < 3`なので、左の子ノードに挿入します。
- 左の子ノードは`nil`なので、`Insert`メソッドは新しいノードを作成します。
- `val`は`2`です。
- 新しいノードが作成され、`2`がその値になります。

```
   5
  / \
  3  10
 / \  / \
 2 nil nil
/ \
nil nil
```

#### 最終的な木の構造
全ての挿入操作が完了した後、最終的な二分探索木の構造は次のようになります。

```
   5
  / \
  3  10
 / \
 2 nil
/ \
nil nil
```

#### 結果
- `5`がルートノード。
- `3`が`5`の左の子ノード。
- `10`が`5`の右の子ノード。
- `2`が`3`の左の子ノード。