public void AddAfter(string existingValue, string value)
        {
            if (ElementAt(-1) == existingValue)
            {
                AddLast(value);
            }
            else
            {
                SinglyLinkedListNode prevNode = firstNode;
                bool found = false;
                while (!prevNode.IsLast())
                {
                    if (prevNode.Value == existingValue)
                    {
                        SinglyLinkedListNode newNode = new SinglyLinkedListNode(value);
                        SinglyLinkedListNode oldNext = prevNode.Next;
                        newNode.Next  = oldNext;
                        prevNode.Next = newNode;

                        found = true;
                        count++;
                        break;
                    }
                    prevNode = prevNode.Next;
                }

                if (!found)
                {
                    throw new ArgumentException();
                }
            }
        }
        public override string ToString()
        {
            string               leftBr      = "{";
            string               rightBr     = "}";
            string               comma       = ",";
            string               space       = " ";
            string               quote       = "\"";
            StringBuilder        newList     = new StringBuilder(leftBr);
            SinglyLinkedListNode currentNode = firstNode;

            while (currentNode != null)
            {
                newList.Append(space);
                newList.Append(quote);
                newList.Append(currentNode.Value);
                newList.Append(quote);
                if (currentNode.IsLast())
                {
                    break;
                }
                else
                {
                    newList.Append(comma);
                }
                currentNode = currentNode.Next;
            }
            newList.Append(space).Append(rightBr);
            return(newList.ToString());
        }
        public string[] ToArray()
        {
            LinkedList <string>  sentence    = new LinkedList <string>();
            SinglyLinkedListNode currentNode = firstNode;

            if (this.First() == null)
            {
                return(sentence.ToArray());
            }
            else if (firstNode.IsLast())
            {
                sentence.AddFirst(firstNode.ToString());
                return(sentence.ToArray());
            }
            else
            {
                while (currentNode != null)
                {
                    sentence.AddLast(currentNode.ToString());
                    if (currentNode.IsLast())
                    {
                        break;
                    }
                    currentNode = currentNode.Next;
                }
                return(sentence.ToArray());
            }
        }
        private SinglyLinkedListNode NodeAt(int index)
        {
            if (firstNode != null && index >= 0)
            {
                SinglyLinkedListNode node = firstNode;
                for (int i = 0; i <= index; i++)
                {
                    if (index == i)
                    {
                        break;
                    }
                    if (node.IsLast())
                    {
                        throw new ArgumentOutOfRangeException();
                    }
                    node = node.Next;
                }

                return(node);
            }
            else if (index < 0)
            {
                return(this.NodeAt(Count() + index)); //Positive index/offset
            }
            else
            {
                throw new ArgumentOutOfRangeException();
            }
        }
Example #5
0
 public void AddAfter(string existingValue, string value)
 {
     if (ElementAt(-1) == existingValue)
     {
         AddLast(value);
     }
     else
     {
         SinglyLinkedListNode current = firstNode;
         bool found = false;
         while (!current.IsLast())
         {
             if (current.Value == existingValue)
             {
                 SinglyLinkedListNode new_node = new SinglyLinkedListNode(value);
                 SinglyLinkedListNode old_next = current.Next;
                 new_node.Next = old_next;
                 current.Next  = new_node;
                 found         = true;
                 break;
             }
             current = current.Next;
         }
         if (!found)
         {
             throw new ArgumentException();
         }
     }
 }
        public int IndexOf(string value)
        {
            SinglyLinkedListNode Current_node = first;
            int  position = 0;
            bool found    = false;

            if (first.Value == null)
            {
                position = -1;
            }
            else
            {
                while (!Current_node.IsLast())
                {
                    if (value == Current_node.Value)
                    {
                        found = true;
                        break;
                    }
                    Current_node = Current_node.Next;
                    position++;
                }
                if (!found)
                {
                    position = -1;
                }
            }
            return(position);
        }
        public int IndexOf(string value)
        {
            SinglyLinkedListNode node = first;

            if (node.Value == null)
            {
                return(-1);
            }
            int count = 0;

            while (!node.IsLast())
            {
                if (node.Value == value)
                {
                    return(count);
                }
                node = node.Next;
                count++;
            }
            if (node.Value == value)
            {
                return(count);
            }
            else
            {
                return(-1);
            }
        }
