C#自定义单链表

在C#中模拟库中已存在的集合，链表LinkedList。可以做添加、插入等操作

可以先写一个链表接口，然后再去实现接口的功能

interface IList<T>
    {
        int GetLength();  //取得链表的长度
        void Clear();  //将链表清空
        bool IsEmpty();  //判断链表是否为空
        void Add(T item);  //添加元素
        void Insert(int index, T item);  //根据索引来插入元素，链表长度加一
        T Delete(int index);  //根据索引来删除元素，链表长度减一
        T this[int index] { get; }  //创建一个索引器
        T GetEle(int index);  //根据索引来得到元素
        int Locate(T value);  //根据元素值，从前往后找到对应索引
    }

再创建一个节点类（为了方便，这里直接初始化节点类的数据）

class Node<T> {
        public T data = default(T);  //该节点的数据
        public Node<T> next = null;  //节点指针
    }

实现接口功能

class LinkList<T>:IList<T> {
        private Node<T> head = null;  //链表头节点
        private int count = 0;  //默认链表长度为0

        //添加操作就是新定义一个节点，判断头节点是否为空，为空，则新节点为头节点

//否则定义一个临时节点，用while判断其指针是否为空，循环遍历链表，将新节点放在临时节点的后面

        public void Add(T item)
        {

            count++;   
            Node<T> newNode = new Node<T>();
            newNode.data = item;
            if (head == null)
            {
                head = newNode;
            }
            else
            {
                Node<T> temp = head;
                while (temp.next != null)
                {
                    temp = temp.next;
                }
                temp.next = newNode;
            }
        }

//取得链表长度，直接返回count

        public int GetLength()
        {
            return count;
        }

        public void Clear()
        {
            count=0;
            head = null;
        }

//判断链表是否为空，返回一个bool值

        public bool IsEmpty()
        {
            return count == 0;
        }

//（先写索引器方法再写插入方法，请先看索引器代码）

//插入先考虑用户输入的索引值越界情况，然后再做，定义一个新的节点，

//如果索引值为0，则新节点为头节点,否则定义一个临时变量为头节点，for循环遍历到用户输入索引值前面一位的节点，再得到当前索引节点，将新节点插入到两者之间

        public void Insert(int index, T item)
        {
            if (index < 0 || index >= count) throw new Exception("索引越界");
            else {
                count++;
                Node<T> newNode = new Node<T>();
                newNode.data = item;
                if (index == 0)
                {
                    newNode.next = head;
                    head = newNode;
                }
                else {
                    Node<T> temp = head;
                    for (int i = 1; i <= index-1; i++) {
                        temp = temp.next;
                    }
                    Node<T> preNode = temp;
                    Node<T> curNode = temp.next;
                    preNode.next = newNode;
                    newNode.next = curNode;
                }

            }
        }

//删除操作  如何索引值为零，head = head.next,否则然后再遍历到index前面一位的节点，得到index节点和其后面的一个节点

//将index-1的节点和index+1的节点连接

        public T Delete(int index)
        {
            if (index < 0) {
                throw new Exception("索引超出界限");
            }
            count--;
            Node<T> temp = new Node<T>();
            temp = head;
            if (index == 0)
            {
                head = head.next;
            }
            else
            {

//注意，从head节点遍历到index-1节点，只需要index-1次
                for (int i = 1; i <= index - 1; i++)
                {
                    temp = temp.next;
                }
                Node<T> preNode = temp;
                Node<T> curNode = temp.next;
                Node<T> nextNode = temp.next.next;
                preNode.next = nextNode;
            }

            return this[index];
        }

//索引器，根据index返回值，只需要get方法

        public T this[int index]
        {
            get { 
                Node<T> temp = new Node<T>();
                temp = head;

//注意i从1是开始遍历到index，当index=0时直接返回head的数据，其他大于零的情况，就是把temp向后移动index次
                for (int i = 1; i<=index; i++){
                    temp = temp.next;
                }
                return temp.data;
            }
        }

        public T GetEle(int index)
        {
            if (index < 0 || index >= count) throw new Exception("索引超出界限");
            else {
                return this[index];
            }
        }

        public int Locate(T value)
        {
            int targetIndex = -1;
            Node<T> temp = head;
            for (int i = 0; i < count; i++) {
                if (temp.data.Equals(value))
                {
                    targetIndex = i;
                    break;
                }
                temp = temp.next;
            }
            return targetIndex;
        }

        public void ShowAll()
        {
            Node<T> temp = head;
            while (temp != null)
            {
                Console.Write(temp.data + " ");
                temp = temp.next;
            }
            Console.WriteLine();
            Console.WriteLine("Length:"+count);
        }

//将链表反向输出，递归方法
        //public void ReverseList(Node<int> node){
        //    if (node != null) {
        //        ReverseList(node.next);
        //        Console.WriteLine(node.data);
        //    }
        //}

//将链表反向输出，将链表中数据压栈，再出栈
        public void ReverseList() {
            Stack<T> stack = new Stack<T>();
            Node<T> temp = head;
            while (temp != null) {
                stack.Push(temp.data);
                temp = temp.next;
            }
            for (int i = 0; i < count; i++) {
                Console.WriteLine(stack.Pop());
            }
        }

    }