Binary Sort Visualized based on insertion order you can see a different BST. This displays why you randomize insertion of a BST

BinarySortTreeInsertionView.swift

//
//  ContentView.swift
//  BinarySearchVisualized
//
//  Created by Paul Wood on 8/23/19.
//  Copyright © 2019 Paul Wood. All rights reserved.
//

import SwiftUI
import Combine

extension Int: Identifiable {
  public var id: Int { return self }
}

class BinarySearchTreeHolder: ObservableObject {
  
  public struct TreeNodeArray: Identifiable {
    public var id: UUID = UUID()
    public var array: [TreeNode] = []
  }
  
  public struct TreeNode: Identifiable {
    var value: Int? {
      return tree?.value
    }
    var layer: Int
    var totalLayer: Int
    var index: Int
    var parentIndex: Int?
    var tree: BinarySearchTree<Int>?
    var id: UUID = UUID()
    
    public static func total(forDepth layerLevel: Int) -> Int {
      return 2^layerLevel
    }
  }
  
  public struct BSTRepresentable {
    var queue = Queue<Int>()
    var layerCount: Int
    var display: [TreeNodeArray] = []
    init(_ tree: BinarySearchTree<Int>){
      let layerCount = tree.height()
      self.layerCount = layerCount
      var layerLevel = 0
      var display: [TreeNodeArray] = []
      var queue = Queue<TreeNode>()
      let root = TreeNode(layer: layerLevel,
                          totalLayer: layerCount,
                          index: 0,
                          parentIndex: 0,
                          tree: tree)
      queue.enqueue(root)
      var layer = TreeNodeArray()
      layer.array.append(root)
      display.append(layer)
      while layerLevel < layerCount {
        var layer = TreeNodeArray()
        var countForLayer = pow(2, layerLevel)
        while countForLayer > 0 {
          let next = queue.dequeue()
          let parentIndex = next?.index
          let left = TreeNode(layer: layerLevel + 1,
                              totalLayer: layerCount,
                              index: layer.array.count,
                              parentIndex: parentIndex,
                              tree: next?.tree?.left)
          queue.enqueue(left)
          layer.array.append(left)
          let right = TreeNode(layer: layerLevel + 1,
                               totalLayer: layerCount,
                               index: layer.array.count,
                               parentIndex: parentIndex,
                               tree: next?.tree?.right)
          queue.enqueue(right)
          layer.array.append(right)
          countForLayer -= 1
        }
        display.append(layer)
        layerLevel += 1
      }
      self.display = display
    }
  }
  
  let listTitle = "Insertion Order"
  let graphTitle = "BST Tree"
  @Published var insertionOrder: [Int]
  @Published var currentTree: BinarySearchTree<Int>
  @Published var bstRep: BSTRepresentable
  
  init(){
    let start = Array((1...5))
    self.insertionOrder = start
    let currentTree = BinarySearchTree<Int>(array: start)
    self.currentTree = currentTree
    self.bstRep = BSTRepresentable(currentTree)
  }
  
  func move(from source: IndexSet, to destination: Int) {
    insertionOrder.move(fromOffsets: source, toOffset: destination)
    currentTree = BinarySearchTree<Int>(array: insertionOrder)
    bstRep = BSTRepresentable(currentTree)
  }
}

struct BinarySortTreeInsertionView: View {
  
  @ObservedObject var bstHolder = BinarySearchTreeHolder()
  @State var hideEmpty = false
  var body: some View {
    TabView {
      
      NavigationView {
        VStack {
          List {
            ForEach(bstHolder.insertionOrder) { item in
              Text("\(item)")
            }
            .onMove(perform: bstHolder.move)
          }
        }
        .navigationBarItems(trailing: EditButton())
        .navigationBarTitle(bstHolder.listTitle)
        
      }
      .tabItem {
        VStack{
          Image(systemName: "text.insert")
          Text(bstHolder.listTitle)
        }
      }
      
      NavigationView{
        VStack{
          ScrollView(.horizontal, showsIndicators: true) {
            VStack {
              ForEach(bstHolder.bstRep.display) { (layer: BinarySearchTreeHolder.TreeNodeArray) in
                HStack {
                  ForEach(layer.array) { (treeNode: BinarySearchTreeHolder.TreeNode) in
                    HStack{
                      Spacer().layoutPriority(0.0)
                      if treeNode.value != nil {
                        Image(systemName:  String(treeNode.value!) + ".circle").layoutPriority(1.0)
                      } else {
                        if self.hideEmpty {
                          Image(systemName: "n.circle")
                            .hidden()
                            .layoutPriority(1.0)
                        } else {
                          Image(systemName: "n.circle")
                            .layoutPriority(1.0)
                        }
                      }
                      Spacer().layoutPriority(0.0)
                    }
                  }
                }
              }
              
            }.padding()
          }
          Toggle(isOn: $hideEmpty) {
            Text("Hide Empty")
          }
        }
        .navigationBarTitle(bstHolder.graphTitle)
        .padding()
      }.tabItem {
        VStack{
          Image(systemName: "arrowtriangle.up")
          Text(bstHolder.graphTitle)
        }
      }.environment(\.isEnabled, true)
    }
  }
}

struct BinarySortTreeInsertionView_Previews: PreviewProvider {
  static var previews: some View {
    BinarySortTreeInsertionView()
  }
}