RediOne1/Tree-Data-Structure
1
0
Fork 0
mirror of https://github.com/AdrianKuta/Tree-Data-Structure.git synced 2026-06-20 03:10:14 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

21: Added path function to TreeNode (#22)

Browse Source 
Path refers to the sequence of nodes along the edges of a tree.
This commit is contained in:
Adrian Kuta
2023-02-22 14:29:22 +01:00
committed by GitHub
parent 8a4e677ebf
commit 4aacbc9dbc
10 changed files with 79 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
src/commonMain/kotlin/com.github.adriankuta/datastructure/tree/iterators/LevelOrderTreeIterator.kt Normal file
View File

@@ -0,0 +1,39 @@
package com.github.adriankuta.datastructure.tree.iterators
import com.github.adriankuta.datastructure.tree.TreeNode
/**
* Tree is iterated by using `Level-order Traversal Algorithm"
* In level-order traversal we iterating nodes level by level,
* starting from root, and going deeper and deeper in tree.
* ```
* E.g.
* 1
* / | \
* / | \
* 2 3 4
* / \ / | \
* 5 6 7 8 9
* / / | \
* 10 11 12 13
*
* Output: 1 2 3 4 5 6 7 8 9 10 11 12 13
* ```
*/
class LevelOrderTreeIterator<T>(root: TreeNode<T>) : Iterator<TreeNode<T>> {
private val stack = ArrayDeque<TreeNode<T>>()
init {
stack.addLast(root)
}
override fun hasNext(): Boolean = stack.isNotEmpty()
override fun next(): TreeNode<T> {
val node = stack.removeFirst()
node.children
.forEach { stack.addLast(it) }
return node
}
}

48
src/commonMain/kotlin/com.github.adriankuta/datastructure/tree/iterators/PostOrderTreeIterator.kt Normal file
View File

@@ -0,0 +1,48 @@
package com.github.adriankuta.datastructure.tree.iterators
import com.github.adriankuta.datastructure.tree.TreeNode
/**
* Tree is iterated by using `Post-order Traversal Algorithm"
* In post-order traversal, we starting from most left child.
* First visit all children of parent, then parent.
* ```
* E.g.
* 1
* / | \
* / | \
* 2 3 4
* / \ / | \
* 5 6 7 8 9
* / / | \
* 10 11 12 13
*
* Output: 10 5 11 12 13 6 2 3 7 8 9 4 1
* ```
*/
class PostOrderTreeIterator<T>(root: TreeNode<T>) : Iterator<TreeNode<T>> {
private val stack = ArrayDeque<TreeNode<T>>()
init {
stack.addAll(getChildrenStack(root))
}
override fun hasNext(): Boolean = stack.isNotEmpty()
override fun next(): TreeNode<T> {
return stack.removeFirst()
}
private fun getChildrenStack(node: TreeNode<T>): ArrayDeque<TreeNode<T>> {
val stack = ArrayDeque<TreeNode<T>>()
if(node.children.isEmpty()) {
return ArrayDeque(listOf(node))
}
node.children.forEach {
stack.addAll(getChildrenStack(it))
}
stack.addLast(node)
return stack
}
}

40
src/commonMain/kotlin/com.github.adriankuta/datastructure/tree/iterators/PreOrderTreeIterator.kt Normal file
View File

@@ -0,0 +1,40 @@
package com.github.adriankuta.datastructure.tree.iterators
import com.github.adriankuta.datastructure.tree.TreeNode
/**
* Tree is iterated by using `Pre-order Traversal Algorithm"
* The pre-order traversal is a topologically sorted one,
* because a parent node is processed before any of its child nodes is done.
* ```
* E.g.
* 1
* / | \
* / | \
* 2 3 4
* / \ / | \
* 5 6 7 8 9
* / / | \
* 10 11 12 13
*
* Output: 1 2 5 10 6 11 12 13 3 4 7 8 9
* ```
*/
class PreOrderTreeIterator<T>(root: TreeNode<T>) : Iterator<TreeNode<T>> {
private val stack = ArrayDeque<TreeNode<T>>()
init {
stack.addLast(root)
}
override fun hasNext(): Boolean = stack.isNotEmpty()
override fun next(): TreeNode<T> {
val node = stack.removeLast()
node.children
.asReversed()
.forEach { stack.addLast(it) }
return node
}
}

68
src/commonMain/kotlin/com.github.adriankuta/datastructure/tree/iterators/TreeNodeIterators.kt Normal file
View File

@@ -0,0 +1,68 @@
package com.github.adriankuta.datastructure.tree.iterators
/**
* @see PreOrder
* @see PostOrder
* @see LevelOrder
*/
enum class TreeNodeIterators {
/**
* Tree is iterated by using `Pre-order Traversal Algorithm"
* The pre-order traversal is a topologically sorted one,
* because a parent node is processed before any of its child nodes is done.
* ```
* E.g.
* 1
* / | \
* / | \
* 2 3 4
* / \ / | \
* 5 6 7 8 9
* / / | \
* 10 11 12 13
*
* Output: 1 2 5 10 6 11 12 13 3 4 7 8 9
* ```
*/
PreOrder,
/**
* Tree is iterated by using `Post-order Traversal Algorithm"
* In post-order traversal, we starting from most left child.
* First visit all children of parent, then parent.
* ```
* E.g.
* 1
* / | \
* / | \
* 2 3 4
* / \ / | \
* 5 6 7 8 9
* / / | \
* 10 11 12 13
*
* Output: 10 5 11 12 13 6 2 3 7 8 9 4 1
* ```
*/
PostOrder,
/**
* Tree is iterated by using `Level-order Traversal Algorithm"
* In level-order traversal we iterating nodes level by level,
* starting from root, and going deeper and deeper in tree.
* ```
* E.g.
* 1
* / | \
* / | \
* 2 3 4
* / \ / | \
* 5 6 7 8 9
* / / | \
* 10 11 12 13
*
* Output: 1 2 3 4 5 6 7 8 9 10 11 12 13
* ```
*/
LevelOrder
}