Algorithms

public class Tree{
    private int tree_height;
    private int tree_width;
    private int nodes_count;
    private List<Node> tree_nodes;}

public class Node{
    //private
    private object state;
    private int ordering;
    private int height;
    private int parent;}

public void AddBranch(Tree branch, int node_num)
{
    if (nodes_count >= node_num && node_num > 0)
    {
        int last_el_ordering = nodes_count,
            first_parent_height = tree_nodes[node_num - 1].Height,
            first_parent_ordering = tree_nodes[node_num - 1].Ordering;
        tree_nodes.Add(new Node(branch.Tree_nodes.First().State, last_el_ordering + 1, first_parent_ordering, first_parent_height + 1));
        foreach (Node el in branch.Tree_nodes.Skip(1))
            tree_nodes.Add(new Node(el.State, el.Ordering + last_el_ordering, el.Parent + last_el_ordering, el.Height + first_parent_height));
        tree_nodes = tree_nodes.OrderBy(match => match.Height).ToList();
        int i = 1;
        foreach (Node el in tree_nodes)
        {
            List<Node> temp = tree_nodes.ToList().FindAll(match => match.Parent == el.Ordering).ToList();
            el.Ordering = i++;
            if (temp.Count() > 0)
                foreach (Node el2 in temp)
                    el2.Parent = el.Ordering;
        }
    }
}

Tree testing_tree1 = new Tree(new Node("start"));
List<string> temp = new List<string> { "a", "b", "c" };
foreach(string el in temp)
    testing_tree1.AddBranch(new Tree(new Node(el)),1);
for (int i = 0; i < 3; i++)
   testing_tree1.AddBranch(new Tree(new Node("false")), i+2);
Tree testing_tree2 = new Tree(new Node("d"));
testing_tree2.AddBranch(new Tree(new Node("false")), 1);
testing_tree1.AddBranch(testing_tree2, 1);
testing_tree1.DisplayTree();
Console.Read();

private Tree DecisionTreeLearning(List<string[]> examples, AttributesVector attributes_vector, Tree default_tree)
{
    if (examples.Count() == 0)
        return default_tree;
    if (AllExamplesSameClassification(examples))
        return new Tree(new Node(examples.First()[0]));
    if (attributes_vector.Vector_length == 0)
        return MajorityValue(examples);
    string chosen_attribute = ChooseAttribute(examples, attributes_vector);
    Tree current_tree = new Tree(new Node(chosen_attribute));
    Tree current_majority_value = MajorityValue(examples);
    int chosen_attr_index = attributes_vector.Names.FindIndex(match => match == chosen_attribute);
    int temp2 = 2;
    for (int i = 0; i < attributes_vector.Possible_values[chosen_attr_index] + 1; i++)
    {
        List<string[]> matching_examples = examples.FindAll(match => match[chosen_attr_index] == i.ToString());
        List<string> new_attributes_names = new List<string> { };
        foreach (string el in attributes_vector.Names)
        {
            string temp = string.Copy(el);
            new_attributes_names.Add(temp);
        }
        new_attributes_names.RemoveAt(chosen_attr_index);
        List<int> new_list_of_possible_values = new List<int> { };
        foreach (int el in attributes_vector.Possible_values)
        {
            int temp = el;
            new_list_of_possible_values.Add(temp);
        }
        new_list_of_possible_values.RemoveAt(chosen_attr_index);
        AttributesVector new_attributes_vector = new AttributesVector(new_attributes_names, new_list_of_possible_values);
        Tree subtree = new Tree();
        subtree = DecisionTreeLearning(matching_examples, new_attributes_vector, current_majority_value);
        current_tree.AddBranch(new Tree(new Node(i.ToString())), 1);
        current_tree.AddBranch(subtree, temp2++);
        //current_tree.DisplayTree();
    }
    return current_tree;
}