Example #8
0
 public SinglyLinkedListNode NodeAt(int index)
 {
     if (index < 0)
     {
         SinglyLinkedListNode currentNode = firstNode;
         int count = 1;
         while (!currentNode.IsLast())
         {
             count++;
             currentNode = currentNode.Next;
         }
         return(NodeAt(count + index));
     }
     if (index > this.size)
     {
         throw new ArgumentOutOfRangeException();
     }
     if (this.firstNode == null)
     {
         throw new ArgumentOutOfRangeException();
     }
     else
     {
         SinglyLinkedListNode currentNode = firstNode;
         for (int j = 0; j < index; j++)
         {
             currentNode = currentNode.Next;
         }
         return(currentNode);
     }
 }
 public void NodeLastWhenLast()
 {
     SinglyLinkedListNode node1 = new SinglyLinkedListNode("foo");
     SinglyLinkedListNode node2 = new SinglyLinkedListNode("bar");
     node1.Next = node2;
     Assert.IsFalse(node1.IsLast());
 }
Example #10
0
 public string ElementAt(int index)
 {
     if (firstNode != null && index >= 0)
     {
         SinglyLinkedListNode node = firstNode;
         for (int i = 0; i <= index; i++)
         {
             if (index == i)
             {
                 break;
             }
             if (node.Next == null)
             {
                 throw new ArgumentOutOfRangeException();
             }
             node = node.Next;
         }
         return(node.Value);
     }
     else if (index < 0)
     {
         SinglyLinkedListNode node = firstNode;
         int length = 1;
         while (!node.IsLast())
         {
             length++;
             node = node.Next;
         }
         return(this.ElementAt(length + index));
     }
     else
     {
         throw new ArgumentOutOfRangeException();
     }
 }
Example #11
0
        public string[] ToArray()
        {
            SinglyLinkedListNode node = firstNode;

            if (node != null)
            {
                int length = 1;
                while (!node.IsLast())
                {
                    length++;
                    node = node.Next;
                }
                string[] answer = new string[length];

                for (int i = 0; i < length; i++)
                {
                    answer[i] = ElementAt(i);
                }
                return(answer);
            }
            else
            {
                return(new string[] { });
            }
        }
Example #12
0
        public override string ToString()
        {
            string               left         = "{";
            string               right        = "}";
            string               space        = " ";
            string               comma        = ",";
            string               quote        = "\"";
            StringBuilder        s            = new StringBuilder(left);
            SinglyLinkedListNode current_node = firstNode;

            while (current_node != null)
            {
                s.Append(space);
                s.Append(quote);
                s.Append(current_node.Value);
                s.Append(quote);
                if (current_node.IsLast())
                {
                    break;
                }
                else
                {
                    s.Append(comma);
                }
                current_node = current_node.Next;
            }
            s.Append(space + right);
            return(s.ToString());
        }
        public bool IsSorted()
        {
            //throw new NotImplementedException();
            SinglyLinkedListNode node = first;

            if (node == null || node.Value == null || node.IsLast())
            {
                return(true);
            }
            else
            {
                SinglyLinkedListNode left  = node;
                SinglyLinkedListNode right = node.Next;
                while (right != null)
                {
                    //if(node.CompareTo(node.Next) >= 0)
                    //{
                    //    return false;
                    //}
                    //node = node.Next;
                    if (left > right)
                    {
                        return(false);
                    }
                    left  = right;
                    right = left.Next;
                }
                return(true);
            }
        }
Example #14
0
        private SinglyLinkedListNode LastNode()
        {
            SinglyLinkedListNode currentNode = firstNode;

            while (!currentNode.IsLast())
            {
                currentNode = currentNode.Next;
            }
            return(currentNode);
        }
Example #15
0
        public override string ToString()
        {
            SinglyLinkedListNode currentNode = this.firstNode;
            string output = "{ ";

            if (currentNode != null)
            {
                while (!currentNode.IsLast())
                {
                    output     += "\"" + currentNode.Value + "\", ";
                    currentNode = currentNode.Next;
                }

                if (currentNode.IsLast())
                {
                    output     += "\"" + currentNode.Value + "\" ";
                    currentNode = currentNode.Next;
                }
            }
            return(output + "}");
        }
        public void AddLast(string value)
        {
            SinglyLinkedListNode node = first;

            if (first.Value == null)
            {
                first = new SinglyLinkedListNode(value);
            }
            while (!node.IsLast())
            {
                node = node.Next;
            }
            node.Next = new SinglyLinkedListNode(value);
        }
