github.com/qiuhoude/go-web@v0.0.0-20220223060959-ab545e78f20d/algorithm/datastructures/tree/bst/binarySearchTree_test.go (about)

     1  package bst
     2  
     3  import (
     4  	"fmt"
     5  	"strconv"
     6  	"testing"
     7  )
     8  
     9  type Integer int
    10  
    11  func (i Integer) CompareTo(o Comparable) int {
    12  	oi, ok := o.(Integer)
    13  	if ok {
    14  		return int(i - oi) // 简单这么写,没有考虑溢出的情况
    15  	}
    16  	return -1
    17  }
    18  func (i Integer) String() string {
    19  	return strconv.Itoa(int(i))
    20  }
    21  
    22  func generateBST() *BST {
    23  	/*
    24  		//      5
    25  		//    /  \
    26  		//   3    6
    27  		//  / \    \
    28  		// 2  4   	8
    29  		//		   /
    30  		//		  7
    31  	*/
    32  	bst := &BST{}
    33  	nums := []Integer{Integer(5), Integer(3), Integer(6), Integer(8), Integer(4), Integer(2), Integer(7)}
    34  	for i := 0; i < len(nums); i++ {
    35  		bst.Add(nums[i])
    36  	}
    37  	return bst
    38  }
    39  
    40  func TestBST_traverse(t *testing.T) {
    41  	bst := generateBST()
    42  	fmt.Println("PreOrder-------------------")
    43  	bst.PreOrder(func(e Comparable) {
    44  		fmt.Println(e)
    45  	})
    46  	fmt.Println("InOrder-------------------")
    47  	bst.InOrder(func(e Comparable) {
    48  		fmt.Println(e)
    49  	})
    50  	fmt.Println("PostOrder-------------------")
    51  	bst.PostOrder(func(e Comparable) {
    52  		fmt.Println(e)
    53  	})
    54  }
    55  
    56  func TestBST_PreOrderNR(t *testing.T) {
    57  	bst := generateBST()
    58  	bst.PreOrder(func(e Comparable) {
    59  		fmt.Println(e)
    60  	})
    61  	fmt.Println("-------------------")
    62  	bst.PreOrderNR(func(e Comparable) {
    63  		fmt.Println(e)
    64  	})
    65  	fmt.Println("-------------------")
    66  	bst.PreOrderMorris(func(e Comparable) {
    67  		fmt.Println(e)
    68  	})
    69  }
    70  
    71  func TestBST_InOrderNR(t *testing.T) {
    72  	bst := generateBST()
    73  	bst.InOrder(func(e Comparable) {
    74  		fmt.Println(e)
    75  	})
    76  	fmt.Println("-------------------")
    77  	bst.InOrderNR(func(e Comparable) {
    78  		fmt.Println(e)
    79  	})
    80  	fmt.Println("-------------------")
    81  	bst.InOrderNR2(func(e Comparable) {
    82  		fmt.Println(e)
    83  	})
    84  	fmt.Println("-------------------")
    85  	bst.InOrderMorris(func(e Comparable) {
    86  		fmt.Println(e)
    87  	})
    88  }
    89  
    90  func TestBST_PostOrderNR(t *testing.T) {
    91  	bst := generateBST()
    92  	bst.PostOrder(func(e Comparable) {
    93  		fmt.Println(e)
    94  	})
    95  	fmt.Println("-------------------")
    96  	bst.PostOrderNR(func(e Comparable) {
    97  		fmt.Println(e)
    98  	})
    99  }
   100  
   101  func TestBST_LevelOrder(t *testing.T) {
   102  	bst := generateBST()
   103  	bst.PreOrderNR(func(e Comparable) {
   104  		fmt.Println(e)
   105  	})
   106  	fmt.Println("-------------------")
   107  	bst.LevelOrder(func(e Comparable) {
   108  		fmt.Println(e)
   109  	})
   110  }
   111  
   112  func TestBst_MaxDepth(t *testing.T) {
   113  	//bst := generateBST()
   114  	bst := &BST{}
   115  	nums := []Integer{Integer(5), Integer(4), Integer(3), Integer(2), Integer(1)}
   116  	for i := 0; i < len(nums); i++ {
   117  		bst.Add(nums[i])
   118  	}
   119  
   120  	t.Log("最大深度 ", maxDepth(bst.root))
   121  }
   122  func TestBst_MinDepth(t *testing.T) {
   123  	//bst := generateBST()
   124  	bst := &BST{}
   125  	nums := []Integer{Integer(5), Integer(4), Integer(3), Integer(2), Integer(1), Integer(6)}
   126  	for i := 0; i < len(nums); i++ {
   127  		bst.Add(nums[i])
   128  	}
   129  	t.Log("最小深度 ", minDepth(bst.root))
   130  }
   131  
   132  func TestBST_Minimum(t *testing.T) {
   133  	bst := generateBST()
   134  	min := bst.Minimum().(Integer)
   135  	minNR := bst.MinimumNR().(Integer)
   136  	t.Log("最小值: ", min, minNR)
   137  
   138  }
   139  
   140  func TestBST_Maximum(t *testing.T) {
   141  	bst := generateBST()
   142  	max := bst.Maximum().(Integer)
   143  	t.Log("最大值: ", max)
   144  }
   145  
   146  func TestBST_RemoveMin(t *testing.T) {
   147  	bst := generateBST()
   148  	for bst.Size() > 0 {
   149  		m := bst.RemoveMin().(Integer)
   150  		fmt.Println("移除最小值: ", m)
   151  		fmt.Println(bst)
   152  	}
   153  }
   154  
   155  func TestBST_RemoveMax(t *testing.T) {
   156  	bst := generateBST()
   157  	for !bst.IsEmpty() {
   158  		m := bst.RemoveMax().(Integer)
   159  		fmt.Println("移除大小值: ", m)
   160  		fmt.Println(bst)
   161  	}
   162  }
   163  
   164  func TestBST_Remove(t *testing.T) {
   165  	bst := generateBST()
   166  	b := bst.Remove(Integer(8))
   167  	if b {
   168  		fmt.Println("删除成功")
   169  		fmt.Println(bst)
   170  	} else {
   171  		fmt.Println("删除失败")
   172  	}
   173  
   174  }