c# 进阶 顺序存储和链式存储

using System;

namespace Lesson9_顺序存储和链式存储
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("顺序存储和链式存储");

            #region 知识点一 数据结构
            //数据结构
            //数据结构是计算机存储、组织数据的方式(规则)
            //数据结构是指相互之间存在一种或多种特定关系的数据元素的集合
            //比如自定义的一个类也可以称为一种数据结构自己定义的数据组合规则
            //不要把数据结构想的太复杂
            //简单点理解，就是人定义的存储数据和表示数据之间关系的规则而已
            //常用的数据结构(前辈总结和制定的一些经典规则)
            //数组、栈、队列、链表、树、图、堆、散列表
            #endregion

            #region 知识点二 线性表
            //线性表是一种数据结构，是由n个具有相同特性的数据元素的有限序列
            //比如数组、ArrayList、Stack、Queue、链表等等
            #endregion

            //顺序存储和链式存储是数据结构中两种存储结构
            #region 知识点三 顺序存储
            //数组、Stack、Queue、List、ArrayList —顺序存储
            //但是数组、Statck、Queue的组织规则不同而已
            //顺序存储:
            //用一组地址连续的存储单元依次存储线性表的各个数据元素
            #endregion

            #region 知识点四 链式存储
            //单向链表、双向链表、循环链表一链式存储
            //链式存储(链接存储):
            //用一组任意的存储单元存储线性表中的各个数据元素
            #endregion

            #region 知识点五 自己实现一个最简单的单向链表
            LinkNode<int> node = new LinkNode<int>(1);
            LinkNode<int> node2 = new LinkNode<int>(2);
            node.nextNode = node2;

            node2.nextNode = new LinkNode<int>(3);
            node2.nextNode.nextNode = new LinkNode<int>(4);

            LinkList<int> link = new LinkList<int>();
            link.Add(1);
            link.Add(2);
            link.Add(3);
            link.Add(4);
            link.Add(5);
            LinkNode<int> curNode = link.head;
            while (curNode != null)
            {
                Console.WriteLine(curNode.value);
                curNode = curNode.nextNode;
            }

            link.Remove(2);
            curNode = link.head;
            while (curNode != null)
            {
                Console.WriteLine(curNode.value);
                curNode = curNode.nextNode;
            }

            link.Add(99);
            curNode = link.head;
            while (curNode != null)
            {
                Console.WriteLine(curNode.value);
                curNode = curNode.nextNode;
            }
            #endregion

            Console.WriteLine("********************************");

            #region pratice-3
            DoubleLinkedList<int> dp = new DoubleLinkedList<int>();
            dp.Add(1);
            dp.Add(2);
            dp.Add(3);
            dp.Add(4);
            dp.Add(5);
            DoubleLinkedNode<int> dpNode = dp.head;
            while (dpNode != null)
            {
                Console.Write("value:" + dpNode.value);
                if (dpNode.pre != null)
                {
                    Console.Write(" pre:" + dpNode.pre.value);
                }
                Console.WriteLine();
                dpNode = dpNode.next;
            }
            Console.WriteLine("size:" + dp.size);

            Console.WriteLine("********************************");
            dp.Remove(5);
            dp.Remove(1);
            dpNode = dp.head;
            while (dpNode != null)
            {
                Console.Write("value:" + dpNode.value);
                if (dpNode.pre != null)
                {
                    Console.Write(" pre:" + dpNode.pre.value);
                }
                Console.WriteLine();
                dpNode = dpNode.next;
            }
            Console.WriteLine("size:" + dp.size);

            Console.WriteLine("********************************");
            dp.RemoveAt(1);
            dpNode = dp.head;
            while (dpNode != null)
            {
                Console.Write("value:" + dpNode.value);
                if (dpNode.pre != null)
                {
                    Console.Write(" pre:" + dpNode.pre.value);
                }
                Console.WriteLine();
                dpNode = dpNode.next;
            }
            Console.WriteLine("size:" + dp.size);
            #endregion

        }
    }
    #region 知识点五 自己实现一个最简单的单向链表

    //链表节点类
    class LinkNode<T>
    {
        public T value;
        //这个存储下一个元素，相当于钩子
        public LinkNode<T> nextNode;

        public LinkNode(){ }
        public LinkNode(T _value)
        {
            value = _value;
            nextNode = null;
        }
    }

    //单向链表类，用以管理节点
    class LinkList<T>
    {
        public LinkNode<T> head;
        public LinkNode<T> last;
        public void Add(T _value)
        {
            LinkNode<T> node = new LinkNode<T>(_value);
            if (head == null)
            {
                head = node;
                last = node;
            } else
            {
                last.nextNode = node;
                last = node;
            }
        }

        public void Remove(T _value)
        {
            if (head == null)
            {
                return;
            }
            if (head.value.Equals(_value))
            {
                head = head.nextNode;
                //如果头节点被移除发现头节点变空
                //证明只有一个节点那尾也要清空
                if (head == null)
                {
                    last = null;
                }
                return;
            }
            LinkNode<T> p = head;
            while (p.nextNode != null)
            {
                if (p.nextNode.value.Equals(_value))
                {
                    //让当前找到的这个元素的上一个节点
                    //指向自己的下一个节点
                    p.nextNode = p.nextNode.nextNode;
                    break;
                }
                p = p.nextNode;
            }
        }
    }
    #endregion

    #region 知识点六 顺序存储和链式存储的优缺点
    //从增删查改的角度去思考
    //增:链式存储计算上优于顺序存储(中间插入时链式不用像顺序一样去移动位置)
    //删:链式存储计算上优于顺序存储(中间删除时链式不用像顺序一样去移动位置)
    //查:顺序存储使用上优于链式存储(数组可以直接通过下标得到元素，链式需要遍历)
    //改:顺序存储使用上优于链式存储(数组可以直接通过下标得到元素，链式需要遍历)
    #endregion
}