c#数据结构的问题.

Question

public struct lnode <T> 
    { 
        T date; 
        lnode <T> next; 
    } 这样定义通不过． 
改为class就可以。 
public class lnode <T> 
    { 
        T date; 
        lnode <T> next; 
    } 
想了下不知道是不是这样． 
struct是直类型．定义的时候是放到堆中．必须初始化一个内存大小。所以大小必须是可知的．sizeof 而class是引用类型．堆栈中存放变量的指针（开始为null）．等到初始话的之后．指针直向堆中的开始位置． 
而且堆中有一个指针类型变量 next． 开始也为空的。等给next副直之后。才直向一个指针． inode <int> a=new lnode <int> 这个时候堆的next为空． 
如果 
inode <int> b=new lnode <int> 
a.next=b; 
那么next才直向b的指针． 
不　知道这样理解对不对．请解答．
附上单链表结构.刚开始学数据结构.有意见请更正.using System;
using System.Collections.Generic;
using System.Collections;namespace lsfv
{
    //链表结点的结构
    public class lnode<T>
    {
        private T date;
        private lnode<T> next;
                public T DATE
        {
            get { return date; }
            set { date = value; }
        }
        public lnode<T> NEXT
        {
            get { return next; }
            set { next = value; }
        }        public lnode()
        {
            date = default(T);
            next = null;
        }
    }
    /// <summary>
    /// 单链表
    /// </summary>
    public class ds_lnode<T>
    {
        private lnode<T> head;        public lnode<T> HEAD
        {
            get { return head; }
            set { head = value; }
        }        /// <summary>
        /// 构造函数，初始化链表
        /// </summary>
        public ds_lnode()
        {
            head = new lnode<T>();
        }        /// <summary>
        /// 构造函数，(带直)初始化链表
        /// </summary>
        public ds_lnode(T[] valarray)
        {
            head = new lnode<T>();
            lnode<T> p = new lnode<T>();
            p=head;
            for (int i = 0; i < valarray.Length; i++)
            {
                lnode<T> currentln = new lnode<T>();
                currentln.DATE = valarray[i];
                p.NEXT = currentln;
                p = p.NEXT;
            }        }
        /// <summary>
        /// 返回线性表的个数
        /// </summary>
        /// <returns></returns>
        public int lnodelength()
        {
            int i = 0;
            lnode<T> p = new lnode<T>();
            p =head;
            while (p.NEXT != null)
            {
                ++i;
                p = p.NEXT;
            }
            return i;
        }        /// <summary>
        /// 返回第i个元素的直,0为头结点
        /// </summary>
        /// <returns></returns>
        public T getelemval(int i)
        {
            int length = lnodelength();
            lnode<T> p = new lnode<T>();
            p = head;
            if (i>length||i<0)
            {
                throw new Exception("超出索引");
            }
            else
            {
                for (int j = 0; j < i; j++)
                {
                    p = p.NEXT;
                }
                return p.DATE;
            }
        }        /// <summary>
        /// 返回第i个元素，0为头结点
        /// </summary>
        /// <returns></returns>
        public lnode<T> getelem(int i)
        {
            int length = lnodelength();
            lnode<T> p = new lnode<T>();
            p = head;
            if (i > length || i < 0)
            {
                throw new Exception("超出索引");
            }
            else
            {
                for (int j = 0; j < i; j++)
                {
                    p = p.NEXT;
                }
                return p;
            }
        }        /// <summary>
        /// 返回第i个元素的前驱,i不能为0.从1开始,参数为1，返回头结点
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        private lnode<T> locateelem(int i)
        { 
        
            int length = lnodelength();
            lnode<T> p = new lnode<T>();
            p = head;
            if (i>length||i<0)
            {
                throw new Exception("超出索引.");
            }
            else
            {
                for (int j = 1; j < i; j++)
                {
                    p = p.NEXT;
                }
                return p;
            }
        }
        /// <summary>
        /// 在第i位置插入一个元素.i不能为0,0为头，参数为1．表示插入的是第一个元素
        /// </summary>
        /// <param name="val"></param>
        /// <param name="i"></param>
        public void listinsert(T val,int i)
        {
            int length = lnodelength();
            lnode<T> p = new lnode<T>();
            p = head;
            if (i<=0||i>length+1)
            {
                throw new Exception("超出索引.");
            }
            else
            {
                for (int j = 1; j < i; j++)
                {
                    p = p.NEXT;
                }
                //p为第i个元素的前驱
                lnode<T> insertn = new lnode<T>();
                insertn.DATE = val;
                insertn.NEXT = p.NEXT;
                p.NEXT = insertn;
            }
        }
        /// <summary>
        /// 删除第i个元素.i不能为0,0为头，参数为1．表示删除的是第一个元素
        /// </summary>
        /// <param name="val"></param>
        /// <param name="i"></param>
        public void listdelete(int i)
        {
            int length = lnodelength();
            if (i <= 0 || i > length)
            {
                throw new Exception("超出索引.");
            }
            else
            {
                lnode<T> bfnode = getelem(i - 1);
                bfnode.NEXT = bfnode.NEXT.NEXT;
            }
        }
    }
}

Answer 1

