Question

感谢您抽出时间停止我的问题。

下面你会发现我正在使用的SLL，但我想更多地使用C＃，而不是有两个类，SLL和Node，我想使用Node的构造函数来完成所有的工作（如果你通过了通过节点的字符串，构造函数将它切割成char节点）。问题是，经过几个小时的修修补补后，我真的无处可去......

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace PalindromeTester
{
    class Program
    {
        static void Main(string[] args)
        {
            SLL mySLL = new SLL();
            mySLL.add('a');
            mySLL.add('b');
            mySLL.add('c');
            mySLL.add('d');
            mySLL.add('e');
            mySLL.add('f');

            Console.Out.WriteLine("Node count = " + mySLL.count);
            mySLL.reverse();
            mySLL.traverse();
            Console.Out.WriteLine("\n The header is: " + mySLL.gethead);
            Console.In.ReadLine();
        }

        class Node
        {
            private char letter;
            private Node next;

            public Node()
            {
                next = null;
            }

            public Node(char c)
            {
                this.data = c;
            }

            public Node(string s)
            {

            }

            public char data
            {
                get { return letter; }
                set { letter = value; }
            }

            public Node nextNode
            {
                get { return next; }
                set { next = value; }
            }
        }

        class SLL
        {
            private Node head;
            private int totalNode;

            public SLL()
            {
                head = null;
                totalNode = 0;
            }

            public void add(char s)
            {
                if (head == null)
                {
                    head = new Node();
                    head.data = s;

                }
                else
                {
                    Node temp;
                    temp = new Node();
                    temp.data = s;
                    temp.nextNode = head;
                    head = temp;
                }
                totalNode++;
            }

            public int count
            {
                get { return totalNode; }
            }

            public char gethead
            {
                get { return head.data; }
            }

            public void traverse()
            {
                Node temp = head;
                while(temp != null)
                {
                    Console.Write(temp.data + " ");
                    temp = temp.nextNode;
                }
            }

            public void reverse()
            {
                Node q = null;
                Node p = this.head;
                while(p!=null)
                {
                    Node r=p;
                    p=p.nextNode;
                    r.nextNode=q;
                    q=r;
                }
                this.head = q;
            }
        }
    }
}

这是我到目前为止尝试将其用于Node的构造函数中的内容：

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace PalindromeTester
{
    class Program
    {
        static void Main(string[] args)
        {

            Node myNode = new Node("hello");

            Console.Out.WriteLine(myNode.count);
            myNode.reverse();
            myNode.traverse();
            Console.In.ReadLine();
        }

        class Node
        {
            private char letter;
            private Node next;
            private Node head;
            private int totalNode;

            public Node()
            {
                head = null;
                totalNode = 0;
            }

            public Node(char c)
            {
                if (head == null)
                {
                    head = new Node();
                    head.data = c;

                }
                else
                {
                    Node temp;
                    temp = new Node();
                    temp.data = c;
                    temp.nextNode = head;
                    head = temp;
                }
                totalNode++;
            }

            public Node(string s)
            {
                foreach (char x in s)
                {
                    new Node(x);
                }
            }

            public char data
            {
                get { return letter; }
                set { letter = value; }
            }

            public Node nextNode
            {
                get { return next; }
                set { next = value; }
            }

            public void reverse()
            {
                Node q = null;
                Node p = this.head;
                while (p != null)
                {
                    Node r = p;
                    p = p.nextNode;
                    r.nextNode = q;
                    q = r;
                }
                this.head = q;
            }

            public void traverse()
            {
                Node temp = head;
                while (temp != null)
                {
                    Console.Write(temp.data + " ");
                    temp = temp.nextNode;
                }
            }

            public int count
            {
                get { return totalNode; }
            }
        }
    }
}

理想情况下，我将留下的唯一构造函数和方法是Node（），Node（char c），Node（字符串s），Node reserve（），我将重新遍历到ToString重载。

有什么建议吗？

Answer 1

如果您希望链接列表能够将字符串分成几个节点，那么请确保执行此操作的方法实际上包含在LL而不是节点对象上。理论上，除非您正在寻找下一个/上一个值，否则您永远不应该知道节点对象。

您的char-linked-list应该有两个方法：一个用于添加char，另一个用于添加将被切割成多个节点的字符串。节点对象本身应该只有一个带char的构造函数。

基本上尝试将数据结构重写为只包含一个类是一个非常糟糕的主意。你真的需要至少两个对象。一个跟踪节点，一个节点对象跟踪。

Answer 2

假设这只是一个学习练习（没有其他理由来编写这样的课程），totalNode字段看起来非常可疑。它将具有值0或1.它是否是从给定节点开始的节点数的计数？如果你颠倒列表怎么样？

在Node的构造函数中，head字段始终为null，因此if是多余的。

也许您应该尝试运行代码，然后更新您的问题！

重新处理我的单链表

2 个答案: