List顺序表,链表.队列,栈,字典.

基础知识

顺序表就是一个数组!!! 只不过数组是被限制的 顺序表是内存地址连续的, 顺序表方便查询 追加 遍历 不适合做删除和插入 因为会频繁的进行赋值操作
顺序表有长度限制

链表 头插法,逆序,尾插法,正序

链表是由一个个Node组成的, Node里面有两个元素 data Node的下一个地址
当Node的.Next为Null的时候链表到尾部 链表是没有长度限制的 链表要时刻注意别断链

增加链表和删除链表都得找到谁? 要操作的前一个元素 链表在笔试中占有很大比例 链表简单比划 链表分为两种{带头链表和不带头的链表 一般都采用带头的 方便管理 } 若将一个数据逆置就采用在头部插入的方式 exp index = 0
若要链表数据和输入数据一致就在用尾部插入法 exp index = length
顺序表更省空间,链表浪费空间(更好的利用空间)

栈和队列都是特殊的线性表(受限线性表)
顺序栈 顺序队列 原型是顺表
链栈 链队列 原型就是链表

顺序表

MyList类

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

namespace MyList
{
    //泛型
    class MySeqList<T>
    {
        private int _flag;//实际个数
        private T[] _ints;//储存的空间,类似数组


        public MySeqList()//构造函数,赋初值
        {
            _ints = new T[30];
            _flag = 0;
        }
        public MySeqList(int count)//重载
        {
            _ints = new T[count];
            _flag = 0;
        }

        //添加
        public void AddItem(T Item)
        {
            if (_flag >= _ints.Length)
            {
                Console.WriteLine("空间溢出");
                return;
            }
            _ints[_flag] = Item;
            _flag++;
        }
        //由下标删除
        public T RemoveAt(int index)
        {
            T returnValue = default(T);
            if (index<0||index>=_flag)
            {
                Console.WriteLine("索引出界");
                goto returnTip;
            }
            returnValue = _ints[index];
            for (int i = index; i < _flag-1; i++)
            {
                _ints[i] = _ints[i + 1];
            }
            _flag--;
            returnTip:
            return returnValue;
        }
        //由数值删除,未找到返回-1
        public void Remove(T removeItem)
        {
            int tmpIndex = -1;
            for (int i = 0; i < _flag; i++)
            {
                if (_ints[i].Equals(removeItem))
                {
                    tmpIndex = i;
                    break;
                }
            }
            if (tmpIndex != -1)
            {
                RemoveAt(tmpIndex);
            }
        }
        //查找
        public int IndexOf(T Item)
        {
            int returnValue = -1;
            for (int i = 0; i < _flag; i++)
            {
                if (_ints[i].Equals(Item))
                {
                    returnValue = i;
                    break;
                }
            }
            return returnValue;
        }
        //插入
        public void Insert(int index,T Item)
        {
            if (_flag>=_ints.Length)
            {
                Console.WriteLine("溢出");
                return;
            }
            if (index > _flag || index < 0)
            {
                Console.WriteLine("索引出界");
                return;
            }
            for (int i = _flag; i >index; i--)
            {
                _ints[i] = _ints[i - 1];
               
            }
             _ints[index] = Item;
                _flag++;
        }
        //遍历
        public void ShowItem(Action<T> ac)
        {
            for (int i = 0; i < _flag; i++)
            {
                ac(_ints[i]);
            }
        }
        //清除所有
        public void Clear()
        {
            _flag = 0;
        }
        //逆序
        public void Reverse()
        {
            T n;
                for (int i = 0; i < _flag/2; i++)
                {
                    n = _ints[i];
                    _ints[i] = _ints[_flag - 1-i];
                    _ints[_flag - 1-i] = n;
                }
        }
    }
}

主类

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

namespace MyList
{
    class MyClass
    {
        public string Name;
        public MyClass(int i)
        {
            Name = "zhangsan\t" + i;
        }
    }
    class Program
    {
        static void show(MyClass my)
        {
            Console.WriteLine(my.Name);
        }
        static void Main(string[] args)
        {
            MySeqList<MyClass> intList = new MySeqList<MyClass>();
            intList.AddItem(new MyClass(1));
            intList.AddItem(new MyClass(2));
            intList.AddItem(new MyClass(3));
            intList.AddItem(new MyClass(4));
            intList.AddItem(new MyClass(5));
            intList.ShowItem(show);

            intList.Reverse();
            intList.ShowItem(show);

            //intList.ShowItem(show);
            Console.ReadLine();
        }
    }
}

链表

LinkList类

using System;

namespace 链表
{
    //一般链表都是有头部节点的 简称为头结点 头结点不参与运算
    public class LinkList
    {
        private Node _head;
        private int _count;
        
        public LinkList()
        {
            //new 对象 _head.next --> null head.data = 0
            _head = new Node();
            _count = 0;
        }

        public void AddItem(Node newNode)
        {
            //找到头结点
            Node tmpNode = _head;
            //循环找到最后结点
            while (tmpNode.Next != null)
            {
                //一直下移
                tmpNode = tmpNode.Next;
            }
//将最后结点和即将插入的结点链接
            tmpNode.Next = newNode;
            //个数++
            _count++;

        }

        public int GetLength()
        {
            return _count;
        }

        public void Insert(int index, Node newNode)
        {
            //0 
            if (index < 0 || index > _count)
            {
                Console.WriteLine("Over");
                return;
            }

            Node tmpNode = _head;
            for (int i = 0; i < index; i++)
            {
                tmpNode = tmpNode.Next;
            }
            //tmpNode? index的前一个结点
          
            newNode.Next = tmpNode.Next;
            tmpNode.Next = newNode;
            _count++;
            //0~l-1
            // l

        }


        /// <summary>
        /// 第一个就是index 第二个是value
        /// </summary>
        /// <param name="ac"></param>
        public void ShowItem(Action<int,int> ac)
        {
            if (_count == 0)
            {
                Console.WriteLine("空");
                return;
            }

            Node tmNode = _head.Next;
            for (int i = 0; i < _count; i++)
            {
                ac(i, tmNode.Data);
                //下移动
                tmNode = tmNode.Next;
            }
        }


        public int RemoveAt(int index)
        {
            //定义一个data返回值
            int returnValue = default(int);
            //判断是否出界
            if (index < 0 || index >=_count)
            {
                Console.WriteLine("error");
                goto returnTip;
            }
            //删除结点的前一个结点
            Node tmpNode = _head;
            //循环走
            for (int i = 0; i < index; i++)
            {
                tmpNode = tmpNode.Next;
            }
            //要删除的结点
            Node deleteNode = tmpNode.Next;
            //牵手删除结点的后一个结点
            tmpNode.Next = tmpNode.Next.Next;
            //不让其连接
            deleteNode.Next = null;
            //个数--
            _count--;
            //返回删除结点的数据data
            returnValue = deleteNode.Data;

            returnTip:
                return returnValue;
        }


        public void Clear()
        {
            _head.Next = null;
            _count = 0;
        }
         public void Reverse()//反转
        {
            Node T1, T2;
            T2 = _head.Next;
            _head.Next = null;
            while (T2!=null)
            {
                T1 = T2.Next;
                T2.Next = _head.Next;
                _head.Next = T2;
                T2 = T1;
            }
            
        }
        public int RemoveMin()//删除最小值
        {
            Node DelePreMin, DeleMin, preMin, min;
            DelePreMin = preMin = _head;
            DeleMin = min = _head.Next;
            while (min!=null)
            {
                if (DeleMin.Date>min.Date)
                {
                    DelePreMin = preMin;
                    DeleMin = min;
                }
                preMin = preMin.Next;
                min = min.Next;
            }
            DelePreMin.Next = DelePreMin.Next.Next;
            DeleMin.Next = null;
            _count--;
            return DeleMin.Date;
        }
      

    }
}

Node类

namespace 链表
{
    public class Node
    {
        public int Data;
        //这个就是地址
        public Node Next;

        /// <summary>
        /// 构造函数目的就是初始化
        /// </summary>
        public Node()
        {
            Data = default(int);
            Next = null;
        }
        
        public Node(int  value)
        {
            Data = value;
            Next = null;
        }
    }
}

主类

using System;

namespace 链表
{
    internal class Program
    {

        public static void Show(int index, int value)
        {
            Console.WriteLine("第{0}个元素是{1}",index+1,value);
        }

        public static void Main(string[] args)
        {
            
            LinkList linkList = new LinkList();
            linkList.AddItem(new Node(1));
            linkList.AddItem(new Node(2));
            linkList.AddItem(new Node(3));
            linkList.AddItem(new Node(4));
            linkList.AddItem(new Node(5));
          linkList.Insert(1,new Node(1000));
            //1 1000 2 3 4 5 
            linkList.Clear();
            linkList.Reverse();
            linkList.RemoveMin();

            Console.WriteLine(linkList.RemoveAt(1));
            Console.WriteLine(linkList.GetLength());
            linkList.ShowItem(Show);
           
        }
    }
}

栈,队列

栈:
压栈: push
出栈: pop
获取栈顶: peek
判断有没有:cont***

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

namespace 栈
{
    class Program
    {
        static void Main(string[] args)
        {
           Stack<int>  stack = new Stack<int>();
            //照片人脸识别
            stack.Push(10);
            stack.Push(20);
            stack.Push(30);
            stack.Push(40);
            stack.Push(50);
            stack.Push(60);
            stack.Push(70);
            stack.Push(80);
            stack.Push(90);
            stack.Push(100);
            stack.Push(110);

            //Console.WriteLine(stack.Pop());
            ;
            //遍历栈
          int[] ints=  stack.ToArray();
            Console.WriteLine(ints[0]);

        }
    }
}

队列:
入队:
出队:

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

namespace 队列
{
    class Program
    {
        static void Main(string[] args)
        {

            List<int> list = new List<int>();
            Queue<int> queue = new Queue<int>();
            queue.Enqueue(10);
            queue.Enqueue(20);
            queue.Enqueue(30);
            queue.Enqueue(40);
            queue.Enqueue(50);
            queue.Enqueue(60);
            queue.Enqueue(70);
           
            Console.WriteLine(queue.Dequeue());
        }
    }
}

字典

遍历字典的方法
（1）KeyValuePair
foreach (KeyValuePair<string, int> pair in dic)
（2）Dictionary.Values
foreach (int value in dic.Values)
（3）Dictionary.Keys
foreach (string key in dic.Keys)

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

namespace 字典
{
    class Program
    {
        static void Main(string[] args)
        {
           // //string string  固定格式
           // //name age
           // //fenshuA fenshuB
           // //GameObj Comm
           // Dictionary<string,string> userDictionary = new Dictionary<string, string>();
           // userDictionary.Add("zhangsan","1324");
           // //userDictionary.Add("zhangsan","1324");
           //// Console.WriteLine(userDictionary.Remove("lixi"));
           // //userDictionary.ContainsKey()
           // ;
           // foreach (var v in userDictionary)
           // {

           //     Console.WriteLine(v.Key);
           //     Console.WriteLine(v.Value);
           // }

           // Console.WriteLine("=========================================");

           // userDictionary["zhangsan"] = "zhangsangfeng";
           // Console.WriteLine(userDictionary["zhangsan"]);
           // //foreach (var v in userDictionary)
           // //{

           // //    Console.WriteLine(v.Key);
           // //    Console.WriteLine(v.Value);
           // //}

            //是一种类型固定的可变长数组!!!
            List<int> list = new List<int>();
            list.Add(10);//添加到末尾
           list.AddRange(new int[]{1,2,3,4,5,6,7,8,9,0}); // 添加一个数组 
            list.Remove(10000); //删除该值 


        }
    }
}