关于c#写单链表的困惑

Question

using System;
using System.Collections.Generic;
using System.Text;namespace DataStruct
{
    class Link_List
    {
        public class Node<T>
        {
            private T data;//数据域
            private Node<T> next;//引用域            public Node(T val, Node<T> p)
            {
                data = val;
                next = p;
            }            public Node(Node<T> p)
            {
                next = p;
            }            public Node(T val)
            {
                data = val;
            }            public Node()
            {
                data = default(T);
                next = null;
            }            public T Data
            {
                get
                {
                    return data;
                }
                set
                {
                    data =value ;
                }
            }            public Node<T> Next
            {
                get
                {
                    return next;
                }
                set
                {
                    next = value;
                }
            }
        }
        public class LinkList<T> : List_line.IListDS<T>
        {
            private Node<T> head;
            public Node <T> Head
            {
                get
                {
                    return head;
                }
                set
                {
                    head = value;
                }
            }            public LinkList()
            {
                head = null;
            }            public int GetLength()
            {
                Node<T> p = head;                int len = 0;
                while (p != null)
                {
                    ++len;
                    p = p.Next;
                }
                return len;
            }
            //清空链表
            public void Clear()
            {
                head = null;
            }            //判断单链表是否为空
            public bool IsEmpty()
            {
                if (head == null)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            public void Append(T item)
            {
                Node<T> q = new Node<T>(item);
                Node<T> p = new Node<T>();
                if (head == null)
                {
                    head = q;
                    return;
                }
                p = head;
                while (p.Next != null)
                {
                    p = p.Next;
                }
                p.Next = q;
            }
        }
    }
}
我上知道以上代码p和p.next的区别，在我看来上面的程序p是节点而p.next是节点里面指向下一个节点的地址，为什么能将p.next赋给p，虽然类型相同，但是他们代表的含义是不同的，烦恼中～～～～～～～～～～～～～～，请大虾指点

Answer 1

p.Next是p的下一个节点，不是下一个节点的地址。

Answer 2

p是节点而p.next是节点里面指向下一个节点的地址，为什么能将p.next赋给p，虽然类型相同，但是他们代表的含义是不同的
呵呵，你是一时糊涂了比如 int a=10;int b =6;b=a;为什么能将a赋给b，虽然类型相同   你不疑惑吧？当然上述是值类型，直接赋值了。p,p.next都是引用类型，它们赋值的含义是引用同一个实例请详细搞懂引用类型

Answer 3

C#中的类其实很像C++中的引用。p声明为一个节点的引用  当然可以赋值， 使其指向其他的节点 包括next

Answer 4

还是有点晕啊，以前学的是c++版的，搞到c#中不知道怎么定义了能帮我注释append函数吗？

Answer 5

还是有点晕啊，以前学的是c++版的，搞到c#中不知道怎么定义了能帮我注释append函数吗？

Answer 6

using System; 
using System.Collections.Generic; 
using System.Text; namespace DataStruct 
{ 
    class Link_List 
    { 
        public class Node <T> 
        { 
            private T data;//数据域 
            private Node <T> next;//引用域             public Node(T val, Node <T> p) 
            { 
                data = val; 
                next = p; 
            }             public Node(Node <T> p) 
            { 
                next = p; 
            }             public Node(T val) 
            { 
                data = val; 
            }             public Node() 
            { 
                data = default(T); 
                next = null; 
            }             public T Data 
            { 
                get 
                { 
                    return data; 
                } 
                set 
                { 
                    data =value ; 
                } 
            }             public Node <T> Next 
            { 
                get 
                { 
                    return next; 
                } 
                set 
                { 
                    next = value; 
                } 
            } 
        } 
        public class LinkList <T> : List_line.IListDS <T> 
        { 
            private Node <T> head; 
            public Node <T> Head 
            { 
                get 
                { 
                    return head; 
                } 
                set 
                { 
                    head = value; 
                } 
            }             public LinkList() 
            { 
                head = null; 
            }             public int GetLength() 
            { 
                Node <T> p = head;                 int len = 0; 
                while (p != null) 
                { 
                    ++len; 
                    p = p.Next; 
                } 
                return len; 
            } 
            //清空链表 
            public void Clear() 
            { 
                head = null; 
            }             //判断单链表是否为空 
            public bool IsEmpty() 
            { 
                if (head == null) 
                { 
                    return true; 
                } 
                else 
                { 
                    return false; 
                } 
            } 
            public void Append(T item) 
            { 
                Node <T> q = new Node <T>(item);  //创建新的Node实例，此时q.Next=item
                Node <T> p = new Node <T>();      //此处应修改为Node <T> p=null; 无需实例化。仅仅声明一个临时的Node引用而已。
                if (head == null)  //如果head为空，说明链表长度为0，新的Node q就是第一个进来的，就是头
                { 
                    head = q;      //让q做头，此时head和q是同一个东东，引用同一个实例   
                    return;        //返回了，没别的事可做了。所以，上述Node <T> p的声明应该放到后面。
                } 
                p = head;          //既然到这儿了，说明链表已经有元素了，head不为空。那就用p这个临时变量来扫描链表，当然从头开始向后走了
                                        //老实说，这里才应该开始声明p。改为Node <T> p = head;
                while (p.Next != null)  //如果后面还有，那就继续，目标是扫到链表最后一个元素
                { 
                    p = p.Next;  //让p引用下一个元素，扫描位置后移
                } 
                //while结束后，p就是链表的最后一个元素
                p.Next = q;  //把新的节点（元素）q挂到p(链表最后一个节点)的后面，完工
            } 
        } 
    } 
}