程序代码：

/*

 * @文件名：Program.cs

 * @描  述：顺序表的基本操作

 */
using System;
public interface IListDS<T>
{
    void Clear();//清空操作
    bool IsEmpty();//判断线性表是否为空
    void Append(T nItem);//附加操作
    void Insert(T nItem, int nPos);//插入操作
    void Delete(int nPos);//删除操作
    T GetElem(int nPos);//取表元
    int Locate(T nValue);//按值查找
    void Print();//打印顺序表
}
public class SeqList<T>:IListDS<T>
{
    private int MAX_SIZE;//顺序表的容量
    private int m_Len;//元素的个数
    private T[] m_Data;//顺序表
    //构造函数
    public SeqList(int nSize)
    {
        m_Data = new T[nSize];
        MAX_SIZE = nSize;
        m_Len = 0;
    }
    //索引器
    public T this[int nIndex]
    {
        get { return m_Data[nIndex]; }
        set { m_Data[nIndex] = value; }
    }
    //容量属性
    public int MaxSize
    {
        get { return MAX_SIZE; }
        set { MAX_SIZE = value; }
    }
    //获取顺序表的长度
    public int GetLen
    {
        get { return m_Len; }
    }
    //清空顺序表
    public void Clear()
    {
        m_Len = 0;
    }
  
    //判断线性表是否为空
    public bool IsEmpty()
    {
        return m_Len == 0;
    }
    //附加操作
    public void Append(T nItem)
    {
        //添加到顺序表的末尾
        m_Data[m_Len++] = nItem;
    }
  
    //在指定的位置上进行插入操作
    public void Insert(T nItem, int nPos)
    {
        if (nPos < 1 || nPos > m_Len)
        {
            Console.WriteLine("\t插入的位置不正确！");
            Console.WriteLine();
        }
        for (int i = m_Len; i >= nPos; --i)
        {
            m_Data[i] = m_Data[i - 1];
        }
        m_Data[nPos - 1] = nItem;
        ++m_Len;
    }
  
    //在指定的位置进行删除操作
    public void Delete(int nPos)
    {
        if (nPos < 1 || nPos > m_Len)
        {
            Console.WriteLine("\t删除的位置不正确！");
            Console.WriteLine();
        }
        for (int i = nPos-1; i < m_Len; ++i)
        {
            m_Data[i] = m_Data[i + 1];
        }
        --m_Len;
    }
    //返回指定顺序表位置的值
    public T GetElem(int nPos)
    {
        if (nPos < 1 || nPos > m_Len)
        {
            Console.WriteLine("\t删除的位置不正确！");
            Console.WriteLine();
        }
        return m_Data[nPos-1];
    }
    //根据值查找元素的第一个位置
    public int Locate(T nValue)
    {
        for (int i = 0; i < m_Len; ++i)
        {
            if (nValue.Equals(m_Data[i]))
            {
                return i+1;
            }
        }
        return 0;
    }
    //输出顺序表的元素
    public void Print()
    {
        for (int i = 0; i < m_Len; ++i)
        {
            Console.Write("{0} ", m_Data[i]);
        }
        Console.WriteLine();
    }
}
public class App
{
    public static void Main()
    {
        SeqList<int> list = new SeqList<int>(10);

        Console.WriteLine("Print list: ");
        list.Print();

        Console.WriteLine("list maxsize is:{0}", list.MaxSize);
        Console.WriteLine();

        Console.WriteLine("Append 1 2 3");
        list.Append(1);
        list.Append(2);
        list.Append(3);
        Console.WriteLine("Print list: ");
        list.Print();
        Console.WriteLine();

        Console.WriteLine("At 1 position Insert 4");
        list.Insert(4, 1);
        Console.WriteLine("Print list: ");
        list.Print();
        Console.WriteLine();

        Console.Write("Get list length:");
        Console.WriteLine("{0} ", list.GetLen);
        Console.WriteLine();

        Console.WriteLine("Find 2's position:");
        Console.WriteLine("{0} ", list.Locate(2));
        Console.WriteLine();

        Console.WriteLine("Delete 2's position:");
        list.Delete(list.Locate(2));
        Console.WriteLine("Print list: ");
        list.Print();
        Console.WriteLine();
    }
}

程序代码：

/**

 * @文件名：Program.cs

 * @作  者：寒风中的细雨

 * @时  间：2012/4/24/

 * @概  述：实现顺序表L，将其倒置

 */
using System;


//顺序表接口
interface ISeqList<T>
{
    int Append(T nData);//在顺序表的末尾添加
    int Insert(int Pos, T nData);//在指定的位置插入
    bool IsEmpty();//判断顺序表示是否为空
    bool IsFull();//判断顺序表示是否为满
    void Print();//打印表
    SeqList<T> Reverse();//倒置
}

//顺序表类
class SeqList<T> : ISeqList<T>
{
    int m_MAXSIZE;//顺序表的最大容量
    int m_Length;//顺序表中元素的个数
    T []m_Data;//存放数据的容器