我以前也写过一个：
C#线性表的顺序存储结构
http://blog.bossma.cn/archives/2008/07/127

Answer 2

/// <summary>
    /// 栈
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ds_stack<T>
    {
        private lnode<T> sktop;        /// <summary>
        /// 初始化栈
        /// </summary>
        public ds_stack()
        {
            sktop = new lnode<T>();
        }
        /// <summary>
        /// 栈的元素个数
        /// </summary>
        /// <returns></returns>
        public int stacklength()
        {
            int i = 0;
            lnode<T> p = new lnode<T>();
            p=sktop;
            while (p.NEXT != null)
            {                ++i;
                p = p.NEXT;
            }
            return i;
        }        /// <summary>
        /// 入栈 pp=sktop 引用副直怎么之后改了,还是改动pp呢。但是把sktop的属性副给她就没有问题.??
        /// </summary>
        /// <param name="p"></param>
        public void stackpush(lnode<T> p)
        {
            lnode<T> pp = new lnode<T>();
            pp = sktop.NEXT;
            sktop.NEXT = p;
            p.NEXT = pp;
        }        /// <summary>
        /// 出栈
        /// </summary>
        public void statckpop()
        {
            if (sktop.NEXT != null)
            {
                lnode<T> p = new lnode<T>();
                p = sktop.NEXT;
                sktop.NEXT = p.NEXT;
                p = null;
            }
        }        /// <summary>
        /// 返回栈顶元素
        /// </summary>
        /// <returns></returns>
        public lnode<T> statcktop()
        {
            if (sktop.NEXT == null)
            {
                throw new Exception("空栈无栈顶元素");
            }
            return sktop.NEXT;
        }栈的迷宫例子public struct lujing
        {
            public int x;
            public int y;            public lujing(int x1, int y1)
            {                x = x1;
                y = y1;
            }
        }        private void migong()
        {
            int[,] mi ={ 
{ 0,1,1,1,1,1,1,1,1},
{ 0,0,0,0,0,1,1,1,1},
{ 1,0,1,0,0,1,1,1,1},
{ 1,0,1,1,1,1,1,1,1},
{ 1,0,0,0,0,0,0,0,0},
{ 1,0,0,1,1,1,1,1,0},
{ 1,1,1,1,1,0,0,0,0},
{ 1,1,1,1,1,0,1,1,1},
{ 1,1,1,1,1,0,0,0,1}};            lujing come = new lujing();
            come.x = 0;
            come.y = 0;            lujing outa = new lujing();
            outa.x = 8;
            outa.y = 7;            lsfv.ds_stack<lujing> stacklu = new lsfv.ds_stack<lujing>();            Response.Write("入口:" + come.x + "," + come.y);
            Response.Write("出口:" + outa.x + "," + outa.y);            lsfv.lnode<lujing> comepa = new lsfv.lnode<lujing>();
            comepa.DATE = come;
            stacklu.stackpush(comepa);            while (come.x != outa.x || come.y != outa.y)
            {
                if (stacklu.stacklength() > 0)
                {
                    if (come.x + 1 >= 0 && come.x + 1 <= 8 && come.y >= 0 && come.y <= 8 && mi[come.x + 1, come.y] == 0 && !statckexe(stacklu, new lujing(come.x + 1, come.y)))
                    {
                        come.x = come.x + 1;
                        lsfv.lnode<lujing> comep = new lsfv.lnode<lujing>();
                        comep.DATE = come;
                        stacklu.stackpush(comep);
                    }
                    else if (come.x >= 0 && come.x <= 8 && come.y + 1 >= 0 && come.y + 1 <= 8 && mi[come.x, come.y + 1] == 0 && !statckexe(stacklu, new lujing(come.x, come.y + 1)))
                    {
                        come.y = come.y + 1;
                        lsfv.lnode<lujing> comep = new lsfv.lnode<lujing>();
                        comep.DATE = come;
                        stacklu.stackpush(comep);
                    }
                    else if (come.x - 1 >= 0 && come.x - 1 <= 8 && come.y >= 0 && come.y <=8 && mi[come.x - 1, come.y] == 0 && !statckexe(stacklu, new lujing(come.x - 1, come.y)))
                    {
                        come.x = come.x - 1;
                        lsfv.lnode<lujing> comep = new lsfv.lnode<lujing>();
                        comep.DATE = come;
                        stacklu.stackpush(comep);
                    }
                    else if (come.x >= 0 && come.x <= 8 && come.y - 1 >= 0 && come.y - 1 <= 8 && mi[come.x, come.y - 1] == 0 && !statckexe(stacklu, new lujing(come.x, come.y - 1)))
                    {
                        come.y = come.y - 1;
                        lsfv.lnode<lujing> comep = new lsfv.lnode<lujing>();
                        comep.DATE = come;
                        stacklu.stackpush(comep);
                    }
                    else
                    {
                        mi[come.x, come.y] = 1;
                        stacklu.statckpop();
                    }
                }
                else
                {
                    Response.Write("没有出口");
                    break;
                }
            }
            while (stacklu.stacklength()>0)
            {
                Response.Write(stacklu.statcktop().DATE.x + "," + stacklu.statcktop().DATE.y+"--->");
                stacklu.statckpop();
            }