Breadth First Search - Matrix

So yesterday during class, we discussed how to make a path finding algorithm for a 2d map. I immediately thought of the example of flooding the map with water like I have seen before.

We didn't have to code it in class, we just had to know how one would write the algorithm. Last night I decided that I would try to code it and here is my work:


In my grid I make the starting cell marked with an X and the destination is marked with a D. The final path would be calculated by simply following the cell values in descending order to the final destination.

That's all for now, thanks for reading!

CS 2420 - Assignment 5 - Part 5

So I just turned in my assignment a few minutes ago, and this is probably the hardest assignment yet. Most of the assignment was really simple actually, but the most challenging part was building the Expression Tree in the correct order.

This is because you have to keep the order of operations in mind when building the tree, Once the tree has been built in the correct order, its just a matter of doing a post-order traversal and evaluating as you go up the tree.

I kept thinking about how I should do this, and after talking to one of my friends, we realized that node rotations would be the simplest way to do it. So here is my code:

using System;
using System.Collections.Generic;

namespace Assignment5
{
    public TreeNode<string> root;

        public ExpressionTree(string input)
        {
            root = null;
            ExpressionParser parser = new ExpressionParser(this, input);
        }

        private class ExpressionParser
        {
            private Stack<TreeNode<string>> numberStack, operatorStack;

            public ExpressionParser(ExpressionTree tree, string input)
            {
                numberStack = new Stack<TreeNode<string>>();
                operatorStack = new Stack<TreeNode<string>>();
                string[] expressionArray = new string[input.Length];
                expressionArray = input.Split();

                BuildNodes(tree, expressionArray);
            }

            private void BuildNodes(ExpressionTree tree, string[] expressionArray)
            {
                foreach (string item in expressionArray)
                {
                    double tempNumber;
                    if (double.TryParse(item, out tempNumber))
                    {
                        TreeNode<string> number_node = new TreeNode<string> 

                            { Data = tempNumber.ToString() };
                        numberStack.Push(number_node);
                    }
                    else
                    {
                        TreeNode<string> operator_node = new TreeNode<string> 

                            { Data = item };
                        operatorStack.Push(operator_node);
                    }
                }
                BuildTree(tree);

            }

            private void BuildTree(ExpressionTree tree)
            {
                while (operatorStack.Count != 0)
                {
                    TreeNode<string> tempRoot = operatorStack.Pop();
                    tempRoot.Right = numberStack.Pop();
                    tempRoot.Left = numberStack.Pop();

                    if((tempRoot.Data == "*" || tempRoot.Data == "/") && 
                        (tempRoot.Right.Data == "+" || tempRoot.Right.Data == "-"))
                    {
                        tempRoot = tree.RotateLeft(tempRoot);
                    }
                    numberStack.Push(tempRoot);
                }
                TreeNode<string> subTree = numberStack.Pop();
                tree.root = tree.RotateLeft(subTree);
            }
        }

        private TreeNode<string> RotateLeft(TreeNode<string> currentNode)
        {
            TreeNode<string> tempNode = currentNode;
            currentNode = currentNode.Right;
            tempNode.Right = currentNode.Left;
            currentNode.Left = tempNode;
            return currentNode;
        }

        public void Evaluate(TreeNode<string> node)
        {
            if (node.Left != null)
                Evaluate(node.Left);
            if (node.Right != null)
                Evaluate(node.Right);
            switch (node.Data)
            {
                case "+":
                    double addResult = double.Parse(node.Left.Data) + 

                        double.Parse(node.Right.Data);
                    node.Data = addResult.ToString();
                    node.Left = null;
                    node.Right = null;
                    break;
                case "-":
                    double subResult = double.Parse(node.Left.Data) - 

                        double.Parse(node.Right.Data);
                    node.Data = subResult.ToString();
                    node.Left = null;
                    node.Right = null;
                    break;
                case "*":
                    double multResult = double.Parse(node.Left.Data) * 

                        double.Parse(node.Right.Data);
                    node.Data = multResult.ToString();
                    node.Left = null;
                    node.Right = null;
                    break;
                case "/":
                    double divResult = double.Parse(node.Left.Data) / 

                        double.Parse(node.Right.Data);
                    node.Data = divResult.ToString();
                    node.Left = null;
                    node.Right = null;
                    break;
                case "^":
                    double expResult = Math.Pow(double.Parse(node.Left.Data), 

                        double.Parse(node.Right.Data));
                    node.Data = expResult.ToString();
                    node.Left = null;
                    node.Right = null;
                    break;
            }
        }