    //支持下标操作
    T this[int nIndex]
    {
        get { return m_Data[nIndex]; }
        set { m_Data[nIndex] = value; }
    }

    //构造函数
    public SeqList(int nMAX_SIZE)
    {
        m_MAXSIZE = nMAX_SIZE;
        m_Length = 0;
        m_Data = new T[m_MAXSIZE];
    }

    //输出整个顺序表
    public void Print()
    {
        int i;

        for (i = 0; i < m_Length; ++i)
        {
            Console.Write("{0} ", m_Data[i]);
        }
    }

    //判断顺序表是否为空
    //返回值：空  true 
    //        非空  false
    public bool IsEmpty()
    {
        return m_Length == 0;
    }

    //判断顺序表示是否为满
    //返回值：满 true 
    //        非满  false
    public bool IsFull()
    {
        return m_Length == m_MAXSIZE;
    }

    //在顺序表的末尾添加元素
    //返回值：成功 0
    //        失败 非零
    public int Append(T nData)
    {
        if (IsFull())
        {
            Console.WriteLine("\t顺序表添加失败，没有足够的空间!");

            return -1;
        }

        m_Data[m_Length++] = nData;

        return 0;
    }

    //在顺序表指定的位置插入元素
    //返回值：成功 0
    //        失败 非零
    public int Insert(int Pos, T nData)
    {
        //判断Pos是否合法
        if (Pos < 1 || Pos > m_Length)
        {
            Console.WriteLine("\t顺序表插入失败，插入的位置不正确!");

            return -1;
        }

        if (IsFull())
        {
            Console.WriteLine("\t顺序表插入失败，没有足够的空间!");

            return -1;
        }

        int i;
        //移动一个单位
        for (i = m_Length; i >= Pos; --i)
        {
            m_Data[i] = m_Data[i - 1];
        }

        m_Data[i] = nData;
        ++m_Length;

        return 0;
    }

    //将顺序表逆置
    public SeqList<T> Reverse()
    {
        SeqList<T> temp = new SeqList<T>(this.m_MAXSIZE);

        int i;

        for (i = 0; i < this.m_Length; ++i)
        {
            if (temp.IsEmpty())
            {
                temp.Append(this.m_Data[i]);
            }
            else
            {
                temp.Insert(1, this.m_Data[i]);
            }
        }

        return temp;
    }

}

class App
{
    public static void Main()
    {
        SeqList<int> lst = new SeqList<int>(10);

        Console.Write("输出 lst 顺序表的初始化元素的状态( ");
        lst.Print();
        Console.WriteLine(").\n");
        for (int i = 1; i <= 10; ++i)
        {
            lst.Append(i);
        }
        Console.Write("输出 lst 顺序表添加10个元素的状态( ");
        lst.Print();
        Console.WriteLine(").\n");

        lst = lst.Reverse();
        Console.Write("输出 lst 顺序表逆置后的元素的状态( ");
        lst.Print();
        Console.WriteLine(").\n");

    }
}

程序代码：

/**

 * @文件名：Program.cs

 * @作  者：寒风中的细雨

 * @时  间：2012/4/25/

 * @概  述：实现有序顺序表La和Lb，合并成一个有序顺序表Lc

 */
using System;

//顺序表类
class SeqList
{
    private int m_MAXSIZE;//顺序表的最大容量
    private int m_Length;//顺序表中元素的个数
    private int []m_Data;//存放数据的容器

    public int Data
    {
        get { return m_MAXSIZE; }
    }

    //支持下标操作
    int this[int nIndex]
    {
        get { return m_Data[nIndex]; }
        set { m_Data[nIndex] = value; }
    }

    //构造函数
    public SeqList(int nMAX_SIZE)
    {
        m_MAXSIZE = nMAX_SIZE;
        m_Length = 0;
        m_Data = new int[m_MAXSIZE];
    }

    //输出整个顺序表
    public void Print()
    {
        int i;
        for (i = 0; i < m_Length; ++i)
        {
            Console.Write("{0} ", m_Data[i]);
        }
    }

    //判断顺序表是否为空
    //返回值：空  true
    //        非空  false
    public bool IsEmpty()
    {
        return m_Length == 0;
    }

    //判断顺序表示是否为满
    //返回值：满 true
    //        非满  false
    public bool IsFull()
    {
        return m_Length == m_MAXSIZE;
    }

    //在顺序表的末尾添加元素
    //返回值：成功 0
    //        失败 非零
    public int Append(int nData)
    {
        if (IsFull())
        {
            Console.WriteLine("\t顺序表添加失败，没有足够的空间!");
            return -1;
        }
        m_Data[m_Length++] = nData;

        return 0;
    }

