了解了二叉堆之后，二叉搜索树就好说了，就是一个节点，左边的子节点是不可能比他大的，右边的子节点是一定大于它的，想了半天终于把创建给写好了。
文章目录
创建
import UIKit
var str = "二叉搜索树"
//这个就不跟前面的完全二叉树一样了，得自己建了类或者结构体了，我建了个类
class erchaTreeNote {
var data: Int
var leftChild: erchaTreeNote!
var rightChild: erchaTreeNote!
init(data:Int) {
self.data = data
}
}
var a = [12,321,432,213,423,4]
func createTree() -> (erchaTreeNote) {
let root = erchaTreeNote(data:a[0]);
for x in a[1...a.count-1] {
let child = erchaTreeNote(data: x)
var temp = root
//循环的条件想了半天，想着如何能走下去，在纸上练了几遍，发现了规律，本来进来一个数如果它加进去了，它的左右子节
//点都是空的，再往下就不走了，但是这个是走不通的，再想他们有什么共性，我就想，既然把它按在了树上，那它再走一
//次，必然和上一次的路径是一样的，当我找到和它一模一样的时候，就是结束的时候，如果我找不到它，一直都不能结束。
//就按这个条件走就出来了。
while temp !== child {
//如果进来的数小于父节点
if child.data < temp.data {
//不为空，那我就把父节点左边子节点拿上，再重新来过
if temp.leftChild != nil
{
temp = temp.leftChild
}
//当父节点左边是空的时候，那就直接填上
else
{
temp.leftChild = child
print("\(temp.data)左边的孩子")
temp = child //优化语句
}
}else //进来的数大于父节点
{
//不为空，那我就把父节点右边子节点拿上，重新来过
if temp.rightChild != nil {
temp = temp.rightChild
}
//当父节点的右边为空的时候，那就直接补上
else
{
temp.rightChild = child
print("\(temp.data)右边的孩子")
temp = child //优化语句
}
}
}
print(child.data)
}
return root
}
createTree()
最大值和最小值
//找到最大的，那就直接朝右走下去，最小则是朝左走下去
func FindMax(_ shu:erchaTreeNote) -> (erchaTreeNote){
var temp = shu
//如果右边不为空，一直找下去
while temp.rightChild != nil {
temp = temp.rightChild
}
return temp
}
//最小
func FindMin(_ shu:erchaTreeNote) -> (erchaTreeNote){
var temp = shu
//如果左边不为空，一直找下去
while temp.leftChild != nil {
temp = temp.leftChild
}
return temp
}
查找
//找到特定的那个数,这个我发现如果两个一样的数字，可能进入树
//的时间不一样，所以他们位置也就不一样，得把这棵树可能的条件都循环完毕才可以
func Findfrom(_ shu:erchaTreeNote,_ mubiao:Int) -> ( Array<erchaTreeNote>){
var temp = shu
var arr = Array<erchaTreeNote>()
while true{
if temp.data < mubiao
{
if temp.rightChild != nil
{
print("拐进右边\(temp.rightChild.data)")
temp = temp.rightChild
}
else
{
print("没有啦")
break
}
}
else if temp.data > mubiao
{
if temp.leftChild != nil
{
print("拐进左边\(temp.leftChild.data)")
temp = temp.leftChild
}
else
{
print("没有啦")
break
}
}
else
{
print("找到啦它就是\(temp.data)")
//找到它的时候给它加载数组里，不确定还有没有一样的存在
arr.append(temp)
if (temp.rightChild != nil)
{
print("下面还有东西呢\(temp.rightChild.data)")
temp = temp.rightChild
}
else
{
break
}
}
}
return arr
}
插入
//插入，其实就跟创建是一模一样，只不过多了一个数而已
func insert(_ shu:erchaTreeNote,_ x :Int) -> (erchaTreeNote)
{
func digui (_ ee: erchaTreeNote)
{
if ee.data > x {
if ee.leftChild != nil
{
digui(ee.leftChild)
}
else
{
print("它的父节点是\(ee.data).他在左边")
ee.leftChild = erchaTreeNote(data: x)
}
}
else
{
if ee.rightChild != nil
{
digui(ee.rightChild)
}
else
{
print("它的父节点是\(ee.data).他在右边")
ee.rightChild = erchaTreeNote(data: x)
}
}
}
digui(shu)
return shu
}
删除
删除好做，但是得找到那个能顶替它原来位置的节点，我这里只是打印出来，因为没有父节点，不好去找，所以就没做。。
//移除的逻辑也简单易懂，删除这个节点，如果有右节点，再去找右
//边最小的那个顶上，如果没有右节点，左节点顶上，要是都木有，那就删了
func yichu(_ shu:erchaTreeNote,_ x:Int)
{
//先找到这个节点,因为里面可能有重复的情况发生，所以得删个几次，我们从最深的那个删起
let arr = Findfrom(shu, x)
arr.count
for i in 0..<arr.count
{
let temp = arr[arr.count - i - 1]
if temp.rightChild != nil
{
print("删了\(temp.data),与\(FindMin(temp.rightChild).data)发生调换")
}
else if temp.leftChild != nil
{
FindMax(temp.rightChild)
print("删了\(temp.data),与\(FindMax(temp.rightChild).data)发生调换")
}
else
{
print("删了\(temp.data),没有发生调换")
}
}
}
前驱
//前驱，一个节点的前驱是指所有比它小的节点里面最大的那个；
func Getpredecessor(_ shu:erchaTreeNote,_ x :Int) -> (erchaTreeNote)
{
let arr = Findfrom(shu, x)
for temp in arr
{
if temp.leftChild != nil
{
return FindMin(temp.leftChild)
}
else
{
return temp
}
}
print("\(x)并没有找到")
return erchaTreeNote(data: -1)
}
后继
//后继，一个节点的后继是指所有比它大的节点里面最小的那个
func GetSuccessor(_ shu:erchaTreeNote,_ x :Int) -> (erchaTreeNote)
{
let arr = Findfrom(shu, x)
for temp in arr
{
if temp.rightChild != nil
{
return FindMax(temp.rightChild)
}
else
{
return temp
}
}
print("\(x)并没有找到")
return erchaTreeNote(data: -1)
}
中序遍历
//遍历 Inorder Traversal 中序遍历，中序遍历就是先左后右，很直观的输出数字。
func InorderTra(_ shu:erchaTreeNote){
var arr = Array<erchaTreeNote>()
func lunhui(_ shu:erchaTreeNote)
{
if shu.leftChild != nil
{
arr.append(shu)
lunhui(shu.leftChild)
}
else
{
print(shu.data)
let beis = arr.remove(at: arr.count-1)
print(beis.data)
if(beis.rightChild != nil) {
lunhui(beis.rightChild)
}
}
}
lunhui(shu)
}
就酱，还是蛮有成就感的。要是不对，咱们一起讨论，当然里面的一些极端情况我没有做判断，只是想着熟悉下思路。