        public string TraversePre(MyList<string> list, TreeNode<string> node)
        {
            list.Add(node.Data);
            if (node.Left != null)
                TraversePre(list, node.Left);
            if (node.Right != null)
                TraversePre(list, node.Right);
            return string.Join(", ", list);
        }

        public string TraverseIn(MyList<string> list, TreeNode<string> node)
        {
            if (node.Left != null)
                TraverseIn(list, node.Left);
            list.Add(node.Data);
            if (node.Right != null)
                TraverseIn(list, node.Right);
            return string.Join(", ", list);
        }

        public string TraversePost(MyList<string> list, TreeNode<string> node)
        {
            if (node.Left != null)
                TraversePost(list, node.Left);
            if (node.Right != null)
                TraversePost(list, node.Right);
            list.Add(node.Data);
            return string.Join(", ", list);
        }
    }
}

I was not able to make my Binary Search Tree self balancing. I know what I need to do, but I never had time to actually implement the code. I will try to finish writing the code and post it here when I'm done with my AVL tree.

Anyways, that's all for now. Thanks for reading!

CS 2420 - Assignment 5 - Part 4

So I've been working more on my Expression Tree and after talking to another student, I realized that I could restructure my files.The Expression Tree works with a total of 3 class files: the Node, the expression parser, and the tree class itself.

At first I had created each class in separate class files, but it was kind of weird how I was parsing the input and how I was building the tree. So I decided to move my Expression Parser class to be nested within my Expression Tree class. This would allow me to do all the parsing and building of the tree within one class file instead of two where it can get messy and confusing.

Here is my new code, thanks for reading:

using System;
using System.Collections.Generic;

namespace Assignment5
{
    class ExpressionTree
    {
        public TreeNode<string> root;
        private int node_count;

        public ExpressionTree(string input)
        {
            root = null;
            ExpressionParser parser = new ExpressionParser(this, input);
        }

        private class ExpressionParser
        {
            private Stack<TreeNode<string>> numberStack, operatorStack;

            public ExpressionParser(ExpressionTree tree, string input)
            {
                numberStack = new Stack<TreeNode<string>>();
                operatorStack = new Stack<TreeNode<string>>();
                Console.WriteLine(input.Length);
                string[] expressionArray = new string[input.Length];
                expressionArray = input.Split();

                BuildNodes(tree, expressionArray);
            }

            private void BuildNodes(ExpressionTree tree, string[] expressionArray)
            {
                foreach (string item in expressionArray)
                {
                    int tempInt;
                    if (Int32.TryParse(item, out tempInt))
                    {
                        TreeNode<string> number_node = new TreeNode<string> { Data = tempInt.ToString() };
                        numberStack.Push(number_node);
                    }
                    else

                    {
                        TreeNode<string> operator_node = new TreeNode<string> { Data = item };
                        operatorStack.Push(operator_node);
                    }
                }
                BuildTree(tree);
            }

            private void BuildTree(ExpressionTree tree)
            {
                tree.node_count = numberStack.Count + operatorStack.Count;

                while (operatorStack.Count != 0)
                {
                    TreeNode<string> tempRoot = operatorStack.Pop();
                    tempRoot.Right = numberStack.Pop();
                    tempRoot.Left = numberStack.Pop();
                    numberStack.Push(tempRoot);
                }

                tree.root = numberStack.Pop();
            }
        }

        public int NodeCount
        {
            get
            {
                return node_count;
            }
        }

        // TODO Finish Evaluate
        public void Evaluate(MyList<string> list, TreeNode<string> node)
        {
            if (node.Left != null)
                Evaluate(list, node.Left);
            if (node.Right != null)
                Evaluate(list, node.Right);
            throw new NotImplementedException();
        }

        public string TraversePre(MyList<string> list, TreeNode<string> node)
        {
            list.Add(node.Data);
            if (node.Left != null)
                TraversePre(list, node.Left);
            if (node.Right != null)
                TraversePre(list, node.Right);
            return string.Join(", ", list);
        }

        public string TraverseIn(MyList<string> list, TreeNode<string> node)
        {
            if (node.Left != null)
                TraverseIn(list, node.Left);
            list.Add(node.Data);
            if (node.Right != null)
                TraverseIn(list, node.Right);
            return string.Join(", ", list);
        }

        public string TraversePost(MyList<string> list, TreeNode<string> node)
        {
            if (node.Left != null)
                TraversePost(list, node.Left);
            if (node.Right != null)
                TraversePost(list, node.Right);
            list.Add(node.Data);
            return string.Join(", ", list);
        }
    }
}

CS 2420 - Assignment 5 - Part 3

I have not been able to make my Binary Search Tree self balancing. I know how the nodes should behave on paper, but I haven't been able to do it in code.