    //顺序表与nRight顺序表进行合并
    //bFlag  false  降序
    //       true   升序
    //返回新的顺序表
    public SeqList Merge(SeqList nRight, bool nFlag)
    {
        nRight.Sort(nFlag);
        Sort(nFlag);
        int i, j;

        SeqList Lc = new SeqList(m_Length + nRight.m_Length);
        for (i = 0, j = 0; i < m_Length && j < nRight.m_Length; )
        {
            if (nFlag )
            {//升序
                if (m_Data[i] < nRight[j])
                {
                    Lc.Append(m_Data[i]);
                    ++i;
                }
                else
                {
                    Lc.Append(nRight[j]);
                    ++j;
                }
            }
            else
            {//降序
                if (m_Data[i] < nRight[j])
                {
                    Lc.Append(nRight[j]);
                    ++j;
                }
                else
                {
                    Lc.Append(m_Data[i]);
                    ++i;
                }
            }
        }

        while (i != m_Length)
        {
            Lc.Append(m_Data[i]);
            ++i;
        }

        while (j != nRight.m_Length)
        {
            Lc.Append(nRight[j]);
            ++j;
        }

        return Lc;
    }

    ////排序
    //bFlag  false  降序
    //       true   升序
    //返回排序后的顺序表
    public void Sort(bool bFlag)
    {
        int i, j;
        //冒泡排序
        for (i = 0; i < m_Length; ++i)
        {
            for (j = 0; j < m_Length-i-1; ++j)
            {
                if (m_Data[j+1] < m_Data[j])
                {//升序
                    int nTmp = m_Data[j];
                    m_Data[j] = m_Data[j+1];
                    m_Data[j+1] = nTmp;
                }
            }
        }

        if (bFlag == false)
        {//降序
            for (i = 0, j = m_Length - 1; i != j; ++i, --j)
            {
                m_Data[i] += m_Data[j];
                m_Data[j] = m_Data[i] - m_Data[j];
                m_Data[i] = m_Data[i] - m_Data[j];
            }
        }
    }
}

class App
{
    public static void Main()
    {
        SeqList Lst = new SeqList(7);
        SeqList Tst = new SeqList(5);

        Console.Write("输出 Lst 顺序表的初始化元素的状态( ");
        Lst.Print();
        Console.WriteLine(").");

        Console.Write("输出 Tst 顺序表的初始化元素的状态( ");
        Tst.Print();
        Console.WriteLine(").");

        Console.WriteLine("输入Lst的{0}个元素", Lst.Data);
        for (int i = 1; i <= Lst.Data; ++i)
        {
            int j;
            j = Int32.Parse(Console.ReadLine());
            Lst.Append(j);
        }
        Console.Write("输出 Lst 顺序表的初始化元素的状态( ");
        Lst.Print();
        Console.WriteLine(").");

        Console.WriteLine("输入Tst的{0}个元素", Tst.Data);
        for (int i = 1; i <= Tst.Data; ++i)
        {
            int j;
            j = Int32.Parse(Console.ReadLine());
            Tst.Append(j);
        }
        Console.Write("输出 Tst 顺序表的初始化元素的状态( ");
        Tst.Print();
        Console.WriteLine(").");

        Console.Write("输出 Lst 顺序表升序的元素的状态( ");
        Lst.Sort(true);
        Lst.Print();
        Console.WriteLine(").");

        Console.Write("输出 Tst 顺序表降序的元素的状态( ");
        Tst.Sort(false);
        Tst.Print();
        Console.WriteLine(").");

        Console.Write("输出升序合并 Tst 和 Lst 顺序表( ");
        SeqList Lc = Tst.Merge(Lst, true);
        Lc.Print();
        Console.WriteLine(").");
    }
}

程序代码：

/**

 * @文件名：Program.cs

 * @作  者：寒风中的细雨

 * @时  间：2012/4/26/

 * @概  述：单链表的基本操作

 */
using System;

class CNode<T>
{
    private T m_Data;//数据域
    private CNode<T> m_Next;//指向后继

    //默认构造函数
    public CNode()
    {
        m_Data = default(T);
        m_Next = null;
    }

    //带参构造函数
    public CNode(T nData, CNode<T> nNext)
    {
        m_Data = nData;
        m_Next = nNext;
    }

    //数据域属性操作
    public T Data
    {
        get { return m_Data; }
        set { m_Data = value; }
    }

    //后继域属性操作
    public CNode<T> Next
    {
        get { return m_Next; }
        set { m_Next = value; }
    }
}

interface IList<T>
{
    int GetLength();//获取链表的长度
    void Clear();//清空链表
    bool IsEmpty();//判断链表是否为空
    void Append(T nData);//在链表的末尾添加元素
    void Insert(int nPos, T nData);//在指定位置插入元素
    void Delete(int nPos);//指定要删除元素的位置
    T GetElem(int nPos);//获取指定位置的值
    int GetIndex(T nData);//查找指定值在链表中的位置
    void Print();//打印链表
}

