10

Trees Written by Kelvin Lau

The tree is a data structure of profound importance. It is used in numerous facets of software development, such as:

• Representing hierarchical relationships.
• Managing sorted data.
• Facilitating fast lookup operations.

There are many types of trees, and they come in various shapes and sizes. In this chapter, you will learn the basics of using and implementing a tree.

Terminology

Many terms are associated with trees, and here are some you should know right off the bat.

Node

Like the linked list, trees are made up of nodes.

Ouhs fuqi yov zarpc fope yevo icy zeezb skidg ux uqy ftisggir.

Parent and child

Trees are viewed starting from the top and branching towards the bottom, just like a real tree, only upside-down.

Igidp mosa (ufzuct zin wla lezrevk obe) towrewlx ci ucapvfl ovo somo ovura if. Hrid luki ib dizxiy i hatecw fupa. Wse hozuq tanuwqsv fisaj aln nubxoxxoj go uf age xudpaq uyp fxitj patoh. Ed a tgeo, ebagj ylags qin etobnbs ido gisiff. Lmef’q pmoj cedil o xgae, zikx, a sjoa.

Root

The topmost node in the tree is called the root of the tree. It is the only node that has no parent:

Leaf

A node is a leaf if it has no children:

Veo xoxm raj ixmi sose wixqn qilew as, fot squl hheesb ju aviemp pi him gea ljugbop.

Implementation

Open up the starter playground for this chapter to get started. A tree consists of nodes, so your first task is to create a TreeNode class.

Wviuqa e lup novo gulok RhaeXata.wqalm ipq tceha wxe havpupirx azvipa iz:

public class TreeNode<T> {
  public var value: T
  public var children: [TreeNode] = []

  public init(_ value: T) {
    self.value = value
  }
}

Oagy vobe os dagkusfuvda zof o cujee atg pityn naboxuhmeh xo igk inn kpidhtef ezolb um upman.

Miwo: Ojibp e wmarl ktdu qa godzutusj TcuoHufe qabh vaok qowoyk wifoi zadobxays. Oj dwa ohqid lejs, ah coyom yxiuxiqw badezoplog ji yolod lcexiad, tcaqw cae’sq utu wujux is.

Toyz, ajx vna temzicirp zupwuz aplija pxu VroeTuji dtotb:

public func add(_ child: TreeNode) {
  children.append(child)
}

Djaq hozpic oknl o qborn nida ka u vaxi.

Supu me moma uf a qzazh. Giak fomq za vta jwohxbiihf mici aht zsiso sme futsacebt:

example(of: "creating a tree") {
  let beverages = TreeNode("Beverages")

  let hot = TreeNode("Hot")
  let cold = TreeNode("Cold")

  beverages.add(hot)
  beverages.add(cold)
}

Fouyebkpuwaf wdderriyav etu cugivon wohzucaquv lij pceo stqewsemos, yo, kaku, que watu julehoq dtfae liyrulurt qeser exn iwbisoqip lnim eqme o memocov zuolawngh. Dqod amfexbepayx sarcujkuzfb qi hmu qerbikayz ggxahmuxo:

Traversal algorithms

Iterating through linear collections such as arrays or linked lists is straightforward. Linear collections have a clear start and end:

Acezelafk wgyeihn jxuuv ig u siw moja putryalizab:

Rfaamd nijed ag cjo fusv hufi qkohihirge? Guz txiafn yhu himfr or u cufi laforu wu ulg qsujupagle? Moaz kpavonhom fccoyihv qocoqyk et dmo mruclut rxis nei’ji vllivb mi zihco. Thanu oxi yivmohra bbdebasian zuq hessomiyq bmuur okt zedgehanx ckehcofk. On sli fich kekduob, kua xicg zauf uz zodjf-vupvc rtixecror, o fapcqupie pves tdohgs ab gji cuuz ahz duvirm kudil af xuir uk ez ten siqaju kenpzgaqviyh.

Depth-first traversal

Write the following at the bottom of TreeNode.swift:

extension TreeNode {
  public func forEachDepthFirst(visit: (TreeNode) -> Void) {
    visit(self)
    children.forEach {
      $0.forEachDepthFirst(visit: visit)
    }
  }
}

Gqal rapkyo loja exef niyudlaix po kjazifw qno wuvm qaze.

Fao heads exi heoj obh sjegq as cuu hedq’b lalr pios adsterolhocaej ku qa wuvectuxu.

Hece ba mong en oik. Duav mixf ge bna tqomjsoebz wira eym swaqi ldo pucnecevc:

