C# 数据结构 之 线性表

数据是对客观事物的符号表示，在计算机科学中是指所有能输入到计算机中并能被计算机程序处理的符号的总称。

数据结构 是指相互之间存在一种或多种特定关系的数据元素的集合。数据结构=数据元素+关系（结构）。

通常有四类基本数据结构：

1.集合(Set)

2.线性结构(Linear Structure)

3.树形结构(Tree Structure)

4.图状结构(Graphic Structure)

数据结构 包括数据的逻辑结构和数据的物理结构

数据的逻辑结构是指送具体的模型抽象出来的数学模型，与数据在计算机中的存储没有关系。

数据的物理结构又称为数据的存储结构 是数据咋计算机中的表示和存储，包括数据元素的表示和存储以及数据元素之间关系的表示和存储。

数据的存储结构包括 顺序存储结构和链式存储结构

算法的时间复杂度：该算法的运行时间和问题规模的对应关系。T(n)=O( f(n) ).

算法的空间复杂度：该算法在运行过程中临时占用的存储空间的大小。

如果一个算法直接调用自己或间接调用自己，就称这个算法是递归的。

线性结构

线性结构的特点结构中的数据元素存在一对一的对应关系。

线性表(List)

是由n(n>=0)个相同类型的数据元素构成的有限序列。

顺序表(Sequence List)

是指用一组地址连续的存储单元依次存储线性表的数据元素。

逻辑上相邻的数据元素物理上也相邻。

链表(Linked List)

链表是用一组任意的存储单元来存储线性表中的数据元素。

链表在存储数据元素时，除了存储元素本身的信息外，还要存储与他相邻的数据元素的存储地址信息。这两部分组成该元素的存储映像，称为结点(Node).把存储数据元素本身信息的域称为结点的数据域，把存储与他相邻的数据元素的存储地址信息的域称为引用域。线性表通过结点的引用域形成一根链条。如果结点的引用域中只存储该结点直接后继的存储地址，则该链表称为单链表(Singly Linked List).把引用域称为next.     |data |next|

如果在结点中设两个引用域，一个保存直接前驱的存储地址 prev ，一个保存直接后继的存储地址 next 这种链表就是双向链表(doubly Linked List).        |prev|data|next|