//单链表类
class LinkList<T>:IList<T>
{
    private CNode<T> m_Head;

    //构造函数
    public LinkList()
    {
        //带上头结点
        m_Head = new CNode<T>();
        Console.WriteLine("\t启动单链表......");
    }

    ////获取链表的长度
    //返回值  链表的长度
    public int GetLength()
    {
        CNode<T> nTmp = m_Head.Next;
        int i = 0;
        while (null != nTmp)
        {
            ++i;
            nTmp = nTmp.Next;
        }

        return i;
    }
  
    //清空链表
    public void Clear()
    {
        m_Head.Next = null;//垃圾回收
    }

    //判断链表是否为空
    //返回值：空-true
    //        非空-false
    public bool IsEmpty()
    {
        return null == m_Head.Next;
    }

    //在链表的末尾添加元素
    public void Append(T nData)
    {
        CNode<T> nTmp = m_Head;

        while (null != nTmp.Next)
        {
            nTmp = nTmp.Next;
        }
        nTmp.Next = new CNode<T>(nData, nTmp.Next);
    }

    //在指定位置插入元素
    public void Insert(int nPos, T nData)
    {
        if (nPos > GetLength() || nPos < 1)
        {
            Console.WriteLine("\t元素插入的位置不正确!");
        }

        CNode<T> nTmp = m_Head;

        while (0 != --nPos)
        {
            nTmp = nTmp.Next;
        }

        nTmp.Next = new CNode<T>(nData, nTmp.Next);
    }

    //指定要删除元素的位置
    public void Delete(int nPos)
    {
        if (nPos > GetLength() || nPos < 1)
        {
            Console.WriteLine("\t指定删除的元素位置不正确!");
            return;
        }

        CNode<T> nTmp = m_Head;

        while (0 != --nPos)
        {
            nTmp = nTmp.Next;
        }

        nTmp.Next = nTmp.Next.Next;
    }

    //获取指定位置的值
    public T GetElem(int nPos)
    {
        if (nPos > GetLength() || nPos < 1)
        {
            Console.WriteLine("\t指定查询元素位置不正确!");
            return default(T);
        }

        CNode<T> nTmp = m_Head.Next;

        while (0 != --nPos)
        {
            nTmp = nTmp.Next;
        }

        return nTmp.Data;
    }

    //查找指定值在链表中的位置
    public int GetIndex(T nData)
    {
        int i = 1;
        CNode<T> nTmp = m_Head.Next;

        while (null != nTmp && !nTmp.Data.Equals(nData))
        {
            ++i;
            nTmp = nTmp.Next;
        }

        if (null == nTmp)
        {//不存在要查找的元素
            return -1;
        }

        return i;
    }

    //打印链表
    public void Print()
    {
        CNode<T> nTmp = m_Head.Next;

        while (null != nTmp)
        {
            Console.Write("{0} ", nTmp.Data);
            nTmp = nTmp.Next;
        }
    }
}

class App
{
    public static void Main()
    {
        int i=0;
        LinkList<int> Lst = new LinkList<int>();

        while (-1 != i)
        {
            choice(ref i);
            run(Lst, i);
        }
    }

    static void run(LinkList<int> Lst, int i)
    {
        switch (i)
        {
            case 1://输出单链表.
                {
                    Console.Write("输出单链表的元素( ");
                    Lst.Print();
                    Console.WriteLine(").");
                }
                break;
            case 2://链表末尾添加元素.
                {
                    Console.Write("输入添加的元素值：");
                    int j = int.Parse(Console.ReadLine());
                    Lst.Append(j);
                }
                break;
            case 3://指定位置插入元素.
                {
                    Console.Write("输入添加的元素位置：");
                    int j = int.Parse(Console.ReadLine());
                    Console.Write("输入添加的元素值：");
                    int k = int.Parse(Console.ReadLine());
                    Lst.Insert(j, k);
                }
                break;
            case 4://指定位置删除元素.
                {
                    Console.Write("输入删除元素的位置：");
                    int j = int.Parse(Console.ReadLine());
                    Lst.Delete(j);
                }
                break;
            case 5://指定值查询元素下标.
                {
                    Console.Write("输入查询下标元素的值：");
                    int j = int.Parse(Console.ReadLine());
                    Console.WriteLine("下标为{0}", Lst.GetIndex(j));
                }
                break;
            case 6://指定位置查询元素值.
                {
                    Console.Write("输入查询值元素的下标：");
                    int j = int.Parse(Console.ReadLine());
                    Console.WriteLine("元素的值为{0}", Lst.GetElem(j));
                }
                break;
            case 7://清空链表.
                {
                    Console.WriteLine("清空链表");
                    Lst.Clear();
                }
                break;
            default:
                break;
        }
    }