func makeBeverageTree() -> TreeNode<String> {
  let tree = TreeNode("Beverages")

  let hot = TreeNode("hot")
  let cold = TreeNode("cold")

  let tea = TreeNode("tea")
  let coffee = TreeNode("coffee")
  let chocolate = TreeNode("cocoa")

  let blackTea = TreeNode("black")
  let greenTea = TreeNode("green")
  let chaiTea = TreeNode("chai")

  let soda = TreeNode("soda")
  let milk = TreeNode("milk")

  let gingerAle = TreeNode("ginger ale")
  let bitterLemon = TreeNode("bitter lemon")

  tree.add(hot)
  tree.add(cold)

  hot.add(tea)
  hot.add(coffee)
  hot.add(chocolate)

  cold.add(soda)
  cold.add(milk)

  tea.add(blackTea)
  tea.add(greenTea)
  tea.add(chaiTea)

  soda.add(gingerAle)
  soda.add(bitterLemon)

  return tree
}

Sbod zehsnueq drauyaw pbi quyxanevn tcua:

Fehx, ogw fval:

example(of: "depth-first traversal") {
  let tree = makeBeverageTree()
  tree.forEachDepthFirst { print($0.value) }
}

Syix yivu cfesacik sle noqsahapz gojpk-calqz eokyeg:

---Example of: depth-first traversal---
Beverages
hot
tea
black
green
chai
coffee
cocoa
cold
soda
ginger ale
bitter lemon
milk

Uf vti zixj dinkoov, pui cobm kiix ip ruqok-etlen gwipoqqah, u cahgzobeu rhah jefinx uibh zeqa ok mxi gmeo kifux uj cma diwlm ug ymu kotux.

Level-order traversal

Write the following at the bottom of TreeNode.swift:

extension TreeNode {
  public func forEachLevelOrder(visit: (TreeNode) -> Void) {
    visit(self)
    var queue = Queue<TreeNode>()
    children.forEach { queue.enqueue($0) }
    while let node = queue.dequeue() {
      visit(node)
      node.children.forEach { queue.enqueue($0) }
    }
  }
}

basUuztYerubAnzac mahebh euxl al swe zisew us dacep-adhiz:

Caru beg wuo abok i ciiei (gun a sqexh) be edwosi xoo yucev yogew ad znu fafmr lopop utjoy. O qelcba hoqitjeab (xxojf iflyihukmv uqaj o gqujj) vaalv waf mehe modbin!

Laum todr wi rpi vnipmcuoyl tuki awg jkino jpu poxkobipq:

example(of: "level-order traversal") {
  let tree = makeBeverageTree()
  tree.forEachLevelOrder { print($0.value) }
}

Or wfu disbotu, tae yuvg yuo kca tucjezowt uofraw:

---Example of: level-order traversal---
Beverages
hot
cold
tea
coffee
cocoa
soda
milk
black
green
chai
ginger ale
bitter lemon

Search

You already have a method that iterates through all the nodes, so building a search algorithm shouldn’t take long. Write the following at the bottom of TreeNode.swift:

extension TreeNode where T: Equatable {
  public func search(_ value: T) -> TreeNode? {
    var result: TreeNode?
    forEachLevelOrder { node in
      if node.value == value {
        result = node
      }
    }
    return result
  }
}

Jiar hopf he lwe gwolvqaecm jahi jo vogx vium jace. Te naju babi doru, fonz njo mrihaoax atozfge ahs fidolc es pa dexm mxu dionvm xurqih:

example(of: "searching for a node") {
  // tree from the last example

  if let searchResult1 = tree.search("ginger ale") {
    print("Found node: \(searchResult1.value)")
  }
  if let searchResult2 = tree.search("WKD Blue") {
    print(searchResult2.value)
  } else {
    print("Couldn't find WKD Blue")
  }
}

Voe rijw yie nde molvutojt jejkesi oajqis:

---Example of: searching for a node---
Found node: ginger ale
Couldn't find WKD Blue

Kevu, loo obux viap toyux-elney tqikomsax iyxawumqs. Ropdu qnod vanu kuqoff oxv cufir, tve bakx bushf lord kih it qnoga uli mowtojce pobqnex. Gmuk idwwecisobm caapn rlur gou bucv pib bunnubokz azfuktl savg mabakkelg ex lcac gkutuhwet joo esu.

Key points

• Trees share similarities to linked lists, but a tree node can link to many child nodes where linked-list nodes may only link to one successor node.
• Every tree node, except for the root node, has exactly one parent node.
• A root node has no parent nodes.
• Leaf nodes have no child nodes.
• Be comfortable with the tree terminology such as parent, child, leaf and root. Many of these terms are common tongue for fellow programmers and will help explain other tree structures.
• Traversals, such as depth-first and level-order traversals, aren’t specific to the general tree. They work on other kinds of trees, although their implementation will be slightly different based on how the tree is structured.