Example #17
0
        public override string ToString()
        {
            string               left_br      = "{";
            string               right_br     = "}";
            string               space        = " ";
            string               comma        = ",";
            string               quote        = "\"";
            StringBuilder        s            = new StringBuilder(left_br);
            SinglyLinkedListNode current_node = firstNode;

            while (current_node != null)
            {
                s.Append(space);
                s.Append(quote);
                s.Append(current_node.Value);
                s.Append(quote);
                if (current_node.IsLast())
                {
                    break;
                }
                else
                {
                    s.Append(comma);
                }
                current_node = current_node.Next;
            }
            s.Append(space + right_br);
            return(s.ToString());

            //The following code also worked

            //SinglyLinkedListNode current = firstNode;
            //if (current == null)
            //{
            //    return "{ }";
            //}

            //StringBuilder builder = new StringBuilder();
            //builder.Append("\"" + current.Value + "\"");
            //while (current.Next != null)
            //{
            //    current = current.Next;
            //    builder.Append(", " + "\"" + current.Value + "\"");
            //}

            //string innerString = builder.ToString();
            //return "{ " + innerString + " }";
        }
Example #18
0
        // NOTE: There is more than one way to accomplish this.  One is O(n).  The other is O(1).
        public int Count()
        {
            if (this.firstNode == null)
            {
                return(0);
            }
            SinglyLinkedListNode currentNode = this.firstNode;
            int count = 1;

            while (!currentNode.IsLast())
            {
                currentNode = currentNode.Next;
                count++;
            }
            return(count);
        }
Example #19
0
 public void AddLast(string value)
 {
     if (this.First() == null)
     {
         firstNode = new SinglyLinkedListNode(value);
     }
     else
     {
         SinglyLinkedListNode nextNode = firstNode;
         while (!nextNode.IsLast())
         {
             nextNode = nextNode.Next;
         }
         nextNode.Next = new SinglyLinkedListNode(value);
     }
 }
Example #20
0
 public void AddLast(string value)
 {
     if (firstNode == null)
     {
         firstNode = new SinglyLinkedListNode(value);
     }
     else
     {
         SinglyLinkedListNode current_node = firstNode;
         while (!current_node.IsLast())
         {
             current_node = current_node.Next;
         }
         current_node.Next = new SinglyLinkedListNode(value);
     }
 }
        // NOTE: There is more than one way to accomplish this.  One is O(n).  The other is O(1).
        public int Count()
        {
            if (firstNode == null)
            {
                return(0);
            }
            int counter = 1;
            SinglyLinkedListNode currentNode = firstNode;

            while (!currentNode.IsLast())
            {
                currentNode = currentNode.Next;
                counter++;
            }
            return(counter);
        }
Example #22
0
        public override string ToString()
        {
            StringBuilder builtString = new StringBuilder("{ ");

            if (firstNode != null)
            {
                SinglyLinkedListNode testNode = firstNode;
                while (!testNode.IsLast())
                {
                    builtString.Append("\"").Append(testNode.ToString()).Append("\", ");
                    testNode = testNode.Next;
                }
                builtString.Append("\"").Append(testNode.ToString()).Append("\" ");
            }
            builtString.Append("}");
            return(builtString.ToString());
        }
        public void AddLast(string value)
        {
            if (firstNode == null)
            {
                firstNode = new SinglyLinkedListNode(value);
            }
            else
            {
                lastNode = firstNode;
                while (!lastNode.IsLast())
                {
                    lastNode = lastNode.Next;
                }

                lastNode.Next = new SinglyLinkedListNode(value);
            }
            count++;
        }
Example #24
0
        public override string ToString()
        {
            string               left         = "{";
            string               right        = "}";
            string               space        = " ";
            string               comma        = ",";
            string               quote        = "\"";
            StringBuilder        s            = new StringBuilder(left);
            SinglyLinkedListNode current_node = firstNode;

            while (current_node != null)
            {
                s.Append(space);
                s.Append(quote);
                s.Append(current_node.Value);
                s.Append(quote);
                if (current_node.IsLast())
                {
                    break;
                }
                else
                {
                    s.Append(comma);
                }
                current_node = current_node.Next;
            }
            s.Append(space + right);
            return(s.ToString());

            /*
             * if (firstNode == null)
             * {
             *  return "{ }";
             * }
             * else
             * {
             *  StringBuilder s = new StringBuilder("{ "); //allows you to build strings without eating all your computers memory
             *  s.Append("\"" + firstNode.Value + "\"");
             *  s.Append(" }");
             *  return s.ToString();
             * }
             */
        }
        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();

            if (firstNode != null)
            {
                SinglyLinkedListNode nodes = firstNode;
                while (!nodes.IsLast())
                {
                    sb.Append("\"");
                    sb.Append(nodes.Value.ToString());
                    sb.Append("\"");
                    sb.Append(", ");
                    nodes = nodes.Next;
                }
                sb.Append("\"" + nodes.Value.ToString() + "\" ");
            }

            return("{ " + sb + "}");
        }
Example #26
0
        public bool IsSorted()
        {
            bool sorted = true;

            if (count < 2)
            {
            }
            else
            {
                SinglyLinkedListNode testNode = firstNode;
                while (!testNode.IsLast())
                {
                    if (testNode > testNode.Next)
                    {
                        sorted = false;
                    }
                    testNode = testNode.Next;
                }
            }
            return(sorted);
        }
        public void AddAfter(string existingValue, string value)
        {
            if (firstNode == null)
            {
                firstNode = new SinglyLinkedListNode(value);
                return;
            }
            SinglyLinkedListNode currentNode = firstNode;

            while (currentNode.Value != existingValue)
            {
                currentNode = currentNode.Next;
                if (currentNode.IsLast() && currentNode.Value != existingValue)
                {
                    throw new ArgumentException();
                }
            }
            SinglyLinkedListNode insert = new SinglyLinkedListNode(value);

            insert.Next      = currentNode.Next;
            currentNode.Next = insert;
        }
        public void AddAfter(string existingValue, string value)
        {
            SinglyLinkedListNode node = first;

            while (node.Value != existingValue && node != null)
            {
                node = node.Next;
                if (node == null)
                {
                    throw new ArgumentException();
                }
            }
            if (node.IsLast())
            {
                AddLast(value);
                return;
            }
            SinglyLinkedListNode insertedNode = new SinglyLinkedListNode(value);

            insertedNode.Next = node.Next;
            node.Next         = insertedNode;
        }
 public void AddAfter(string existingValue, string value)
 {
     //throw new NotImplementedException();
     if (Count() == 0)
     {
         first = new SinglyLinkedListNode(value);
     }
     else
     {
         SinglyLinkedListNode node = first;
         while (node.Value != existingValue)
         {
             if (node.IsLast())
             {
                 throw new ArgumentException();
             }
             node = node.Next;
         }
         SinglyLinkedListNode storage = node.Next;
         node.Next      = new SinglyLinkedListNode(value);
         node.Next.Next = storage;
     }
 }
Example #30
0
        private SinglyLinkedListNode NodeAt(int index)
        {
            if (firstNode == null)
            {
                throw new ArgumentOutOfRangeException();
            }

            if (index < 0)
            {
                index = this.Count() + index;
            }

            SinglyLinkedListNode currentNode = firstNode;

            for (int i = 0; i < index; i++)
            {
                if (currentNode.IsLast())
                {
                    throw new ArgumentOutOfRangeException();
                }
                currentNode = currentNode.Next;
            }
            return(currentNode);
        }
 public void NodeLastWhenNotLast()
 {
     SinglyLinkedListNode node = new SinglyLinkedListNode("foo");
     Assert.IsTrue(node.IsLast());
 }
        public void AddLast(string value)
        {
            if (firstNode == null)
            {
                firstNode = new SinglyLinkedListNode(value);
            }
            else
            {
                lastNode = firstNode;
                while (!lastNode.IsLast())
                {
                    lastNode = lastNode.Next;
                }

                lastNode.Next = new SinglyLinkedListNode(value);
            }
            count++;
        }