C#数据结构与算法学习笔记 数组（上）

1.1 什么是动态数组

namespace DataStructure
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = new int[10];
            for (int i = 0; i < 10; i++)    //不具备自动扩容，改为15会报错
            {
                arr[i] = i;
                Console.Write(arr[i]+" ");
            }
            Console.WriteLine();

            ArrayList a = new ArrayList(10);
            for (int i = 0; i < 15; i++)    //动态扩容，10自动扩为15
            {
                a.Add(i);
                Console.Write(a[i]+" ");
            }
            Console.WriteLine();

            List<int> l = new List<int>(10);
            for (int i = 0; i < 15; i++)    //动态扩容
            {
                l.Add(i);
                Console.Write(l[i]+" ");
            }

            Console.ReadLine();
        }
    }
}

1.2 往数组中添加元素

//动态数组的代码编写
namespace DataStructure
{
    class Array1
    {
        private int[] data;     //需要一个静态数组进行元素的存储
        private int N;          //记录动态数组实际存储多少元素

        public Array1(int capacity)
        {
            data = new int[capacity];
            N = 0;
        }

        public Array1() : this(10) { }//无参构造函数,与下面等价
        //public Array1()
        //{
        //    data = new int[10];
        //    N = 0;
        //}

        public int Capacity     //访问数组的容量
        {
            get { return data.Length; }
        }
        public int Count        //访问动态数组实际存储的多少
        {
            get { return N; }
        }
        public bool IsEmpty     //判断动态数组是否为空
        {
            get { return N == 0; }  //等于0返回true，否则返回false
        }

        public void Add(int index, int e)    //要添加的位置index，要添加的元素e
        {
            if (index < 0 || index > N)
            {
                throw new ArgumentException("数组索引越界");
            }

            if (N == data.Length)
            {
                throw new ArgumentException("数组已满");
            }

            //index位置可能被占用，用for循环进行元素的挪动
            for (int i = N - 1; i >= index; i--)
            {
                data[i + 1] = data[i];
            }

            data[index] = e;
            N++;
        }

        public void AddLast(int e)
        {
            Add(N, e);
        }

        public void AddFirst(int e)
        {
            Add(0, e);
        }
    }
}

1.3 查询、修改、打印

打印：

        static void Main(string[] args)
        {
            Array1 a = new Array1(20);
            for (int i = 0; i < 10; i++)
            {
                a.AddLast(i);
            }
            Console.WriteLine(a);
            Console.Read();
        }

此处调用的是父类的一个ToString方法，输出内容不是我们想要的：

        public override string ToString()   //重写ToString方法，才能得到想要的信息
        {
            StringBuilder res = new StringBuilder();
            res.Append(string.Format("Array1:  count={0} capacity={1}\n", N, data.Length));
            res.Append("[");
            for (int i = 0; i < N; i++)
            {
                res.Append(data[i]);
                if (i!=N-1)
                {
                    res.Append(", ");
                }
            }
            res.Append("]");
            return res.ToString();
        }

对ToString方法重写后，输出为：

查询：

        public int Get(int index)
        {
            if (index < 0 || index >= N)
            {
                throw new ArgumentException("数组索引越界");
            }
            return data[index];
        }
        public int GetFirst()
        {
            return Get(0);
        }
        public int GetLast()
        {
            return Get(N - 1);
        }

修改：

        public void Set(int index,int newE)
        {
            if (index < 0 || index >= N)
            {
                throw new ArgumentException("数组索引越界");
            }
            data[index] = newE;
        }

1.4 包含、搜索、删除

包含：

        //查看是否包含元素
        public bool Contains(int e)
        {
            for (int i = 0; i < N; i++)
            {
                if (data[i]==e)
                    return true;
            }
            return false;
        }

搜索：

		//搜索
        public int IndexOf(int e)
        {
            for (int i = 0; i < N; i++)
            {
                if (data[i]==e)
                    return i;
            }
            return -1;  //作为无效数组返回
        }

删除：

        //删除
        public int RemoveAt(int index)
        {
            if (index < 0 || index >= N)
                throw new ArgumentException("数组索引越界");

            int del = data[index];  //删除前要保存一下删除的元素

            for (int i = index+1; i <= N-1; i++)
            {
                data[i - 1] = data[i];
            }
            N--;
            data[N] = default(int);

            return del;     //返回被删除元素的值
        }
        public int RemoveFirst()
        {
            return RemoveAt(0);
        }
        public int RemoveLast()
        {
            return RemoveAt(N - 1);
        }
        public void Remove(int e)   //删除特定元素
        {
            int index = IndexOf(e); //找到这个元素的索引
            if (index!= -1)
            {
                RemoveAt(index);
            }
        }