/// <summary>
/// Copies the contents of the BST to an appropriately-sized array of type T, using a specified traversal method.
/// </summary>
public void CopyTo(T[] array, int index, TraversalMethod traversalMethod)
{
IEnumerable <T> enumerable = null;
// Determine which Enumerator-returning property to use, based on the TraversalMethod input parameter
if (traversalMethod == TraversalMethod.Preorder)
{
enumerable = Preorder;
}
else if (traversalMethod == TraversalMethod.Inorder)
{
enumerable = Inorder;
}
else
{
enumerable = Postorder;
}
// dump the contents of the tree into the passed-in array
int i = 0;
foreach (T value in enumerable)
{
array[i + index] = value;
i++;
}
}
/// <summary>
/// Copies the contents of the BST to an appropriately-sized array of type T, using a specified
/// traversal method.
/// </summary>
public void CopyTo(T[] array, int index, TraversalMethod TraversalMethod)
{
IEnumerable <T> enumProp = null;
// Determine which Enumerator-returning property to use, based on the TraversalMethod input parameter
switch (TraversalMethod)
{
case TraversalMethod.Preorder:
enumProp = PreorderEnumerable;
break;
case TraversalMethod.Inorder:
enumProp = InorderEnumerable;
break;
case TraversalMethod.Postorder:
default:
enumProp = PostorderEnumerable;
break;
}
// dump the contents of the tree into the passed-in array
int i = 0;
foreach (T value in enumProp)
{
array[i + index] = value;
i++;
}
}
/// <summary>
/// 노드들을 지정된 탐색 방법에 따라 지정된 컬렉션에 담는다.
/// </summary>
/// <param name="list"></param>
/// <param name="method"></param>
public virtual void GetTreeDataList(IList <T> list, TraversalMethod method)
{
// 탐색 방법에 따라 얻는다.
foreach (T data in GetValueEnumerable(method))
{
list.Add(data);
}
}
/// <summary>
/// 지정된 탐색 방법으로 노드들의 값을 집합형식의 문자열로 만듦
/// </summary>
/// <param name="method">탐색 방법</param>
/// <returns>문자열</returns>
public virtual string ToString(TraversalMethod method)
{
if (IsEmpty)
{
return(ReflectionTool.CollectionToString(null));
}
return(GetValueEnumerable(method).CollectionToString());
}
/// <summary>
/// 이진트리에 있는 노드의 값들을 1차원 배열에 복사한다.
/// </summary>
/// <param name="array">값을 담을 1차원 배열</param>
/// <param name="arrayIndex">값을 담을 배열의 첫번째 위치</param>
/// <param name="method">탐색 방법</param>
/// <exception cref="ArgumentOutOfRangeException">값을 담을 배열의 주어진 크기가 작을때</exception>
public void CopyTo(T[] array, int arrayIndex, TraversalMethod method)
{
array.ShouldNotBeNull("array");
Guard.Assert(_count + arrayIndex <= array.Length, @"arrayIndex is larger than length of array to copy space");
foreach (T value in GetValueEnumerable(method))
{
array[arrayIndex++] = value;
}
}
public IEnumerator <K> GetEnumerator(TraversalMethod method)
{
switch (method)
{
case TraversalMethod.Preorder:
return(new BinaryTreeEnumerator <K>(PreorderTraversal(Root, new List <K>()).ToArray()));
default:
case TraversalMethod.Inorder:
return(new BinaryTreeEnumerator <K>(InorderTraversal(Root, new List <K>()).ToArray()));
case TraversalMethod.Postorder:
return(new BinaryTreeEnumerator <K>(PostorderTraversal(Root, new List <K>()).ToArray()));
}
}
/// <summary>
/// Enumerates the BST's contents using a specified traversal method.
/// </summary>
/// <param name="traversalMethod">The type of traversal to perform.</param>
/// <returns>An enumerator that provides access to the BST's elements using a specified traversal technique.</returns>
public virtual IEnumerator <T> GetEnumerator(TraversalMethod traversalMethod)
{
// The traversal approaches are defined as public properties in the BST class...
// This method simply returns the appropriate property.
switch (traversalMethod)
{
case TraversalMethod.Preorder:
return(Preorder.GetEnumerator());
case TraversalMethod.Inorder:
return(Inorder.GetEnumerator());
default:
return(Postorder.GetEnumerator());
}
}
public IEnumerator <T> GetEnumerator(TraversalMethod TraversalMethod)
{
// The traversal approaches are defined as public properties in the BST class...
// This method simply returns the appropriate property.
if (TraversalMethod == TraversalMethod.Preorder)
{
return(Preorder.GetEnumerator());
}
else if (TraversalMethod == TraversalMethod.Inorder)
{
return(Inorder.GetEnumerator());
}
else
{
return(Postorder.GetEnumerator());
}
}
/// <summary></summary>
public IEnumerator <BinaryTreeNode <T> > GetEnumerator(TraversalMethod method)
{
switch (method)
{
case TraversalMethod.Postorder:
return(Postorder.GetEnumerator());
case TraversalMethod.Inorder:
return(Inorder.GetEnumerator());
case TraversalMethod.Levelorder:
return(Levelorder.GetEnumerator());
case TraversalMethod.Preorder:
default:
return(Preorder.GetEnumerator());
}
}
public void Traverse(TraversalMethod method, Action <TreeNode <TValue> > onVisitAction)
{
if (method == TraversalMethod.InOrder)
{
TraverseInOrder(Root, onVisitAction);
}
else if (method == TraversalMethod.PreOrder)
{
TraversePreOrder(Root, onVisitAction);
}
else if (method == TraversalMethod.PostOrder)
{
TraversePostOrder(Root, onVisitAction);
}
else if (method == TraversalMethod.LevelOrder)
{
TraverseLevelOrder(Root, onVisitAction);
}
}
/// <summary>
/// 탐색 방법에 따른 값에 대한 노드 값에 대한 반복자를 제공한다.
/// </summary>
public virtual IEnumerable <T> GetValueEnumerable(TraversalMethod method)
{
switch (method)
{
case TraversalMethod.PreOrder:
return(PreOrder);
case TraversalMethod.InOrder:
return(InOrder);
case TraversalMethod.PostOrder:
return(PostOrder);
case TraversalMethod.InRevOrder:
return(InRevOrder);
default:
return(InOrder);
}
}
/// <summary>
/// 탐색 방법에 따른 노드에 대한 반복자를 반환한다.
/// </summary>
public virtual IEnumerable <BinaryTreeNode <T> > GetNodeEnumerable(TraversalMethod method)
{
switch (method)
{
case TraversalMethod.PreOrder:
return(PreOrderNode);
case TraversalMethod.InOrder:
return(InOrderNode);
case TraversalMethod.PostOrder:
return(PostOrderNode);
case TraversalMethod.InRevOrder:
return(InRevOrderNode);
default:
return(InOrderNode);
}
}
/// <summary>
/// Traverse the group/entry tree in the current group. Various traversal
/// methods are available.
/// </summary>
/// <param name="tm">Specifies the traversal method.</param>
/// <param name="groupHandler">Function that performs an action on
/// the currently visited group (see <c>GroupHandler</c> for more).
/// This parameter may be <c>null</c>, in this case the tree is traversed but
/// you don't get notifications for each visited group.</param>
/// <param name="entryHandler">Function that performs an action on
/// the currently visited entry (see <c>EntryHandler</c> for more).
/// This parameter may be <c>null</c>.</param>
/// <returns>Returns <c>true</c> if all entries and groups have been
/// traversed. If the traversal has been canceled by one of the two
/// handlers, the return value is <c>false</c>.</returns>
public bool TraverseTree(TraversalMethod tm, GroupHandler groupHandler, EntryHandler entryHandler)
{
bool bRet = false;
switch (tm)
{
case TraversalMethod.None:
bRet = true;
break;
case TraversalMethod.PreOrder:
bRet = PreOrderTraverseTree(groupHandler, entryHandler);
break;
default:
Debug.Assert(false);
break;
}
return(bRet);
}
public void CopyTo(K[] array, int arrayIndex, TraversalMethod method)
{
if (Root == null)
{
return;
}
switch (method)
{
case TraversalMethod.Preorder:
PreorderTraversal(Root, new List <K>()).CopyTo(array, arrayIndex);
break;
default:
case TraversalMethod.Inorder:
InorderTraversal(Root, new List <K>()).CopyTo(array, arrayIndex);
break;
case TraversalMethod.Postorder:
PostorderTraversal(Root, new List <K>()).CopyTo(array, arrayIndex);
break;
}
Dictionary <string, string> d = new Dictionary <string, string>();
}
public string Print(TraversalMethod traversalMethod = TraversalMethod.PreOrder)
{
StringBuilder sb = new StringBuilder();
switch (traversalMethod)
{
case TraversalMethod.InOrder:
this.VisitInOrder(this.Root, node =>
{
sb.Append(node.Name);
sb.Append(", ");
return(true);
});
break;
case TraversalMethod.PreOrder:
this.VisitPreOrder(this.Root, node =>
{
sb.Append(node.Name);
sb.Append(", ");
return(true);
});
break;
case TraversalMethod.PostOrder:
this.VisitPostOrder(this.Root, node =>
{
sb.Append(node.Name);
sb.Append(", ");
return(true);
});
break;
}
return(sb.ToString());
}
/// <summary></summary>
public IEnumerator <TreeNode <T> > GetEnumerator(TraversalMethod method)
{
switch (method)
{
case TraversalMethod.Postorder:
return(Postorder.GetEnumerator());
case TraversalMethod.Inorder:
return(Inorder.GetEnumerator());
case TraversalMethod.Levelorder:
return(Levelorder.GetEnumerator());
case TraversalMethod.Children:
return(this._children.GetEnumerator());
case TraversalMethod.Path:
return(Path.GetEnumerator());
case TraversalMethod.Preorder:
default:
return(Preorder.GetEnumerator());
}
}
/// <summary>
/// Traverse the tree using a <see cref="TreeTraversal">tree traversal
/// method</see>. Can be iterated with a foreach loop.
/// </summary>
///
/// <param name="method">The tree traversal method. Common methods are
/// available in the <see cref="TreeTraversal"/>static class.</param>
///
/// <returns>An <see cref="IEnumerable{T}"/> object which can be used to
/// traverse the tree using the chosen traversal method.</returns>
///
public IEnumerable <TNode> Traverse(TraversalMethod <TNode> method)
{
return(new InnerTreeTraversal(this, method));
}
/// <summary>
/// 탐색 방법에 따라 탐색하면서 값들을 집합형식으로 표현한 문자열을 반환한다.
/// </summary>
/// <param name="method">탐색 방법</param>
/// <returns>노드 값을 집합으로 표현한 문자열 </returns>
public string TraverseToString(TraversalMethod method)
{
return(ToString(method));
}
private String PrintTree(TraversalMethod method, TraversalDirection direction, Node <K, V> currentNode, String result)
{
if (direction == TraversalDirection.Forwards)
{
switch (method)
{
case TraversalMethod.Preorder:
if (currentNode != null)
{
result = result + currentNode.Key + " " + currentNode.Value + ", ";
result = PrintTree(method, direction, currentNode.Left, result);
result = PrintTree(method, direction, currentNode.Right, result);
}
break;
default:
case TraversalMethod.Inorder:
if (currentNode != null)
{
result = PrintTree(method, direction, currentNode.Left, result);
result = result + currentNode.Key + " " + currentNode.Value + ", ";
result = PrintTree(method, direction, currentNode.Right, result);
}
break;
case TraversalMethod.Postorder:
if (currentNode != null)
{
result = PrintTree(method, direction, currentNode.Left, result);
result = PrintTree(method, direction, currentNode.Right, result);
result = result + currentNode.Key + " " + currentNode.Value + ", ";
}
break;
}
}
else
{
switch (method)
{
case TraversalMethod.Preorder:
if (currentNode != null)
{
result = result + currentNode.Key + " " + currentNode.Value + ", ";
result = PrintTree(method, direction, currentNode.Right, result);
result = PrintTree(method, direction, currentNode.Left, result);
}
break;
default:
case TraversalMethod.Inorder:
if (currentNode != null)
{
result = PrintTree(method, direction, currentNode.Right, result);
result = result + currentNode.Value + " " + currentNode.Key + ", ";
result = PrintTree(method, direction, currentNode.Left, result);
}
break;
case TraversalMethod.Postorder:
if (currentNode != null)
{
result = PrintTree(method, direction, currentNode.Right, result);
result = PrintTree(method, direction, currentNode.Left, result);
result = result + currentNode.Key + " " + currentNode.Value + ", ";
}
break;
}
}
return(result);
}
public String PrintTree(TraversalMethod method, TraversalDirection direction)
{
String temp = PrintTree(method, direction, Root, "");
return(temp.Remove(temp.Length - 2));
}
/// <summary>
/// Return enumerator by the specified traversal method.
/// </summary>
/// <param name="method">Traversal method</param>
/// <returns>Enumerator of {T}</returns>
public IEnumerator <T> GetEnumerator(TraversalMethod method)
{
return(GetValueEnumerable(method).GetEnumerator());
}
/// <summary>
/// Return binary tree node enumerator by the specified traversal method.
/// </summary>
/// <param name="method"></param>
/// <returns>Enumerator of <see cref="BinaryTreeNode{T}"/></returns>
public IEnumerator <BinaryTreeNode <T> > GetNodeEnumerator(TraversalMethod method)
{
return(GetNodeEnumerable(method).GetEnumerator());
}
public void CopyTo(ref Array array, int index = 0, TraversalMethod traversal = TraversalMethod.Inorder)
{
throw new NotImplementedException();
}
public InnerTreeTraversal(Tree <TNode> tree, TraversalMethod <TNode> method)
{
this.tree = tree;
this.method = method;
}
public InnerTreeTraversal(Tree <TNode> tree, TraversalMethod <TNode> method)
{
_tree = tree;
_method = method;
}