    static void choice(ref int i)
    {
        Console.WriteLine("\n\t根据下面提示信息选择操作.");
        Console.WriteLine("\"1\"：输出单链表.");
        Console.WriteLine("\"2\"：链表末尾添加元素.");
        Console.WriteLine("\"3\"：指定位置插入元素.");
        Console.WriteLine("\"4\"：指定位置删除元素.");
        Console.WriteLine("\"5\"：指定值查询元素下标.");
        Console.WriteLine("\"6\"：指定位置查询元素值.");
        Console.WriteLine("\"7\"：清空链表.");
        Console.WriteLine("\"-1\"：退出链表操作.");

        i = Int16.Parse(Console.ReadLine());
    }
}

程序代码：

/**

 * @文件名：Program.cs

 * @作  者：寒风中的细雨

 * @时  间：2012/4/27/

 * @概  述：带头结点的单链表的逆置

 */
using System;

class CNode<T>
{
    private T m_Data;//数据域
    private CNode<T> m_Next;//指向后继

    //默认构造函数
    public CNode()
    {
        m_Data = default(T);
        m_Next = null;
    }

    //带参构造函数
    public CNode(T nData, CNode<T> nNext)
    {
        m_Data = nData;
        m_Next = nNext;
    }

    //数据域属性操作
    public T Data
    {
        get { return m_Data; }
        set { m_Data = value; }
    }

    //后继域属性操作
    public CNode<T> Next
    {
        get { return m_Next; }
        set { m_Next = value; }
    }
}

interface IList<T>
{
    int GetLength();//获取链表结点个数
    void Append(T nData);//在链表的末尾添加元素
    void Insert(int nPos, T nData);//在指定位置插入元素
    void Print();//打印链表
    LinkList<T> Reverse();//逆置
}

//单链表类
class LinkList<T>:IList<T>
{
    private CNode<T> m_Head;

    //构造函数
    public LinkList()
    {
        //带上头结点
        m_Head = new CNode<T>();
    }

    ////获取链表的长度
    //返回值  链表的长度
    public int GetLength()
    {
        CNode<T> nTmp = m_Head.Next;
        int i = 0;

        while (null != nTmp)
        {
            ++i;
            nTmp = nTmp.Next;
        }
        return i;
    }

    //在链表的末尾添加元素
    public void Append(T nData)
    {
        CNode<T> nTmp = m_Head;

        while (null != nTmp.Next)
        {
            nTmp = nTmp.Next;
        }
        nTmp.Next = new CNode<T>(nData, nTmp.Next);
    }

    //在指定位置插入元素
    public void Insert(int nPos, T nData)
    {
        if (nPos > GetLength() || nPos < 1)
        {
            Console.WriteLine("\t元素插入的位置不正确!");
        }

        CNode<T> nTmp = m_Head;

        while (0 != --nPos)
        {
            nTmp = nTmp.Next;
        }
        nTmp.Next = new CNode<T>(nData, nTmp.Next);
    }

    //打印链表
    public void Print()
    {
        CNode<T> nTmp = m_Head.Next;

        while (null != nTmp)
        {
            Console.Write("{0} ", nTmp.Data);
            nTmp = nTmp.Next;
        }
    }

    //逆置
    //返回逆置后的链表
    public LinkList<T> Reverse()
    {
        LinkList<T> Lc = new LinkList<T>();
        CNode<T> nTmp = m_Head.Next;

        while (null != nTmp)
        {
            if (Lc.GetLength() == 0)
            {
                Lc.Append(nTmp.Data);
            }
            else
            {
                Lc.Insert(1, nTmp.Data);
            }
            nTmp = nTmp.Next;
        }

        return Lc;
    }
}

class App
{
    public static void Main()
    {
        LinkList<int> Lst = new LinkList<int>();
        int i;

        do
        {
            Console.Write("输入你要输入的元素个数:");
            i = int.Parse(Console.ReadLine());
        }
        while (i <= 0);

        while (0 != i--)
        {
            int j = int.Parse(Console.ReadLine());
            Lst.Append(j);
        }
        Console.Write("输出单链表 Lst 中的所有元素( ");
        Lst.Print();
        Console.WriteLine(").");

        //逆置
        Lst = Lst.Reverse();
        Console.Write("输出逆置后单链表 Lst 中的所有元素( ");
        Lst.Print();
        Console.WriteLine(").");
    }
}

程序代码：

/**

 * @文件名：Program.cs

 * @作  者：寒风中的细雨

 * @时  间：2012/4/28/

 * @概  述：单链表a和b,数据按升序排列，将量表合并

 */
using System;

class CNode<T>
{
    private T m_Data;//数据域
    private CNode<T> m_Next;//指向后继

    //默认构造函数
    public CNode()
    {
        m_Data = default(T);
        m_Next = null;
    }

    //带参构造函数
    public CNode(T nData, CNode<T> nNext)
    {
        m_Data = nData;
        m_Next = nNext;
    }

    //数据域属性操作
    public T Data
    {
        get { return m_Data; }
        set { m_Data = value; }
    }

