mirror of
https://github.com/AdrianKuta/Tree-Data-Structure.git
synced 2025-04-19 23:19:03 +02:00
Implemented iterator. Kotlin extensions.
This commit is contained in:
parent
567e134b97
commit
0a04ecd532
@ -1,45 +1,94 @@
|
||||
package com.github.adriankuta.datastructure.tree
|
||||
|
||||
open class TreeNode<T>(val value: T) {
|
||||
open class TreeNode<T>(val value: T) : Iterable<TreeNode<T>>, ChildDeclarationInterface<T> {
|
||||
|
||||
private var parent: TreeNode<T>? = null
|
||||
private val children = mutableListOf<TreeNode<T>>()
|
||||
private var _parent: TreeNode<T>? = null
|
||||
/**
|
||||
* The converse notion of a child, an immediate ancestor.
|
||||
*/
|
||||
val parent: TreeNode<T>?
|
||||
get() = _parent
|
||||
|
||||
private val _children = mutableListOf<TreeNode<T>>()
|
||||
/**
|
||||
* A group of nodes with the same parent.
|
||||
*/
|
||||
val children: List<TreeNode<T>>
|
||||
get() = _children
|
||||
|
||||
/**
|
||||
* Add new child to current node or root.
|
||||
*
|
||||
* @param child A node which will be directly connected to current node.
|
||||
*/
|
||||
fun addChild(child: TreeNode<T>) {
|
||||
child.parent = this
|
||||
children += child
|
||||
child._parent = this
|
||||
_children.add(child)
|
||||
}
|
||||
|
||||
override fun child(value: T, childDeclaration: ChildDeclaration<T>?) {
|
||||
val newChild = TreeNode(value)
|
||||
if(childDeclaration != null)
|
||||
newChild.childDeclaration()
|
||||
_children.add(newChild)
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes a single instance of the specified node from this tree, if it is present.
|
||||
*
|
||||
* @return `true` if the node has been successfully removed; `false` if it was not present in the tree.
|
||||
*/
|
||||
fun removeChild(child: TreeNode<T>): Boolean {
|
||||
if (children.isEmpty()) {
|
||||
return false
|
||||
val removed = child._parent?._children?.remove(child)
|
||||
child._parent = null
|
||||
return removed ?: false
|
||||
}
|
||||
|
||||
val nestedChildRemoved = children.map {
|
||||
it.removeChild(child)
|
||||
}.reduce { acc, b -> acc or b }
|
||||
|
||||
return children.remove(child) or nestedChildRemoved
|
||||
}
|
||||
|
||||
fun getParent(): TreeNode<T>? = parent
|
||||
|
||||
fun getChildren(): List<TreeNode<T>> = children
|
||||
|
||||
fun size(): Int {
|
||||
if (children.isEmpty())
|
||||
/**
|
||||
* This function go through tree and counts children. Root element is not counted.
|
||||
* @return All child and nested child count.
|
||||
*/
|
||||
fun nodeCount(): Int {
|
||||
if (_children.isEmpty())
|
||||
return 0
|
||||
return children.size +
|
||||
children.sumBy { it.size() }
|
||||
|
||||
return _children.size +
|
||||
_children.sumBy { it.nodeCount() }
|
||||
}
|
||||
|
||||
fun depth(): Int {
|
||||
|
||||
val childrenMaxDepth = children.map { it.depth() }.max() ?: 0
|
||||
/**
|
||||
* @return The number of edges on the longest path between current node and a descendant leaf.
|
||||
*/
|
||||
fun height(): Int {
|
||||
val childrenMaxDepth = _children.map { it.height() }
|
||||
.max()
|
||||
?: -1 // -1 because this method counts nodes, and edges are always one less then nodes.
|
||||
return childrenMaxDepth + 1
|
||||
}
|
||||
|
||||
/**
|
||||
* Distance is the number of edges along the shortest path between two nodes.
|
||||
* @return The distance between current node and the root.
|
||||
*/
|
||||
fun depth(): Int {
|
||||
var _depth = 0
|
||||
var tempParent = parent
|
||||
|
||||
while (tempParent != null) {
|
||||
_depth++
|
||||
tempParent = tempParent.parent
|
||||
}
|
||||
return _depth
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove all children from root and every node in tree.
|
||||
*/
|
||||
fun clear() {
|
||||
_parent = null
|
||||
_children.forEach { it.clear() }
|
||||
_children.clear()
|
||||
}
|
||||
|
||||
override fun toString(): String {
|
||||
val stringBuilder = StringBuilder()
|
||||
print(stringBuilder, "", "")
|
||||
@ -50,7 +99,7 @@ open class TreeNode<T>(val value: T) {
|
||||
stringBuilder.append(prefix)
|
||||
stringBuilder.append(value)
|
||||
stringBuilder.append('\n')
|
||||
val childIterator = children.iterator()
|
||||
val childIterator = _children.iterator()
|
||||
while (childIterator.hasNext()) {
|
||||
val node = childIterator.next()
|
||||
if (childIterator.hasNext()) {
|
||||
@ -60,4 +109,26 @@ open class TreeNode<T>(val value: T) {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Tree is iterated by using `Pre-order Traversal Algorithm"
|
||||
* 1. Check if the current node is empty or null.
|
||||
* 2. Display the data part of the root (or current node).
|
||||
* 3. Traverse the left subtree by recursively calling the pre-order function.
|
||||
* 4. Traverse the right subtree by recursively calling the pre-order function.
|
||||
* ```
|
||||
* 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
|
||||
* ```
|
||||
*/
|
||||
override fun iterator(): Iterator<TreeNode<T>> = TreeNodeIterator(this)
|
||||
}
|
||||
@ -0,0 +1,15 @@
|
||||
package com.github.adriankuta.datastructure.tree
|
||||
|
||||
typealias ChildDeclaration<T> = ChildDeclarationInterface<T>.() -> Unit
|
||||
|
||||
@JvmSynthetic
|
||||
inline fun<reified T> treeNode(value: T, childDeclaration: ChildDeclaration<T>): TreeNode<T> {
|
||||
val treeNode = TreeNode(value)
|
||||
treeNode.childDeclaration()
|
||||
return treeNode
|
||||
}
|
||||
|
||||
interface ChildDeclarationInterface<T> {
|
||||
|
||||
fun child(value: T, childDeclaration: ChildDeclaration<T>? = null)
|
||||
}
|
||||
@ -0,0 +1,22 @@
|
||||
package com.github.adriankuta.datastructure.tree
|
||||
|
||||
import java.util.*
|
||||
|
||||
class TreeNodeIterator<T>(root: TreeNode<T>) : Iterator<TreeNode<T>> {
|
||||
|
||||
private val stack = Stack<TreeNode<T>>()
|
||||
|
||||
init {
|
||||
stack.push(root)
|
||||
}
|
||||
|
||||
override fun hasNext(): Boolean = !stack.empty()
|
||||
|
||||
override fun next(): TreeNode<T> {
|
||||
val node = stack.pop()
|
||||
node.children
|
||||
.asReversed()
|
||||
.forEach { stack.push(it) }
|
||||
return node
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,131 @@
|
||||
package com.github.adriankuta.datastructure.tree
|
||||
|
||||
import org.hamcrest.CoreMatchers.`is`
|
||||
import org.hamcrest.CoreMatchers.nullValue
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertThat
|
||||
import org.junit.Test
|
||||
|
||||
class TreeNodeTest {
|
||||
|
||||
@Test
|
||||
fun removeNodeTest() {
|
||||
val root = TreeNode<String>("Root")
|
||||
val beveragesNode = TreeNode<String>("Beverages")
|
||||
val curdNode = TreeNode<String>("Curd")
|
||||
root.addChild(beveragesNode)
|
||||
root.addChild(curdNode)
|
||||
|
||||
val teaNode = TreeNode<String>("tea")
|
||||
val coffeeNode = TreeNode<String>("coffee")
|
||||
val milkShakeNode = TreeNode<String>("Milk Shake")
|
||||
beveragesNode.addChild(teaNode)
|
||||
beveragesNode.addChild(coffeeNode)
|
||||
beveragesNode.addChild(milkShakeNode)
|
||||
|
||||
val gingerTeaNode = TreeNode<String>("ginger tea")
|
||||
val normalTeaNode = TreeNode<String>("normal tea")
|
||||
teaNode.addChild(gingerTeaNode)
|
||||
teaNode.addChild(normalTeaNode)
|
||||
|
||||
val yogurtNode = TreeNode<String>("yogurt")
|
||||
val lassiNode = TreeNode<String>("lassi")
|
||||
curdNode.addChild(yogurtNode)
|
||||
curdNode.addChild(lassiNode)
|
||||
|
||||
assertEquals(
|
||||
"Root\n" +
|
||||
"├── Beverages\n" +
|
||||
"│ ├── tea\n" +
|
||||
"│ │ ├── ginger tea\n" +
|
||||
"│ │ └── normal tea\n" +
|
||||
"│ ├── coffee\n" +
|
||||
"│ └── Milk Shake\n" +
|
||||
"└── Curd\n" +
|
||||
" ├── yogurt\n" +
|
||||
" └── lassi\n", root.toString()
|
||||
)
|
||||
|
||||
System.out.println("Remove: ${curdNode.value}")
|
||||
root.removeChild(curdNode)
|
||||
System.out.println("Remove: ${gingerTeaNode.value}")
|
||||
root.removeChild(gingerTeaNode)
|
||||
assertEquals(
|
||||
"Root\n" +
|
||||
"└── Beverages\n" +
|
||||
" ├── tea\n" +
|
||||
" │ └── normal tea\n" +
|
||||
" ├── coffee\n" +
|
||||
" └── Milk Shake\n", root.toString()
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun clearTest() {
|
||||
val root = TreeNode<String>("Root")
|
||||
val beveragesNode = TreeNode<String>("Beverages")
|
||||
val curdNode = TreeNode<String>("Curd")
|
||||
root.addChild(beveragesNode)
|
||||
root.addChild(curdNode)
|
||||
|
||||
val teaNode = TreeNode<String>("tea")
|
||||
val coffeeNode = TreeNode<String>("coffee")
|
||||
val milkShakeNode = TreeNode<String>("Milk Shake")
|
||||
beveragesNode.addChild(teaNode)
|
||||
beveragesNode.addChild(coffeeNode)
|
||||
beveragesNode.addChild(milkShakeNode)
|
||||
|
||||
val gingerTeaNode = TreeNode<String>("ginger tea")
|
||||
val normalTeaNode = TreeNode<String>("normal tea")
|
||||
teaNode.addChild(gingerTeaNode)
|
||||
teaNode.addChild(normalTeaNode)
|
||||
|
||||
val yogurtNode = TreeNode<String>("yogurt")
|
||||
val lassiNode = TreeNode<String>("lassi")
|
||||
curdNode.addChild(yogurtNode)
|
||||
curdNode.addChild(lassiNode)
|
||||
|
||||
println(root.toString())
|
||||
println(curdNode.height())
|
||||
|
||||
root.clear()
|
||||
assertThat(root.children, `is`(emptyList()))
|
||||
assertThat(beveragesNode.children, `is`(emptyList()))
|
||||
assertThat(curdNode.children, `is`(emptyList()))
|
||||
assertThat(teaNode.children, `is`(emptyList()))
|
||||
assertThat(coffeeNode.children, `is`(emptyList()))
|
||||
assertThat(milkShakeNode.children, `is`(emptyList()))
|
||||
assertThat(gingerTeaNode.children, `is`(emptyList()))
|
||||
assertThat(normalTeaNode.children, `is`(emptyList()))
|
||||
assertThat(yogurtNode.children, `is`(emptyList()))
|
||||
assertThat(lassiNode.children, `is`(emptyList()))
|
||||
|
||||
assertThat(root.parent, `is`(nullValue()))
|
||||
assertThat(beveragesNode.parent, `is`(nullValue()))
|
||||
assertThat(curdNode.parent, `is`(nullValue()))
|
||||
assertThat(teaNode.parent, `is`(nullValue()))
|
||||
assertThat(coffeeNode.parent, `is`(nullValue()))
|
||||
assertThat(milkShakeNode.parent, `is`(nullValue()))
|
||||
assertThat(gingerTeaNode.parent, `is`(nullValue()))
|
||||
assertThat(normalTeaNode.parent, `is`(nullValue()))
|
||||
assertThat(yogurtNode.parent, `is`(nullValue()))
|
||||
assertThat(lassiNode.parent, `is`(nullValue()))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun kotlinExtTest() {
|
||||
val root = treeNode("World") {
|
||||
child("North America") {
|
||||
child("USA")
|
||||
}
|
||||
child("Europe") {
|
||||
child("Poland")
|
||||
child("Germany")
|
||||
}
|
||||
}
|
||||
|
||||
println(root)
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user