循环链表是单链表的一种形式，其最后一个结点的指针不在是空，而是指向头结点，整个链表形成一个环。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DataStructure
{

    public interface ILinarList<T>
    {
        void InsertNode(T a, int i);            //插入操作
        void DeleteNode(int i);                 //删除操作
        T SearchNode(int i);                    //查找元素
        T SearchNode(T value);                  //定位元素
        int GetLength();                        //求表长度
        void Clear();                           //清空操作
        bool IsEmpty();                         //判断线性表是否为空
        //bool IsFull();                          //判断线性表是否已满
    }

    /// <summary>
    /// 顺序表
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class SeqList<T> : ILinarList<T>
    {
        private int maxsize;          //顺序表的最大容量
        private T[] data;
        private int length;           //顺序表的实际长度

        public int Length
        {
            get { return length; }
        }

        public int Maxsize
        {
            get { return maxsize; }
            set { maxsize = value; }
        }

        public T this[int index]
        {
            get { return data[index]; }
            set { data[index] = value; }
        }

        public SeqList(int size)
        {
            maxsize = size;
            data = new T[size];
            length = 0;
        }


        public void Clear()
        {
            length = 0;
        }

        public bool IsEmpty()
        {
            if (length == 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetLength()
        {
            return length;
        }

        public bool IsFull()
        {
            if (length == maxsize)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public void InsertNode(T a)
        {
            if (IsFull())
            {
                Console.WriteLine("List is Full !");
                return;
            }
            data[length] = a;
            length++;
        }

        //在第i个数据元素的位置插入一个数据
        public void InsertNode(T a, int i)
        {
            if (IsFull())
            {
                Console.WriteLine("List is Full !");
                return;
            }
            if (i < 1 || i > length + 1)
            {
                Console.WriteLine("Postion is Error !");
                return;
            }
            else
            {
                for (int j = length - 1; j >= i - 1; j--)
                {
                    data[j + 1] = data[j];
                }
                data[i - 1] = a;
            }
            length++;
        }

        public void DeleteNode(int i)
        {
            if (IsEmpty())
            {
                Console.WriteLine("List is Empty !");
                return;
            }
            if (i < 1 || i > length)
            {
                Console.WriteLine("Postion is Error !");
                return;
            }
            for (int j = i; j < length; j++)
            {
                data[j - 1] = data[j];
            }
            length--;
        }

        public T SearchNode(int i)
        {
            if (IsEmpty() || i < 1 || i > length)
            {
                Console.WriteLine("List is Empty or Postion is Error !");
                return default(T);
            }
            return data[i - 1];
        }

        public T SearchNode(T value)
        {
            if (IsEmpty())
            {
                Console.WriteLine("List is Empty !");
                return default(T);
            }
            int i = 0;
            for (i = 0; i < length; i++)
            {
                if (data[i].ToString().Contains(value.ToString()))
                {
                    break;
                }
            }
            if (i >= length)
                return default(T);
            return data[i];
        }
    }

    /// <summary>
    /// 自定义类型
    /// </summary>
    class StuNode
    {
        private string stu_no;
        private string stu_name;
        private int stu_score;

        public string Stu_no
        {
            get { return stu_no; }
            set { stu_no = value; }
        }

        public string Stu_name
        {
            get { return stu_name; }
            set { stu_name = value; }
        }

        public int Stu_score
        {
            get { return stu_score; }
            set { stu_score = value; }
        }

        public StuNode(string stu_no, string stu_name, int stu_score)
        {
            this.stu_no = stu_no;
            this.stu_name = stu_name;
            this.stu_score = stu_score;
        }

        public override string ToString()
        {
            return stu_no + stu_name;
        }
    }

    /// <summary>
    /// 单链表结点类
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class SNode<T>
    {
        private T data;          //数据域
        private SNode<T> next;   //应用域

        public SNode(T val, SNode<T> p)
        {
            data = val;
            next = p;
        }

        public SNode(SNode<T> p)
        {
            next = p;
        }

        public SNode(T val)
        {
            data = val;
            next = null;
        }

        public SNode()
        {
            data = default(T);
            next = null;
        }

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

        //引用域属性
        public SNode<T> Next
        {
            get { return next; }
            set { next = value; }
        }


    }

    /// <summary>
    /// 单链表
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class SLinkList<T> : ILinarList<T>
    {
        private SNode<T> start;         //单链表的头引用
        int length;                     //单链表的长度

        public SLinkList()
        {
            start = null;
        }

        //在单链表末尾追加数据元素
        public void InsertNode(T a)
        {
            if (start == null)
            {
                start = new SNode<T>(a);
                return;
            }
            SNode<T> current = start;//使current指向第一个结点

            while (current.Next != null)
            {
                //找到链表中最后一个结点(从start一直扫描到最后(即next=null))
                current = current.Next;
            }
            //使current的next字段指向新结点
            current.Next = new SNode<T>(a);
            length++;
        }

        //在单链表的第i个数据元素的位置前插入一个数据元素
        public void InsertNode(T val, int i)
        {
            SNode<T> current;
            SNode<T> previous;

            if (i < 1)
            {
                Console.WriteLine("Postion is Error !");
                return;
            }
            SNode<T> newnode = new SNode<T>(val);
            //在空链表或第一个元素前插入第一个元素
            if (i == 1)
            {
                newnode.Next = start;
                start = newnode;
                length++;
                return;
            }
            //单链表的两个元素间插入一个元素
            //使current指向第一个结点
            current = start;
            previous = null;

            int j = 1;
            while (current != null && j < i)
            {
                //使previous指向curent
                previous = current;
                //使current指向序列中的下一个结点
                current = current.Next;
                j++;
            }
            if (j == i)
            {
                previous.Next = newnode;
                newnode.Next = current;
                length++;
            }
        }

        public int GetLength()
        {
            return length;
        }

        public void Clear()
        {
            //单链表清空后，原结点占有的空间不会一直保留 由垃圾回收器回收
            start = null;
        }

        public bool IsEmpty()
        {
            if (start == null)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        //删除单链表的第i个元素
        public void DeleteNode(int i)
        {
            if (IsEmpty() || i < 1)
            {
                Console.WriteLine("Link is Empty or Positon is Error !");
                return;
            }
            SNode<T> current = start;
            if (i == 1)
            {
                start = current.Next;//使用current指向单链表中的下一个结点
                length--;
                return;
            }
            SNode<T> previous = null;
            int j = 1;
            while (current.Next != null && j < i)
            {
                previous = current;
                current = current.Next;
                j++;
            }
            if (j == i)
            {
                previous.Next = current.Next;
                current = null;
                length--;
            }
            else
            {
                Console.WriteLine("The {0}th node is no exsit ！", i);
            }
        }

        //获得单链表的第i个数据元素
        public T SearchNode(int i)
        {
            if (IsEmpty())
            {
                Console.WriteLine("Link is Empty !");
                return default(T);
            }
            SNode<T> current = start;
            int j = 1;

            while (current.Next != null && j < i)
            {
                current = current.Next;//使current指向序列中的下一个结点 直到i
                j++;
            }
            if (j == i)
            {
                return current.Data;
            }
            else
            {
                Console.WriteLine("The {0}th node is no exsit !", i);
                return default(T);
            }
        }

        //在单链表中查找值为value的数据
        public T SearchNode(T value)
        {
            if (IsEmpty())
            {
                Console.WriteLine("List is Empty !");
                return default(T);
            }
            SNode<T> current = start;
            int i = 0;
            while (!current.Data.ToString().Contains(value.ToString()) && current != null)
            {
                current = current.Next;
                i++;
            }
            if (current != null)
            {
                return current.Data;
            }
            else
            {
                return default(T);
            }
        }

    }

    /// <summary>
    /// 双向链表结点类
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class DbNode<T>
    {
        private T data;          //数据域
        private DbNode<T> prev;  //前驱引用域
        private DbNode<T> next;  //后继引用域

        public DbNode(T val, DbNode<T> p)
        {
            data = val;
            next = p;
        }

        public DbNode(T val)
        {
            data = val;
            next = null;
        }

        public DbNode()
        {
            data = default(T);
            next = null;
        }

        public DbNode(DbNode<T> p)
        {
            next = p;
        }

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

        //前驱引用域属性
        public DbNode<T> Prev
        {
            get { return prev; }
            set { prev = value; }
        }

        //后继应用域属性
        public DbNode<T> Next
        {
            get { return next; }
            set { next = value; }
        }

    }

    /// <summary>
    /// 双向链表
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class DlinkList<T> : ILinarList<T>
    {
        private DbNode<T> start;       //双向列表的头引用
        private int length;            //双链表的长度

        public DlinkList()
        {
            start = null;
        }


        public int GetLength()
        {
            return length;
        }

        public void Clear()
        {
            start = null;
        }

        public bool IsEmpty()
        {
            if (start == null)
                return true;
            else
                return false;
        }

        //向双链表的末尾追加数据元素
        public void InsertNode(T a)
        {
            DbNode<T> newNode = new DbNode<T>(a);
            if (IsEmpty())
            {
                start = newNode;
                length++;
                return;
            }
            DbNode<T> current = start;

            while (current.Next != null)
            {
                current = current.Next;
            }

            current.Next = newNode;
            newNode.Prev = current;
            newNode.Next = null;
            length++;
        }

        //在双向链表的第i个数据元素的位置前插入一个数据元素
        public void InsertNode(T a, int i)
        {
            DbNode<T> current;
            DbNode<T> previous;

            if (i < 1)
            {
                Console.WriteLine("Postion is Error ！");
                return;
            }

            DbNode<T> newnode = new DbNode<T>(a);

            if (i == 1)
            {
                newnode.Next = start;
                start = newnode;
                length++;
                return;
            }

            //在双向链表的两个元素间插入一个元素
            current = start;
            previous = null;
            int j = 1;

            while (current != null && j < i)
            {
                previous = current;
                current = current.Next;
                j++;
            }
            if (j == i)
            {
                newnode.Next = current;
                newnode.Prev = previous;
                if (current !=null )
                    current.Prev = newnode; ;
                previous.Next = newnode;
                length++;

            }
        }

        //删除双向链表的第i个数据元素
        public void DeleteNode(int i)
        {
            if (IsEmpty() || i < 1)
            {
                Console.WriteLine("Link is Empty or Postion is Error !");
                return;
            }
            DbNode<T> current = start;

            if (i == 1)
            {
                start = current.Next;
                length--;
                return;
            }

            DbNode<T> previous = null;
            int j = 1;
            while (current.Next != null && j < i)
            {
                previous = current;
                current = current.Next;
                j++;
            }
            if (j == i)
            {
                previous.Next = current.Next;
                if (current.Next != null)
                    current.Next.Prev = previous;
                previous = null;
                current = null;
                length--;
            }
            else
            {
                Console.WriteLine("The {0}th node is not exist !");
            }
        }

        //获得双向链表的第i个元素
        public T SearchNode(int i)
        {
            if (IsEmpty())
            {
                Console.WriteLine("List is Empty !");
                return default(T);
            }
            DbNode<T> current = start;
            int j = 1;
            while (current.Next != null && j < i)
            {
                current = current.Next;
                j++;
            }
            if (j == i)
            {
                return current.Data;
            }
            else
            {
                Console.WriteLine("The {0}th node is not exist !");
                return default(T);
            }
        }

        //在双向链表中查找值为value的数据元素
        public T SearchNode(T value)
        {
            if (IsEmpty())
            {
                Console.WriteLine("List is Empty !");
                return default(T);
            }
            DbNode<T> current = start;

            int i = 1;
            while (!current.Data.ToString().Contains(value.ToString()) && current != null)
            {
                current = current.Next;
                i++;
            }
            if (current != null)
                return current.Data;
            else
            {
                return default(T);
            }
        }
    }

    class SeqListApp
    {
        static void Main(string[] args)
        {
            ILinarList<StuNode> stuList = null;
            Console.WriteLine("请选择存储结构的类型：1.顺序表 2.单链表 3.双链表 4.循环列表 ：");
            char selectFlag = Convert.ToChar(Console.ReadLine());
            switch (selectFlag)
            {
                case '1':
                    Console.WriteLine("请输入学生数：");
                    int maxsize = Convert.ToInt32(Console.ReadLine());
                    stuList = new SeqList<StuNode>(maxsize);
                    break;
                case '2':
                    stuList = new SLinkList<StuNode>();
                    break;
                case '3':
                    stuList = new DlinkList<StuNode>();
                    break;
                default:
                    break;
            }
            while (true)
            {
                Console.WriteLine("请输入操作选项：");
                Console.WriteLine("1.添加学生成绩");
                Console.WriteLine("2.删除学生成绩");
                Console.WriteLine("3.按姓名查询学生成绩");
                Console.WriteLine("4.按学号查询学生成绩");
                Console.WriteLine("5.按升序显示所有的学生成绩");
                Console.WriteLine("6.按降序显示所有的学生成绩");
                Console.WriteLine("7.退出");
                selectFlag = Convert.ToChar(Console.ReadLine());

                switch (selectFlag)
                {
                    /*添加学生信息*/
                    case '1':
                        {
                            char flag;
                            do
                            {
                                string stu_no;
                                string stu_name;
                                int stu_score;

                                Console.WriteLine("请输入学号：");
                                stu_no = Console.ReadLine();
                                Console.WriteLine("请输入学生姓名：");
                                stu_name = Console.ReadLine();
                                
                                Console.WriteLine("请输入学生成绩：");
                                stu_score = Convert.ToInt32(Console.ReadLine());

                                StuNode newNode = new StuNode(stu_no, stu_name, stu_score);
                                if (stuList.GetLength() == 0)
                                {
                                    stuList.InsertNode(newNode, 1);
                                }
                                else if (newNode.Stu_score > stuList.SearchNode(stuList.GetLength()).Stu_score)
                                {
                                    stuList.InsertNode(newNode, stuList.GetLength() + 1);
                                }
                                else
                                {
                                    for (int i = 1; i < stuList.GetLength(); i++)
                                    {
                                        if (newNode.Stu_score <= stuList.SearchNode(i).Stu_score)
                                        {
                                            stuList.InsertNode(newNode, i);
                                            break;
                                        }
                                    }
                                }
                                Console.WriteLine("继续输入学生信息？(Y/N)");
                                flag = Convert.ToChar(Console.ReadLine());
                            } while (flag == 'Y');
                            break;
                        }
                    /*按学号删除学生信息*/
                    case '2':
                        {
                            StuNode temp;
                            Console.WriteLine("请输入要删除的学生学号：");
                            string stu_no = Console.ReadLine();
                            for (int i = 1; i < stuList.GetLength(); i++)
                            {
                                temp = stuList.SearchNode(i);
                                if (temp.Stu_no == stu_no)
                                {
                                    stuList.DeleteNode(i);
                                    break;
                                }
                            }
                            break;
                        }
                    /*按姓名查询学生信息*/
                    case '3':
                        {
                            StuNode temp;
                            Console.WriteLine("请输入要查询的学生姓名：");
                            string stu_name = Console.ReadLine();
                            for (int i = 1; i <= stuList.GetLength(); i++)
                            {
                                temp = stuList.SearchNode(i);
                                if (temp.Stu_name == stu_name)
                                {
                                    Console.WriteLine("{0}的成绩是：{1}", stu_name, temp.Stu_score);
                                    break;
                                }
                            }
                            break;
                        }
                    /*按学号查询学生信息*/
                    case '4':
                        {
                            StuNode temp;
                            Console.WriteLine("请输入要查询的学生学号：");
                            string stu_no = Console.ReadLine();
                            for (int i = 1; i <= stuList.GetLength(); i++)
                            {
                                temp = stuList.SearchNode(i);
                                if (temp.Stu_no == stu_no)
                                {
                                    Console.WriteLine("学号为{0}的学生的成绩是：{1}", stu_no, temp.Stu_score);
                                    break;
                                }
                            }
                            break;
                        }
                    /*按升序显示所有学生的成绩*/
                    case '5':
                        {
                            StuNode temp = null;
                            for (int i = 1; i <= stuList.GetLength(); i++)
                            {
                                temp = stuList.SearchNode(i);
                                Console.WriteLine(" {0}\t{1}\t{2}", temp.Stu_no, temp.Stu_name, temp.Stu_score);
                            }
                            break;
                        }
                    case '6':
                        {
                            StuNode temp = null;
                            for (int i = stuList.GetLength(); i >= 1; i--)
                            {
                                temp = stuList.SearchNode(i);
                                Console.WriteLine(" {0}\t{1}\t{2}", temp.Stu_no, temp.Stu_name, temp.Stu_score);
                            }
                            break;
                        }
                    case '7':
                        {
                            return;
                        }
                    default:
                        break;
                }
                Console.WriteLine("按任意键继续....");
                Console.ReadLine();
            }
        }
    }
}

注：本文整理自《数据结构(C#语言版)》 清华大学出版社 ！！！

复制搜索

复制搜索

复制搜索

复制搜索