    //后继域属性操作
    public CNode<T> Next
    {
        get { return m_Next; }
        set { m_Next = value; }
    }
}

interface IList<T>
{
    int GetLength();//获取链表结点个数
    void Append(T nData);//在链表的末尾添加元素
    void Insert(int nPos, T nData);//在指定位置插入元素
    void Print();//打印链表
    LinkList<T> Reverse();//逆置
}

//单链表类
class LinkList<T>:IList<T>
{
    private CNode<T> m_Head;

    //获取头结点
    public CNode<T> Head
    {
        get { return m_Head; }
        set { m_Head = value; }
    }
    //构造函数
    public LinkList()
    {
        //带上头结点
        m_Head = new CNode<T>();
    }
    ////获取链表的长度
    //返回值  链表的长度
    public int GetLength()
    {
        CNode<T> nTmp = m_Head.Next;
        int i = 0;
        while (null != nTmp)
        {
            ++i;
            nTmp = nTmp.Next;
        }
        return i;
    }
    //在链表的末尾添加元素
    public void Append(T nData)
    {
        CNode<T> nTmp = m_Head;
        while (null != nTmp.Next)
        {
            nTmp = nTmp.Next;
        }
        nTmp.Next = new CNode<T>(nData, nTmp.Next);
    }
    //在指定位置插入元素
    public void Insert(int nPos, T nData)
    {
        if (nPos > GetLength() || nPos < 1)
        {
            Console.WriteLine("\t元素插入的位置不正确!");
        }
        CNode<T> nTmp = m_Head;
        while (0 != --nPos)
        {
            nTmp = nTmp.Next;
        }
        nTmp.Next = new CNode<T>(nData, nTmp.Next);
    }
    //打印链表
    public void Print()
    {
        CNode<T> nTmp = m_Head.Next;
        while (null != nTmp)
        {
            Console.Write("{0} ", nTmp.Data);
            nTmp = nTmp.Next;
        }
    }
    //逆置
    //返回逆置后的链表
    public LinkList<T> Reverse()
    {
        LinkList<T> Lc = new LinkList<T>();
        CNode<T> nTmp = m_Head.Next;
        while (null != nTmp)
        {
            if (Lc.GetLength() == 0)
            {
                Lc.Append(nTmp.Data);
            }
            else
            {
                Lc.Insert(1, nTmp.Data);
            }
            nTmp = nTmp.Next;
        }
        return Lc;
    }
}

class App
{
    public static void Main()
    {
        LinkList<int> aLst = new LinkList<int>();
        LinkList<int> bLst = new LinkList<int>();
        int i;

        do
        {
            Console.Write("输入你要输入的aLst元素个数:");
            i = int.Parse(Console.ReadLine());
        }
        while (i <= 0);
        while (0 != i--)
        {
            int j = int.Parse(Console.ReadLine());
            aLst.Append(j);
        }
        Console.Write("输出单链表 aLst 中的所有元素( ");
        aLst.Print();
        Console.WriteLine(").");

        do
        {
            Console.Write("输入你要输入的bLst元素个数:");
            i = int.Parse(Console.ReadLine());
        }
        while (i <= 0);
        while (0 != i--)
        {
            int j = int.Parse(Console.ReadLine());
            bLst.Append(j);
        }
        Console.Write("输出单链表 bLst 中的所有元素( ");
        bLst.Print();
        Console.WriteLine(").");

        LinkList<int> cLst = Merge(aLst, bLst, true);
      
        Console.Write("输出升序合并后单链表 cLst 中的所有元素( ");
        cLst.Print();
        Console.WriteLine(").");
    }
    //排序
    // nFlag true 升序
    //       fase 降序
    static void Sort(LinkList<int> nList, bool nFlag)
    {
        int Length = nList.GetLength();
        if (Length <= 0)
        {
            return;
        }
        //冒泡升序
        while (0 != --Length)
        {
            CNode<int> node = nList.Head;
            int i = Length;
            while (null!=node && 0!=i--)
            {
                if (node.Next.Data > node.Next.Next.Data)
                {
                    CNode<int> tmp = node.Next.Next;
                    node.Next.Next = tmp.Next;
                    tmp.Next = node.Next;
                    node.Next = tmp;
                }
                node = node.Next;
            }
        }
        if (false == nFlag)
        {
            nList = nList.Reverse();
        }
    }
    //合并aList 和 bList 表
    static LinkList<int> Merge(LinkList<int> aList, LinkList<int> bList, bool nFlag)
    {
        Sort(aList, nFlag);
        Sort(bList, nFlag);
        CNode<int> Ta = aList.Head.Next;
        CNode<int> Tb = bList.Head.Next;
        LinkList<int> cList = new LinkList<int>();
        while (null != Ta && null != Tb)
        {
            if (Ta.Data > Tb.Data)
            {
                cList.Append(Tb.Data);
                Tb = Tb.Next;
            }
            else
            {
                cList.Append(Ta.Data);
                Ta = Ta.Next;
            }
        }
        while (null != Ta)
        {
            cList.Append(Ta.Data);
            Ta = Ta.Next;
        }
        while (null != Tb)
        {
            cList.Append(Tb.Data);
            Tb = Tb.Next;
        }
        return cList;
    }
}