Yesterday after class, I figured out how to finish my Expression Tree and the Parser that takes the user's input.

Expression Tree:

using System;

namespace Assignment5
{
    class ExpressionTree
    {
        public TreeNode<string> root;
        public int node_count;

        public ExpressionTree()
        {
            root = null;
        }

        // TODO Finish Evaluate
        public void Evaluate()
        {

        }

        public string TraversePre(MyList<string> list, TreeNode<string> node)
        {
            list.Add(node.data);
            if (node.left != null)
                TraversePre(list, node.left);
            if (node.right != null)
                TraversePre(list, node.right);
            return string.Join(", ", list);
        }

        public string TraverseIn(MyList<string> list, TreeNode<string> node)
        {
            if (node.left != null)
                TraverseIn(list, node.left);
            list.Add(node.data);
            if (node.right != null)
                TraverseIn(list, node.right);
            return string.Join(", ", list);
        }

        public string TraversePost(MyList<string> list, TreeNode<string> node)
        {
            if (node.left != null)
                TraversePost(list, node.left);
            if (node.right != null)
                TraversePost(list, node.right);
            list.Add(node.data);
            return string.Join(", ", list);
        }
    }
}

Parser:

using System;
using System.Collections;
using System.Collections.Generic;

namespace Assignment5
{
    class ExpressionParser
    {
        private Stack<TreeNode<string>> numberStack, operatorStack;

        public ExpressionParser(ExpressionTree ETree, string input)
        {
            numberStack = new Stack<TreeNode<string>>();
            operatorStack = new Stack<TreeNode<string>>();

            ToArray(ETree, input);
        }

        public void ToArray(ExpressionTree ETree, string input)
        {
            string[] expressions = new string[input.Length];
            expressions = input.Split();

            BuildNodes(expressions, ETree);
        }

        private void BuildNodes(string[] expressions, ExpressionTree ETree)
        {
            foreach (string item in expressions)
            {
                int tempInt;
                if (Int32.TryParse(item, out tempInt))
                {
                    TreeNode<string> number_node = new TreeNode<string> { data = tempInt.ToString() };
                    numberStack.Push(number_node);
                }
                else                {
                    TreeNode<string> operator_node = new TreeNode<string> { data = item };
                    operatorStack.Push(operator_node);
                }
            }
            BuildTree(ETree);
        }

        private void BuildTree(ExpressionTree ETree)
        {
            ETree.node_count = numberStack.Count + operatorStack.Count;

            while (operatorStack.Count != 0)
            {
                TreeNode<string> tempRoot = operatorStack.Pop();
                tempRoot.right = numberStack.Pop();
                tempRoot.left = numberStack.Pop();
                numberStack.Push(tempRoot);
            }

            ETree.root = numberStack.Pop();
        }
    }
}

I will continue to work on this assignment. Thanks for reading!

CS 2420 - Assignment 5 - Part 2

So I've been working on my Binary Search tree a bit more, and I have made some changes since last time. For example, in the assignment the traverse functions need to return a string of the numbers instead of being void.

Here is what I have now:

using System;

class BinarySearchTree
{
    public TreeNode root;
    private int node_count;

    public BinarySearchTree()
    {
        root = null;
        node_count = 0;
    }

    public void Add(int item)
    {
        TreeNode new_node = new TreeNode(item);

        if (root == null)
            root = new_node;
        else
        {
            TreeNode crawler = root;

            while (crawler != null)
            {
                new_node.parent = crawler;
                if (item >= crawler.data)
                    crawler = crawler.right;
                else
                    crawler = crawler.left;
            }

            if (item >= new_node.parent.data)
                new_node.parent.right = new_node;
            else
                new_node.parent.left = new_node;
        }
        node_count++;
        CalculateHeight(root);
        Console.WriteLine("");
    }

    public TreeNode Contains(int item)
    {
        TreeNode crawler = root;

        while (crawler != null)
        {
            if (item == crawler.data)
                return crawler;
            else if (item >= crawler.data)
                crawler = crawler.right;
            else
                crawler = crawler.left;
        }
        return null;
    }

    // TODO Finish Remove function
    public void Remove(TreeNode node)
    {
        if (node == null)
            Console.WriteLine("\nCould not remove the node you were looking for!\n");
        else
        {
            //Work needed
        }
    }

    public void Clear()
    {
        root = null;
        node_count = 0;
    }

    public int NodeCount
    {
        get
        {
            return node_count;
        }
    }

