melloc1801 · melloc1801 · May 12, 2023
diff --git a/DataStructure.Test/BFSandDFS.cs b/DataStructure.Test/BFSandDFS.cs
@@ -0,0 +1,39 @@
+using NUnit.Framework;
+
+namespace DataStructure.Test;
+
+[TestFixture]
+public class BFSandDFS
+{
+    [Test]
+    public void Tmp()
+    {
+        var tree = new TreeNode(2);
+
+        tree.Add(4);
+        tree.Add(3);
+
+            tree._children[4].Add(10);
+            tree._children[4].Add(15);
+
+                tree._children[4]._children[15].Add(11);
+                tree._children[4]._children[15].Add(9);
+
+                    tree._children[4]._children[15]._children[11].Add(2);
+                    tree._children[4]._children[15]._children[11].Add(3);
+
+            tree._children[3].Add(2);
+            tree._children[3].Add(6);
+                tree._children[3]._children[6].Add(4);
+                tree._children[3]._children[6].Add(6);
+
+                    tree._children[3]._children[6]._children[4].Add(1);
+                    tree._children[3]._children[6]._children[4].Add(2);
+                    tree._children[3]._children[6]._children[4].Add(3);
+                    tree._children[3]._children[6]._children[6].Add(1);
+
+
+
+        tree.BreadthFirstSearchLog();
+    }
+}
diff --git a/DataStructure.Test/Edge.cs b/DataStructure.Test/Edge.cs
@@ -0,0 +1,17 @@
+namespace DataStructure.Test;
+
+public class Edge
+{
+    public Vertex From { get; set; }
+    public Vertex To { get; set; }
+    public bool Oriented { get; set; }
+    public int Weight { get; set; }
+
+    public Edge(Vertex from, Vertex to, bool oriented = false, int weight = 1)
+    {
+        From = from;
+        To = to;
+        Oriented = oriented;
+        Weight = weight;
+    }
+}
diff --git a/DataStructure.Test/Graph.cs b/DataStructure.Test/Graph.cs
@@ -0,0 +1,253 @@
+using NUnit.Framework;
+
+namespace DataStructure.Test;
+
+public class Graph
+{
+    public List<Vertex> Vertexes { get; }
+    public List<Edge> Edges { get; }
+    public int VertexesCount => Vertexes.Count;
+    public int EdgesCount => Edges.Count;
+
+    public Graph()
+    {
+        Vertexes = new List<Vertex>();
+        Edges = new List<Edge>();
+    }
+
+    public void AddVertex(Vertex vertex)
+    {
+        Vertexes.Add(vertex);
+    }
+
+    public void AddEdge(Vertex from, Vertex to)
+    {
+        var edge = new Edge(from, to);
+        Edges.Add(edge);
+    }
+
+    public void BreadthFirstSearchLog()
+    {
+        var visited = new HashSet<Vertex>();
+
+        var startVertex = Vertexes.First(vertex => vertex.Value == 1);
+
+        var queue = new Queue<Vertex>();
+        queue.Enqueue(startVertex);
+
+        while (queue.Count > 0)
+        {
+            var newQueueValues = new List<Vertex>();
+
+            foreach (var item in queue)
+            {
+                if (visited.Contains(item))
+                {
+                    continue; 
+                }
+
+                Console.Write($"_{item}_");
+
+                Edges.ForEach(edge =>
+                    {
+                        if (!visited.Contains(edge.From) && edge.From == item)
+                        {
+                            newQueueValues.Add(edge.To);
+                        } else if (!visited.Contains(edge.To) && edge.To == item)
+                        {
+                            newQueueValues.Add(edge.From);
+                        }
+                    });
+
+                visited.Add(item);
+            }
+
+            Console.WriteLine();
+
+            queue.Clear();
+
+            foreach (var vertex in newQueueValues)
+            {
+                queue.Enqueue(vertex);
+            }
+        }
+    }
+
+    public void RepeatBFS()
+    {
+        var matrix = GetMatrix();
+
+        var src = Vertexes.First(vertex => vertex.Value == 1);
+        var queue = new Queue<Vertex>();
+        var visited = new HashSet<Vertex>();
+
+        queue.Enqueue(src);
+        visited.Add(src);
+
+        while (queue.Count > 0)
+        {
+            var currentVertex = queue.Dequeue();
+            Console.Write(currentVertex.Value);
+            for (int i = 0; i < VertexesCount; i++)
+            {
+                if (matrix[currentVertex.Value - 1, i] == 1)
+                {
+                    var childVertex = Vertexes.First(v => v.Value == i + 1); 
+                    if (!visited.Contains(childVertex))
+                    {
+                        queue.Enqueue(childVertex);
+                        visited.Add(childVertex);
+                    }
+                }
+            }
+
+        }
+    }
+
+    public void BreadFirstSearch()
+    {
+        var src = Vertexes.First(vertex => vertex.Value == 1);
+        var matrix = GetMatrix();
+
+        var queue = new Queue<Vertex>();
+        var visited = new HashSet<Vertex>();
+
+        queue.Enqueue(src);
+        visited.Add(src);
+
+        while (queue.Count > 0)
+        {
+            src = queue.Dequeue();
+            Console.WriteLine(src);
+            for (int i = 0; i < VertexesCount; i++)
+            {
+                var matValue = matrix[src.Value - 1, i];
+                var vertex = Vertexes.First(v => v.Value == i + 1);
+                if (matValue == 1 && !visited.Contains(vertex))
+                {
+                    queue.Enqueue(vertex);
+                    visited.Add(vertex);
+                }
+            }
+        }
+    }
+
+    public void DepthFirstSearchLog()
+    {
+        var matrix = GetMatrix();
+        var visited = new HashSet<Vertex>();
+
+        var stack = new Stack<Vertex>();
+        var startVertex = Vertexes.First(vertex => vertex.Value == 1);
+        stack.Push(startVertex);
+
+        while (stack.Count > 0)
+        {
+            var currentVertex = stack.Pop();
+            Console.WriteLine(currentVertex.Value);
+            for (int i = 0; i < VertexesCount; i++)
+            {
+                if (matrix[currentVertex.Value - 1, i] == 1)
+                {
+                    var vertex = Vertexes.First(v => v.Value - 1 == i);
+                    if (!visited.Contains(vertex))
+                    {
+                        stack.Push(vertex);
+                        visited.Add(vertex);
+                    }
+                }
+            }
+
+            // 1. Find all children
+            // 2. Add children to stack
+            // 3. Go to 1st Step
+            // 4. If there are no children => log current node
+        }
+
+    }
+
+    public int[,] GetMatrix()
+    {
+        var matrix = new int[VertexesCount, VertexesCount];
+
+        foreach (var edge in Edges)
+        {
+            var from = edge.From.Value - 1;
+            var to = edge.To.Value - 1;
+
+            matrix[from, to] = 1;
+        }
+
+        return matrix;
+    }
+
+    public void LogMatrix()
+    {
+        var matrix = GetMatrix();
+
+        Console.Write($"№ |");
+        for (int i = 0; i < VertexesCount; i++)
+        {
+            Console.Write($"_{i + 1}_");
+        }
+        Console.WriteLine();
+
+        for (int i = 0; i < VertexesCount; i++)
+        {
+            Console.Write($"{i + 1} |");
+            for (int j = 0; j < VertexesCount; j++)
+            {
+                Console.Write($"_{matrix[i, j]}_");
+            }
+            Console.WriteLine();
+        }
+    }
+}
+
+[TestFixture]
+public class Test
+{
+    [Test]
+    public void Tmp()
+    {
+        var graph = new Graph();
+
+        var v1 = new Vertex(1);
+        var v2 = new Vertex(2);
+        var v3 = new Vertex(3);
+        var v4 = new Vertex(4);
+        var v5 = new Vertex(5);
+        var v6 = new Vertex(6);
+        var v7 = new Vertex(7);
+        var v8 = new Vertex(8);
+        var v9 = new Vertex(9);
+
+        graph.AddVertex(v1);
+        graph.AddVertex(v2);
+        graph.AddVertex(v3);
+        graph.AddVertex(v4);
+        graph.AddVertex(v5);
+        graph.AddVertex(v6);
+        graph.AddVertex(v7);
+        graph.AddVertex(v8);
+        graph.AddVertex(v9);
+
+        graph.AddEdge(v1, v2);
+        graph.AddEdge(v1, v7);
+        graph.AddEdge(v2, v3);
+        graph.AddEdge(v2, v4);
+        graph.AddEdge(v2, v5);
+        graph.AddEdge(v3, v6);
+        graph.AddEdge(v7, v8);
+        graph.AddEdge(v8, v9);
+
+        // graph.BreadthFirstSearchLog();
+        // Console.WriteLine("========");
+        // graph.BreadFirstSearch();
+        // Console.WriteLine("========");
+        // graph.RepeatBFS();
+
+        graph.DepthFirstSearchLog();
+        // graph.LogMatrix();
+    }
+}
diff --git a/DataStructure.Test/TreeNode.cs b/DataStructure.Test/TreeNode.cs
@@ -0,0 +1,55 @@
+namespace DataStructure.Test;
+
+class TreeNode
+{
+    public readonly Dictionary<int, TreeNode> _children = new ();
+
+    public readonly int Id;
+
+    public TreeNode(int id)
+    {
+        Id = id;
+    }
+
+    public void Add(int id)
+    {
+        _children[id] = new TreeNode(id);
+    }
+
+    public void BreadthFirstSearchLog()
+    {
+        var queue = new Queue<TreeNode>();
+        queue.Enqueue(this);
+
+        while (queue.Count > 0)
+        {
+            // Gets and removes all nodes from queue (Current Level)
+            var currentLevelNodes = new List<TreeNode>();
+            while (queue.Count > 0)
+            {
+                currentLevelNodes.Add(queue.Dequeue());
+            }
+
+            // Log all nodes from current level
+            foreach (var node in currentLevelNodes)
+            {
+                Console.Write($"_{node.Id}_");
+            }
+            Console.WriteLine();
+
+            // Add to queue current level children nodes
+            foreach (var currentNode in currentLevelNodes)
+            {
+                foreach (var node in currentNode._children.Values)
+                {
+                    queue.Enqueue(node);
+                }
+            }
+        }
+    }
+
+    public void DepthFirstSearchLog()
+    {
+
+    }
+}
diff --git a/DataStructure.Test/Vertex.cs b/DataStructure.Test/Vertex.cs
@@ -0,0 +1,17 @@
+namespace DataStructure.Test; 
+
+public class Vertex
+{
+    public int Value { get; set; }
+
+    public Vertex(int value)
+    {
+        Value = value;
+    }
+
+    public override string ToString()
+    {
+        return Value.ToString();
+    }
+
+}
diff --git a/algorithms-data-structures.sln.DotSettings.user b/algorithms-data-structures.sln.DotSettings.user
@@ -0,0 +1,7 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/Environment/UnitTesting/UnitTestSessionStore/Sessions/=6525bdb9_002D6858_002D41b6_002D86fb_002Dbc039ec2c7ea/@EntryIndexedValue">&lt;SessionState ContinuousTestingMode="0" IsActive="True" Name="StrTest" xmlns="urn:schemas-jetbrains-com:jetbrains-ut-session"&gt;
+  &lt;TestAncestor&gt;
+    &lt;TestId&gt;NUnit3x::3C5BBBF3-2F37-4169-95B8-C6659023E43D::net7.0::DataStructure.Test.BFSandDFS.Tmp&lt;/TestId&gt;
+    &lt;TestId&gt;NUnit3x::3C5BBBF3-2F37-4169-95B8-C6659023E43D::net7.0::DataStructure.Test.Test.Tmp&lt;/TestId&gt;
+  &lt;/TestAncestor&gt;
+&lt;/SessionState&gt;</s:String></wpf:ResourceDictionary>