数据结构和算法——线性表

顺序存储结构

Array

• 引用类型（托管堆）
• 初始化时需要设置默认值
• 实现自己的ArrayList

  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  
  namespace ConsoleAppMyArrayList
  {
      public class MyArrayList
      {
          //容量
          private const int _defaultCapacity = 4;
          //存放数组元素
          private object[] _items;
          //数组大小
          private int _size;
          //元素个数为0的数组状态
          private static readonly object[] emptyArray = new object[0];
  
          public MyArrayList()
          {
              this._items = emptyArray;
          }
  
          public MyArrayList( int capacity)
          {
              if (capacity<0)
              {
                  throw new ArgumentOutOfRangeException(nameof(capacity),"ArrayList的容量不可为负数！");
              }
              this._items = new object[capacity];
          }
  
          //索引器
          public virtual object this[int index]
          {
              get 
              {
                  if (index<0||index>=this._size)
                  {
                      throw new ArgumentOutOfRangeException(nameof(index),"索引超出范围！");
                  }
                  return this._items[index];
              }
  
              set 
              {
                  if (index < 0 || index >= this._size)
                  {
                      throw new ArgumentOutOfRangeException(nameof(index), "索引超出范围！");
                  }
                  this._items[index] = value;
              }
  
          }
  
          //当前数组元素个数
          public virtual int Count
          {
              get {return this._size ;}
          }
  
          //数组的容量
          public virtual int Capacity
          {
              get { return this._items.Length; }
              set 
              {
                  if (value!=this._items.Length)
                  {
                      if (value<this._size)
                      {
                          throw new ArgumentOutOfRangeException(nameof(value),"容量太小");
                      }
                      if (value > 0)
                      {//开辟新内存空间存储元素
                          object[] dest = new object[value];
                          if (this._size > 0)
                          {//搬动元素
                              Array.Copy(this._items, 0, dest, 0, this._size);
                          }
                          this._items = dest;
                      }
                      else//数组最小的空间为4
                      {
                          this._items=new object[_defaultCapacity]; 
                      } 
                  }
              }
          }
  
          //元素的添加
          public virtual int Add(object value)
          {//当空间已满
              if (this._size==this._items.Length)
              {
                  this.EnsureCapacity(this._size+1);
              }
              this._items[this._size] = value;
              return this._size++;
          }
  
          //扩容
          private void EnsureCapacity(int p)
          {
              if (this._items.Length<p)
              {//空间加倍
                  int num = (this._items.Length == 0) ? _defaultCapacity : (this._items.Length * 2);
                  if (num < p)
                  {
                      num = p;
                  }
                  this.Capacity = num;
              } 
          }
  
          //指定位置插入元素
          public virtual void Insert( int index,object value)
          {
              if (index<0||index>this._size)
              {
                  throw new ArgumentOutOfRangeException(nameof(index),"索引超出范围！");
              }
              if (this._size==this._items.Length)
              {
                  this.EnsureCapacity(this._size + 1);
              }
              if (index<this._size)
              {
                  Array.Copy(this._items, index, this._items, index + 1, this._size - index);
              }
              this._items[index] = value;
              this._size++;
          } 
  
          //移除指定索引的元素
          public virtual void Remove(int index)
          {
              if (index < 0 || index > this._size)
              {
                  throw new ArgumentOutOfRangeException(nameof(index), "索引超出范围！");
              }
              this._size--;
              if (index<this._size)
              {
                  Array.Copy(this._items,index+1,this._items,index,this._size-index);
              }
              this._items[this._size]=null; 
          }
  
          //裁剪空间
          public virtual void TrimToSize()
          {
              this.Capacity = this._size;
          }
      }
  }

链式存储结构

链表

1. 单向链表

2. 循环链表

   • 实现自己的循环链表

     using System;
     
     namespace ConsoleAppLinked
     {
         class CirculLinkedList
         {
             //元素个数
             private int count;
     
             //尾指针
             private Node tail;
     
             //当前节点的前节点
             private Node CurrPrev;
     
     
             //增加元素
             public void Add(object value)
             {
                 Node newNode = new Node(value);
                 if (tail==null)
                 {//链表为空
                     tail = newNode;
                     tail.next = newNode;
                     CurrPrev = newNode;
                 }
                 else
                 {//链表不为空，把元素增加到链表结尾
                     newNode.next = tail.next;
                     tail.next = newNode;
     
                     if (CurrPrev==tail)
                     {
                         CurrPrev = newNode;
                     }
                     tail = newNode;
                 }
                 count++;
             }
     
             //删除当前元素
             public void RemoveCurrNode()
             {
                 //为null代表为空表
                 if (tail == null) 
                 {
                     throw new NullReferenceException("集合中没有任何元素！");
                 }
                 else if (count==1)
                 {
                     tail = null;
                     CurrPrev = null;
                 }
                 else
                 {
                     if (CurrPrev.next==tail)
                     {
                         tail = CurrPrev;
                     }
                     CurrPrev.next = CurrPrev.next.next;
                 }
                 count--;
             }
     
             //当前节点移动步数
             public void Move(int step)
             {
                 if (step<0)
                 {
                     throw new ArgumentOutOfRangeException("step", "移动步数不可为负数！");
                 }
                 if (tail==null)
                 {
                     throw new NullReferenceException("链表为空！");
                 }
                 for (int i = 0; i < step; i++)
                 {
                     CurrPrev = CurrPrev.next;
                 }
             }
     
             //获得当前节点
             public object Current
             {
                 get {return CurrPrev.next.item ;}
             }
     
             public override string ToString()
             {
                 if (tail==null)
                 {
                     return string.Empty;
                 }
                 string s = "";
                 Node temp = tail.next;
                 for (int i = 0; i < count; i++)
                 {
                     s += temp.ToString() + "    ";
                     temp = temp.next;
                 }
                 return s;
             }
     
     
             public int Count
             {
                 get {return count ;}
             }
     
             private   class Node
             {
                 public Node(object  value)
                 {
                     item = value;
                 }
                 //放置数据
                 public object item;
                 public CirculLinkedList.Node next;
                 public override string ToString()
                 {
                     return item.ToString();
                 }
             }
         }
     }

3. 双向链表