Beispiel #1
0
 public SLNode(int val)
 {
     Value = val;
     Next  = null;
     Child = null;
     Flag  = false;
 }
Beispiel #2
0
        public SLL ResetFlags()
        {
            SLNode runner = Head;

            while (runner != null)
            {
                runner.Flag = false;
            }
            Console.Write("Flags Reset...");
            return(this);
        }
Beispiel #3
0
        // SList: Break Loop
        // Even better than finding where the loops start would be to just fix them. You will be given a potentially loopy list; determine whether there is a loop, and if so, break it. Retain all nodes, in original order.

        public SLL BreakLoop()
        {
            SLNode runner = Head;

            while (runner != null)
            {
                if (runner.Next.Flag)
                {
                    runner.Next = null;
                }
                runner.Flag = true;
                runner      = runner.Next;
            }
            Console.WriteLine("Loop is broken");
            return(this);
        }
Beispiel #4
0
        // You can refactor this without using end flag - have to access the "Size" attribute
        // public SLL UnflattenChildren2()
        // {
        //   SLNode runner = Head;
        //   while(runner.Next != null)
        //   {
        //     if(runner.Child != null)
        //     {
        //       runner2.size =
        //       for ()
        //     }
        //     runner = runner.Next;
        //   }
        //   return this;
        // }

        public SLL MakeLoop(int val)
        {
            var    runner = Head;
            SLNode temp   = null;

            while (runner.Next != null)
            {
                if (runner.Value == val)
                {
                    temp = runner;
                }
                runner = runner.Next;
            }
            runner.Next = temp;
            return(this);
        }
Beispiel #5
0
        // SList: Has Loop
        // Ben sends linked lists to Emma, but she doesn’t quite trust him. Is he trying to make her code spin infinitely? Given a linked list, determine whether it has a loop, and return a boolean accordingly.

        public bool HasLoop()
        {
            SLNode runner = Head;

            while (runner != null)
            {
                if (runner.Flag)
                {
                    Console.WriteLine("List has Loop!");
                    return(true);
                }
                runner.Flag = true;
                runner      = runner.Next;
            }
            Console.WriteLine("List does not have Loop");
            return(false);
        }
Beispiel #6
0
        public SLL AppendNode(SLNode node)
        {
            var runner = Head;

            if (Head == null)
            {
                Head = node;
                Size++;
                return(this);
            }
            while (runner.Next != null)
            {
                runner = runner.Next;
            }
            runner.Next = node;
            Size++;
            return(this);
        }
Beispiel #7
0
        public SLL Append(int val)
        {
            var runner = Head;

            if (Head == null)
            {
                Head = new SLNode(val);
                Size++;
                return(this);
            }
            while (runner.Next != null)
            {
                runner = runner.Next;
            }
            runner.Next = new SLNode(val);
            Size++;
            return(this);
        }
Beispiel #8
0
        // SList: Reverse
        // Reverse the node sequence. Given an SList object, the .head property should point to the previously-last node, and the rest of the nodes should follow similarly from back to front.

        public SLL Reverse()
        {
            if (Head == null)
            {
                return(this);
            }
            SLNode runner = Head;
            SLNode before = null;
            SLNode after  = null;

            while (runner != null)
            {
                after       = runner.Next;
                runner.Next = before;
                before      = runner;
                runner      = after;
            }
            Head = before;
            return(this);
        }
Beispiel #9
0
// SList: Unflatten Children
//         Take the output from your “flatten child lists” function (a linear linked list containing nodes
// with .child pointers), and restore it to its original state. Do you need to change your flatten function to enable this?

        public SLL UnflattenChildren()
        {
            SLNode runner = Head;

            while (runner.Next != null)
            {
                if (runner.Child != null)
                {
                    SLNode runner2 = runner.Child.Head;
                    while (runner2.Flag != true)
                    {
                        runner2 = runner2.Next;
                    }
                    runner.Next  = runner2.Next;
                    runner2.Next = null;
                }
                runner = runner.Next;
            }
            return(this);
        }
Beispiel #10
0
 public SLL()
 {
     Head = null;
     Size = 0;
 }