    private void CalculateHeight(TreeNode node)
    {
        if (node.left != null)
            CalculateHeight(node.left);
        if (node.right != null)
            CalculateHeight(node.right);

        if (node.left != null && node.right != null)
            node.height = Math.Max(node.left.height, node.right.height) + 1;

        else if (node.left != null && node.right == null)
            node.height = node.left.height + 1;

        else if (node.left == null && node.right != null)
            node.height = node.right.height + 1;

        else if (node.left == null && node.right == null)
            node.height = 1;
        Console.WriteLine("Node value: {0} Node Height: {1}", node.data, node.height);
        CheckBalance(node);
    }

    private void CheckBalance(TreeNode node)
    {
        if (node.left == null && node.right == null)
            return;

        else if (node.left != null && node.right == null)
            if (node.left.height > 1)
                Rotate(node);

            else if (node.left == null && node.right != null)
                if (node.right.height > 1)
                    Rotate(node);

                else if (node.left != null && node.right != null)
                {
                    if (node.left.height > node.right.height + 1)
                        Rotate(node.left);
                    else if (node.right.height > node.left.height + 1)
                        Rotate(node.right);
                }
    }

    // TODO Finish Rotate function
    private void Rotate(TreeNode node)
    {
        //Work needed
    }

    public string TraversePre(MyList list, TreeNode node)
    {
        list.Add(node.data);
        if (node.left != null)
            TraversePre(list, node.left);
        if (node.right != null)
            TraversePre(list, node.right);
        return string.Join(", ", list);
    }

    public string TraverseIn(MyList list, TreeNode node)
    {
        if (node.left != null)
            TraverseIn(list, node.left);
        list.Add(node.data);
        if (node.right != null)
            TraverseIn(list, node.right);
        return string.Join(", ", list);
    }

    public string TraversePost(MyList list, TreeNode node)
    {
        if (node.left != null)
            TraversePost(list, node.left);
        if (node.right != null)
            TraversePost(list, node.right);
        list.Add(node.data);
        return string.Join(", ", list);
    }
}

There has been a few changes to the rest of the code as well. I have been trying to figure out how to make my tree self balancing. And while I have been able to calculate the depth/height of each node, I am running into issues on how I should rotate the nodes. I am also working on removing nodes, but I haven't made much progress in that department either.

Anyways, that's all for now. Thanks for reading!

CS 2420 - Assignment 5 - Part 1

So even though there is no assignment this week, I asked the professor to post the next assignment early. It turns out that writing my Linked List class a few days ago was a good call, because the next assignment will be Trees!

The assignment will have us built two trees: a Binary Search Tree and a Binary Expression Tree.

I have started working on both, but I have been mainly focusing on the BS Tree since to me its the easiest of the two. I am actually almost done with the BS Tree, here is what I have:

class BinarySearchTree
{
    public TreeNode root;
    private int node_count;

    public BinarySearchTree()
    {
        root = null;
        node_count = 0;
    }

    public void Add(int item)
    {
        TreeNode new_node = new TreeNode(item);
        if (root == null)
            root = new_node;
        else
        {
            TreeNode crawler = root;

            while (crawler != null)
            {
                new_node.parent = crawler;
                if (item >= crawler.data)
                    crawler = crawler.right;
                else
                    crawler = crawler.left;
            }

            if (item >= new_node.parent.data)
                new_node.parent.right = new_node;
            else
                new_node.parent.left = new_node;
        }
        node_count++;
    }

    public bool Contains(int item)
    {
        TreeNode crawler = root;
        while (crawler != null)
        {
            if (item == crawler.data)
                return true;
            else if (item >= crawler.data)
                crawler = crawler.right;
            else
                crawler = crawler.left;
        }
        return false;
    }

    public void Clear()
    {
        root = null;
        node_count = 0;
    }

    public int NodeCount
    {
        get
        {
            return node_count;
        }
    }

    public void TraversePre(MyList list, TreeNode node)
    {
        list.Add(node.data);
        if (node.left != null)
            TraversePre(list, node.left);
        if (node.right != null)
            TraversePre(list, node.right);
    }

    public void TraverseIn(MyList list, TreeNode node)
    {
        if (node.left != null)
            TraverseIn(list, node.left);
        list.Add(node.data);
        if (node.right != null)
            TraverseIn(list, node.right);
    }

    public void TraversePost(MyList list, TreeNode node)
    {
        if (node.left != null)
            TraversePost(list, node.left);
        if (node.right != null)
            TraversePost(list, node.right);
        list.Add(node.data);
    }
}

My Binary Search Tree takes advantage of the List class I wrote for assignment 4 and of a Node class that has only three properties: Left, Right, & Parent. That's all for now, thanks for reading!

Linked List class in C#

So today I was bored at work, and decided to write a Linked List in C# to get more practice with the language and get more familiar with Visual Studio.

I also decided to make my own enumerator for the linked list. Here is what I wrote: