linked lists.-VBForums
Results 1 to 2 of 2

Thread: linked lists.

  1. #1

    Thread Starter
    Junior Member
    Join Date
    May 2011
    Posts
    24

    linked lists.

    Hi I am really close at getting this to work. The copy and reverse functions are the issue.

    The copy only does the first and last node and non of the middle nodes. Seems like it is not moving along as it goes. How do it fix that?

    Reverse is just totally messed up because the .previous node don't seem to be correct and I can't figure out why.


    Code:
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace me_Palindromic_Lists
    {
        class palindromicNode
        {
            // Dimention a new node
            private Node palindromicList;
    
            // Blank Constructor
            public palindromicNode()
            {
                palindromicList = null;
            }
    
            // Constructor for one character
            public palindromicNode(char c)
            {
                palindromicList = new Node(c);
            }
    
            // Constructor for a sting
            public palindromicNode(string s)
            {
    
                // Set a node to keep track
                Node Current = new Node();
                // Keep track of the pervios node
                Node prevNode = new Node();
    
                // Loop through each character in the string 
                foreach (char c in s)
                {
    
                    // Create a new node for the character
                    Node palNode = new Node(c);
                    palNode.previous = prevNode;
    
                    // Check to see if the node list is blank, indicaing it is new
                    if (palindromicList == null)
                        // Set palnode as the new node
                        palindromicList = palNode;
                    else
                    {
                        //Make current the current Copy of the list 
                        Current = palindromicList;
    
                        // Loop to the last node
                        while (Current.next != null)
                            Current = Current.next;
    
                    }
    
                    // Keep track of this node for next time
                    prevNode = Current;    
                    // Set the next node as the new node
                    Current.next = palNode;
                          
                }
            }
    
            public int length
            {
                get
                {
                    // Set up a node to keep track
                    Node Current = palindromicList;
                    // Dimention a counter to count the length
                    int counter = 1;
    
                    // Loop through each node
                    while (Current.next != null)
                    {
                        // Increment the counter
                        counter++;
                        Current = Current.next;
                    }
                    // Return the counter
                    return counter;
                }
            }
    
            // Override the ToSting
            public override string ToString()
            {
                // Dimention a place for the result
                String result = "";
                // Create a note to keep track
                Node current = palindromicList;
    
                // Loop through each node
                while (current != null)
                {
                    // Append the result with the next character
                    result += current.nodeCharater;
                    // Advance to the next node
                    current = current.next;
                }
                // Return the result string
                return result;
            }
    
            public palindromicNode Copy()
            {
                // Dimention a node to keep track
                Node Current = palindromicList;
                Node previousNode = new Node();
                // Dimention a new instance of the list
                palindromicNode copiedList = new palindromicNode();
                            
                // Loop through the current list
                while (Current != null)
                {
                    // Create a new node
                    Node newNode = new Node(Current.nodeCharater);
                    // Set the previous node
                    newNode.previous  = previousNode;
    
                    // Check if the new list is blank which indicates it is new and set equal to new node
                    if (copiedList.palindromicList == null)
                    {
                        copiedList.palindromicList = newNode;
                    }
                    else
                    {
                        // Set new node as the next node
                        copiedList.palindromicList.next = newNode;
                        //copiedList.palindromicList = newNode;
    
                    }
                    // Remeber this as the previous node for next iteration
                    previousNode = Current;
                    // Advance the current node
                    Current = Current.next;
                }
                // Return the new list
                return copiedList;
            }
    
            public palindromicNode Reverse()
            {
                // not complete
                palindromicNode nodeReverse = new palindromicNode();
                Node Current = palindromicList;
                Node previousNode = new Node();
    
                // Loop to the last node
                while (Current.next != null)
                    Current = Current.next;
    
    
                while (Current  != null)
                {
    
                    Node reverseNode = new Node(Current.nodeCharater);
                    reverseNode.previous = previousNode;
    
    
                    if (nodeReverse.palindromicList == null)
                    {
                        nodeReverse.palindromicList = reverseNode;
                    }
                    else
                    {
    
                        nodeReverse.palindromicList.next = reverseNode;
    
                    }
    
                    previousNode = Current;
                    Current = Current.previous;
    
                }
    
    
    
                return nodeReverse;
            }
    
            public bool equals(palindromicNode n)
            {
                bool result = true;
    
                Node Current = palindromicList;
                
                while (Current != null)
                {
                    if (Current.nodeCharater != n.palindromicList.nodeCharater)
                    {
                        result = false;
                    }
    
                    Current = Current.next;
                    n.palindromicList = n.palindromicList.next;
    
                }
    
                 return result;
            }
    
            // Make a node class
            private class Node
            {
                // The character value
                public char nodeCharater;
                // Store the next node 
                public Node next;
                // Store the last node
                public Node previous;
    
                // Constructor for a blank node.
                public Node()
                {
                    nodeCharater = '\0';
                    next = null;
                    previous = null;
                }
    
                //Contructor for a node with a character
                public Node(char character)
                {
                    nodeCharater = character;
                    next = null;
                    previous = null;
                }
            }
        }
    }
    Code:
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.IO;
    
    namespace me_Palindromic_Lists
    {
        class Program
        {
            static void Main(string[] args)
            {
    
                header();
    
                StreamReader myStream = new StreamReader("data.txt");
                string[] palindromeString = myStream.ReadLine().ToString().Split(' ');
                                    
                foreach (string item in palindromeString )
                {
    
                    palindromicNode palindrome = new palindromicNode(item);
                   
                    Console.WriteLine("Initial string: \t" + item);
    
                    Console.WriteLine("String as a list: \t" + palindrome.ToString() );
    
                    palindromicNode copy = palindrome.Copy();
                    palindromicNode reverseCopy = palindrome.Reverse();
    
                    Console.WriteLine("Copy as a list: \t" + copy.ToString() );
                    Console.WriteLine("Copy Reversed: \t\t" + reverseCopy .ToString() );
    
                    if (copy.equals (reverseCopy ))
                    {
                        Console.WriteLine ("This is a palindrome");
                    }
                    else
                    {
                        Console.WriteLine("This is not a palindrome");
                    }
    
    
                    
    
                    Console.WriteLine();
    
                }
    
                Console.Read();
                
              
            }
    
            static void header()
            {
    
                Console.WriteLine("Palindromic Lists\n");
                Console.WriteLine("Author: Scott Merryfield");
                Console.WriteLine("Class: c# GSD311");
                Console.WriteLine("Assignment: Seminar 5 Individual Program");
                Console.WriteLine("Date: March 20, 2012\n");
    
            }
        }
    }

  2. #2
    Fanatic Member
    Join Date
    Feb 2000
    Location
    Dunmow,Essex,England
    Posts
    898

    Re: linked lists.

    Linq gives a reverse feature. I'd suggest you take a look at that it could save you a whole heap of code.

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •  



Featured


Click Here to Expand Forum to Full Width

Survey posted by VBForums.