数据结构

数据结构

数据结构就是 数据之间的关系 逻辑结构和物理结构

顺序表(seqList):

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

 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):

 链表是由一个个的Node组成的,Node里面有两个元素 (data)和 (Node的下一个地址)
 所以链表所占用的空间比顺序表大,因为链表中的每个元素都是两个,一个是(data)一个是(Node)
 但链表比顺序表更加方便利用空间,因为顺序表的长度是固定的,
 比如:一个100容量的内存 顺序表长度是90,剩下的10 没法利用,但链表可以利用剩下的10容量,所以链表更好利用空间

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);
           
        }
    }
}

栈(FILO):

 栈属于线性表,栈分为顺序栈和链栈两种,
 关键词
 push(S,x)--->压入
 pop(S) --->弹出
 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]);

        }
    }
}

队列(FIFO):

 队列的两头限制 先进先出 一端是只能进不能出称为队头 一端是只能出不能称为队尾
 EnQueue(Q,x)入队
 DeQueue(Q)出队    队头元素不保留
 QueueEmpty(Q)判断队列空
 QueueFull(Q)判断队列满
 QueueFront(Q) 取队头元素,队头元素仍保留

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());
        }
    }
}

字典(Dictionary):
使用字典必须包含名空间System.Collection.Generic
Dictionary里面的每一个元素都是一个键值对(由二个元素组成：键和值)
键必须是唯一的,而值不需要唯一的
键和值都可以是任何类型(比如：string, int, 自定义类型，等等)
通过一个键读取一个值的时间是接近O(1)
键值对之间的偏序可以不定义
http://www.cnblogs.com/txw1958/archive/2012/11/07/csharp-dictionary.html
字典 类的介绍
遍历字典的方法
（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)
**

二叉树
左孩子右兄弟表示法
遍历顺序:前序(左下右),中序(下左右),后序(下右左)

在二叉树的第i层有至多2的(i-1)个结点
深度为K的二叉树至多有2的K次方-1个结点