Министерство образования и науки России

Федеральное государственное бюджетное образовательное учреждение высшего

образования «Тульский государственный университет»
Институт прикладной математики и компьютерных наук
Кафедра «Вычислительная техника»

Структуры и алгоритмы обработки данных

Отчёт по лабораторной работе №5
Структуры данных типа дерево

Выполнил студент группы 220601 _________ Осипов Д.В.

Проверил Доцент каф. _________ Афанасьева С. М.

г. Тула, 2021
 2

СОДЕРЖАНИЕ

Задачи и цель работы………………………………………………………………3

Ход выполнения работы…………………………………………………..……….4
Вывод……………………………………………………………..…………………7
 3

1. ЗАДАЧИ И ЦЕЛЬ РАБОТЫ

Ознакомится с представлением данных в виде деревьев. Изучить основные

алгоритмы обхода деревьев.
 4

3. ХОД ВЫПОЛНЕНИЯ РАБОТЫ

Итак, после изучения теоретических положений лабораторной работы мы

приступили к практическому выполнению. В среде MS Visual Studio была набрана
программа с выполнением всех требуемых условий.
1. Реализуйте на языке программирования С# дерево целых чисел, добавление и
удаление листьев. Создайте процедуру обхода дерева «в глубину».

using System;
namespace ConsoleApp1
{
public enum Side
{
Left,
Right
}
public class TreeNode<T> where T : IComparable
{
public TreeNode(T data)
{
Data = data;
}
public T Data { get; set; }
public TreeNode<T> LeftNode { get; set; }
public TreeNode<T> RightNode { get; set; }
public TreeNode<T> ParentNode { get; set; }
public Side? NodeSide =>
ParentNode == null
? (Side?)null
: ParentNode.LeftNode == this
? Side.Left
: Side.Right;
public override string ToString() => Data.ToString();
}
public class BinaryTree<T> where T : IComparable
{
public TreeNode<T> RootNode { get; set; }

public TreeNode<T> Add(TreeNode<T> node, TreeNode<T> currentNode = null)

{
if (RootNode == null)
{
node.ParentNode = null;
return RootNode = node;
}

currentNode = currentNode ?? RootNode;

node.ParentNode = currentNode;
int result;
return (result = node.Data.CompareTo(currentNode.Data)) == 0
? currentNode
: result < 0
? currentNode.LeftNode == null
? (currentNode.LeftNode = node)
: Add(node, currentNode.LeftNode)
: currentNode.RightNode == null
? (currentNode.RightNode = node)
: Add(node, currentNode.RightNode);
}
public TreeNode<T> Add(T data)
{
return Add(new TreeNode<T>(data));
}
public TreeNode<T> FindNode(T data, TreeNode<T> startWithNode = null)
{
startWithNode = startWithNode ?? RootNode;
int result;
return (result = data.CompareTo(startWithNode.Data)) == 0
? startWithNode
: result < 0
? startWithNode.LeftNode == null
? null
: FindNode(data, startWithNode.LeftNode)
: startWithNode.RightNode == null
? null
: FindNode(data, startWithNode.RightNode);
}
public void Remove(TreeNode<T> node)
{
if (node == null)
return;
var currentNodeSide = node.NodeSide;
if (node.LeftNode == null && node.RightNode == null)
{
if (currentNodeSide == Side.Left)
{
 5

node.ParentNode.LeftNode = null;
}
else
{
node.ParentNode.RightNode = null;
}
}
else if (node.LeftNode == null)
{
if (currentNodeSide == Side.Left)
{
node.ParentNode.LeftNode = node.RightNode;
}
else
{
node.ParentNode.RightNode = node.RightNode;
}

node.RightNode.ParentNode = node.ParentNode;
}
else if (node.RightNode == null)
{
if (currentNodeSide == Side.Left)
{
node.ParentNode.LeftNode = node.LeftNode;
}
else
{
node.ParentNode.RightNode = node.LeftNode;
}

node.LeftNode.ParentNode = node.ParentNode;
}
else
{
switch (currentNodeSide)
{
case Side.Left:
node.ParentNode.LeftNode = node.RightNode;
node.RightNode.ParentNode = node.ParentNode;
Add(node.LeftNode, node.RightNode);
break;
case Side.Right:
node.ParentNode.RightNode = node.RightNode;
node.RightNode.ParentNode = node.ParentNode;
Add(node.LeftNode, node.RightNode);
break;
default:
var bufLeft = node.LeftNode;
var bufRightLeft = node.RightNode.LeftNode;
var bufRightRight = node.RightNode.RightNode;
node.Data = node.RightNode.Data;
node.RightNode = bufRightRight;
node.LeftNode = bufRightLeft;
Add(bufLeft, node);
break;
}
}
}
public void Remove(T data)
{
var foundNode = FindNode(data);
Remove(foundNode);
}
public void PrintTree()
{
PrintTree(RootNode);
}
private void PrintTree(TreeNode<T> startNode, string indent = "", Side? side = null)
{
if (startNode != null)
{
var nodeSide = side == null ? "+" : side == Side.Left ? "1" : "2";
Console.WriteLine($"{indent} [{nodeSide}]- {startNode.Data}");
indent += new string(' ', 3);
PrintTree(startNode.LeftNode, indent, Side.Left);
PrintTree(startNode.RightNode, indent, Side.Right);
}
}
}
class Program
{
static void Main(string[] args)
{
Random rnd = new Random();
var Tree = new BinaryTree<int>();
// Tree.Add(rnd.Next(1, 10));
Tree.Add(rnd.Next(1, 10));
Tree.Add(5);
Tree.Add(rnd.Next(1, 10));
Tree.Add(rnd.Next(1, 10));
Tree.Add(rnd.Next(1, 10));
Tree.Add(rnd.Next(1, 10));
Tree.PrintTree();
Console.WriteLine(new string('-', 40));
Tree.Remove(5);
Tree.PrintTree();
Console.WriteLine(new string('-', 40));
Tree.Add(11);
Tree.PrintTree();
}
}
 6

Рисунок 1 – Пример работы программы 1

 7

4. ВЫВОД

Ознакомился с представлением данных в виде деревьев. Изучил основные

алгоритмы обхода деревьев.