输入你要输入的aLst元素个数:5
12
3
6
90
10
输出单链表 aLst 中的所有元素( 12 3 6 90 10 ).
输入你要输入的bLst元素个数:3
34
9
23
输出单链表 bLst 中的所有元素( 34 9 23 ).
输出升序合并后单链表 cLst 中的所有元素( 3 6 9 10 12 23 34 90 ).
请按任意键继续. . .

程序代码：

/**

 * @文件名：Program.cs

 * @作  者：寒风中的细雨

 * @时  间：2012/4/29/

 * @概  述：单循环链表实现约瑟夫环

 */
using System;

class CNode<T>
{
    private T m_Data;//数据域
    private CNode<T> m_Next;//指向后继

    //默认构造函数
    public CNode()
    {
        m_Data = default(T);
        m_Next = null;
    }

    //带参构造函数
    public CNode(T nData, CNode<T> nNext)
    {
        m_Data = nData;
        m_Next = nNext;
    }

    //数据域属性操作
    public T Data
    {
        get { return m_Data; }
        set { m_Data = value; }
    }

    //后继域属性操作
    public CNode<T> Next
    {
        get { return m_Next; }
        set { m_Next = value; }
    }
}

interface IList<T>
{
    int GetLength();//获取链表结点个数
    void Append(T nData);//在链表的末尾添加元素
    void Print();//打印链表
    void Delete(int Pos);//删除
}

//单链表类
class CLinkList<T>:IList<T>
{
    private CNode<T> m_Head;

    //获取头结点
    public CNode<T> Head
    {
        get { return m_Head; }
        set { m_Head = value; }
    }

    //构造函数
    public CLinkList()
    {
        //不带头结点
        m_Head = null;
    }

    ////获取链表的长度
    //返回值  链表的长度
    public int GetLength()
    {
        if (null == m_Head)
        {
            return 0;
        }
        CNode<T> nTmp = m_Head.Next;
        int i = 1;
        while (nTmp != m_Head)
        {
            ++i;
            nTmp = nTmp.Next;
        }
        return i;
    }

    //在链表的末尾添加元素
    public void Append(T nData)
    {
        int nLen = GetLength();
        if (0 == nLen)
        {
            m_Head = new CNode<T>(nData, null);
            m_Head.Next = m_Head;
            return;
        }
        CNode<T> nTmp = m_Head;
        while (0 != --nLen)
        {
            nTmp = nTmp.Next;
        }
        nTmp.Next = new CNode<T>(nData, nTmp.Next);
    }

    //打印链表
    public void Print()
    {
        int nLen = GetLength();
        if (0 == nLen)
        {
            return;
        }
        CNode<T> nTmp = m_Head;
        Console.Write("{0} ", nTmp.Data);
        nTmp = nTmp.Next;
        while (nTmp != m_Head)
        {
            Console.Write("{0} ", nTmp.Data);
            nTmp = nTmp.Next;
        }
    }
    //删除指定位置
    public void Delete(int Pos)
    {
        int i = GetLength();
        if (i == 1)
        {//长度只有1
            Console.Write("{0} ", m_Head.Data);
            m_Head = null;
            return;
        }
      
        //长度大于1
        if (1 == Pos)
        {
            Console.Write("{0} ", m_Head.Data);
            CNode<T> nTmp = m_Head;
            while (m_Head != nTmp.Next)
            {
                nTmp = nTmp.Next;
            }
            nTmp.Next = m_Head = m_Head.Next;
        }
        else
        {
            CNode<T> nTmp = m_Head;
            --Pos;
            while (0 != --Pos)
            {
                nTmp = nTmp.Next;
            }
            Console.Write("{0} ", nTmp.Next.Data);
            nTmp.Next = nTmp.Next.Next;
        }
    }
}

class App
{
    public static void Main()
    {
        CLinkList<int> CList = new CLinkList<int>();
        Console.Write("输入元素个数：");
        int i = int.Parse(Console.ReadLine());
        for (int j = 1; j <= i; ++j)
        {
            CList.Append(j);
        }
        Console.Write("输出 CList 中的元素( ");
        CList.Print();
        Console.WriteLine(").");
        Console.Write("起始位置：");
        int nStart = int.Parse(Console.ReadLine());
        Console.Write("间隔：");
        int nOffset = int.Parse(Console.ReadLine());

        while (0 != CList.GetLength())
        {
            nStart = (nStart-1) % CList.GetLength() + 1;
            CList.Delete(nStart);
            nStart += nOffset;
        }
        Console.WriteLine();
    }
}

输入元素个数：10
输出 CList 中的元素( 1 2 3 4 5 6 7 8 9 10 ).
起始位置：1
间隔：2
1 4 7 10 5 9 6 3 8 2
请按任意键继续. . .

程序代码：

/**

 * @文件名：Program.cs

 * @作  者：寒风中的细雨

 * @时  间：2012/4/30/

 * @概  述：双循环链表实现约瑟夫环

 */
using System;

class CNode<T>
{
    private T m_Data;//数据域
    private CNode<T> m_Next;//指向后继
    private CNode<T> m_Prev;//指向前驱

    //默认构造函数
    public CNode()
    {
        m_Data = default(T);
        m_Prev = m_Next = null;
    }

    //带参构造函数
    public CNode(T nData, CNode<T> nNext, CNode<T> nPrev)
    {
        m_Data = nData;
        m_Next = nNext;//后继赋值给后继
        m_Prev = nPrev;//前驱赋值给前驱
    }

    //数据域属性操作
    public T Data
    {
        get { return m_Data; }
        set { m_Data = value; }
    }

    //后继域属性操作
    public CNode<T> Next
    {
        get { return m_Next; }
        set { m_Next = value; }
    }

    //前驱域属性操作
    public CNode<T> Prev
    {
        get { return m_Prev; }
        set { m_Prev = value; }
    }
}

interface IList<T>
{
    int GetLength();//获取链表结点个数
    void Append(T nData);//在链表的末尾添加元素
    void Print();//打印链表
    void Delete(int Pos);//删除
}

//单链表类
class CLinkList<T>:IList<T>
{
    private CNode<T> m_Head;

    //获取头结点
    public CNode<T> Head
    {
        get { return m_Head; }
        set { m_Head = value; }
    }

    //构造函数
    public CLinkList()
    {
        //不带头结点
        m_Head = null;
    }

    ////获取链表的长度
    //返回值  链表的长度
    public int GetLength()
    {
        if (null == m_Head)
        {
            return 0;
        }
        CNode<T> nTmp = m_Head.Next;
        int i = 1;
        while (nTmp != m_Head)
        {
            ++i;
            nTmp = nTmp.Next;
        }
        return i;
    }

    //在链表的末尾添加元素
    public void Append(T nData)
    {
        int nLen = GetLength();
        if (0 == nLen)
        {
            m_Head = new CNode<T>(nData, null, null);
            m_Head.Prev = m_Head.Next = m_Head;
            return;
        }
        CNode<T> nPrev = m_Head.Prev;
        nPrev.Next = m_Head.Prev = new CNode<T>(nData, m_Head, nPrev);
    }

    //打印链表
    public void Print()
    {
        int nLen = GetLength();
        if (0 == nLen)
        {
            return;
        }
        CNode<T> nTmp = m_Head;
        Console.Write("{0} ", nTmp.Data);
        nTmp = nTmp.Next;
        while (nTmp != m_Head)
        {
            Console.Write("{0} ", nTmp.Data);
            nTmp = nTmp.Next;
        }
    }

    //删除指定位置
    public void Delete(int Pos)
    {
        int i = GetLength();
        if (i == 1)
        {//长度只有1
            Console.Write("{0} ", m_Head.Data);
            m_Head = null;
            return;
        }
        CNode<T> nPrev;
        CNode<T> nNext;
        //长度大于1
        if (1 == Pos)
        {
            Console.Write("{0} ", m_Head.Data);
            nPrev = m_Head.Prev;
            nNext = m_Head.Next;
            m_Head = nNext;
        }
        else
        {
            CNode<T> nTmp = m_Head;
            while (0 != --Pos)
            {
                nTmp = nTmp.Next;
            }
            Console.Write("{0} ", nTmp.Data);
            nPrev = nTmp.Prev;
            nNext = nTmp.Next;
        }
        nPrev.Next = nNext;
        nNext.Prev = nPrev;
    }
}

class App
{
    public static void Main()
    {
        CLinkList<int> CList = new CLinkList<int>();
        Console.Write("输入元素个数：");
        int i = int.Parse(Console.ReadLine());
        for (int j = 1; j <= i; ++j)
        {
            CList.Append(j);
        }
        Console.Write("输出 CList 中的元素( ");
        CList.Print();
        Console.WriteLine(").");

        Console.Write("起始位置：");
        int nStart = int.Parse(Console.ReadLine());
        Console.Write("间隔：");
        int nOffset = int.Parse(Console.ReadLine());

        while (0 != CList.GetLength())
        {
            nStart = (nStart-1) % CList.GetLength() + 1;
            CList.Delete(nStart);
            nStart += nOffset;
        }
        Console.WriteLine();
    }
}

输入元素个数：10
输出 CList 中的元素( 1 2 3 4 5 6 7 8 9 10 ).
起始位置：3
间隔：3
3 7 1 6 2 9 8 10 5 4
请按任意键继续. . .