算法学习（一）背包队列和栈

背包类bag

    public class My_Bag<T>
    {
        public My_Bag()
        {
            array = null;
        }
        private T[] array;
        /// <summary>
        /// 添加一个元素
        /// </summary>
        /// <param name="item"></param>
        public void Add(T item)
        {
            int size = Size();
            T[] newarray = new T[size + 1];
            for (int i = 0; i < size; i++)
            {
                newarray[i] = array[i];
            }
            newarray[size] = item;
            this.array = newarray;
        }
        /// <summary>
        /// 判断是否为空
        /// </summary>
        /// <returns></returns>
        public bool Isempty()
        {
            if (array == null)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 返回当前背包大小
        /// </summary>
        /// <returns></returns>
        public int Size()
        {
            if (array == null)
            {
                return 0;
            }
            else
            {
                return array.Length;
            }
        }
    }

队列（先进先出）

namespace ConsoleApp1
{
    /// <summary>
    /// 队列类 先进先出
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class My_Queue<T>
    {
        public My_Queue()
        {
            array = null;
        }
        private T[] array;
        /// <summary>
        /// 入队
        /// </summary>
        /// <param name="item"></param>
        public void Enqueue(T item)
        {
            int size = Size();
            T[] Newarray = new T[size + 1];
            for (int i = 0; i < size; i++)
            {
                Newarray[i] = array[i];
            }
            Newarray[size] = item;
            this.array = Newarray;
        }
        /// <summary>
        /// 出队
        /// </summary>
        /// <param name="item"></param>
        public T Ouqueue()
        {
            if (Size() == 0)
            {
                Console.WriteLine("未添加元素");
                return default(T);
            }
            else
            {
                int size = Size();
                T[] newarray = new T[size - 1];
                for (int i = 1; i < size; i++)
                {
                    newarray[i - 1] = array[i];
                }
                T num = array[0];
                this.array = newarray;
                return num;
            }
        }
        /// <summary>
        /// 删除后进的一个元素
        /// </summary>
        public void Dequeue()
        {
            if (Size() == 0)
            {
                Console.WriteLine("未添加元素");
            }
            else
            {
                int size = Size();
                T[] newarray = new T[size - 1];
                for (int i = 0; i < size - 1; i++)
                {
                    newarray[i] = array[i];
                }
                this.array = newarray;
            }
        }
        /// <summary>
        /// 判断是否为空
        /// </summary>
        /// <returns></returns>
        public bool Isempty()
        {
            if (array == null)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 获取大小的方法
        /// </summary>
        /// <returns></returns>
        public int Size()
        {
            if (array == null)
            {
                return 0;
            }
            else
            {
                return array.Length;
            }
        }
        /// <summary>
        /// 获取队列长度的属性
        /// </summary>
        public int Length
        {
            get
            {
                return Size();
            }
        }
    }
}

栈（先进后出）

namespace ConsoleApp1
{
    /// <summary>
    /// 队列类 后进先出
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class My_Stack<T>
    {
        public My_Stack()
        {
            array = null;
        }
        private T[] array;
        /// <summary>
        /// 入栈
        /// </summary>
        /// <param name="item"></param>
        public void Push(T item)
        {
            int size = Size();
            T[] newarray = new T[size + 1];
            for (int i = 0; i < size; i++)
            {
                newarray[i] = array[i];
            }
            newarray[size] = item;
            this.array = newarray;
        }
        /// <summary>
        /// 出栈
        /// </summary>
        /// <param name="item"></param>
        public T Back()
        {
            if (Size() == 0)
            {
                Console.WriteLine("未添加元素");
                return default(T);
            }
            else
            {
                int size = Size();
                T[] newarray = new T[size - 1];
                for (int i = 0; i < size - 1; i++)
                {
                    newarray[i] = array[i];
                }
                T num = array[size - 1];
                this.array = newarray;
                return num;
            }
        }
        /// <summary>
        /// 删除后进的一个元素
        /// </summary>
        public void Pop()
        {
            if (Size() == 0)
            {
                Console.WriteLine("未添加元素");
            }
            else
            {
                int size = Size();
                T[] newarray = new T[size - 1];
                for (int i = 0; i < size - 1; i++)
                {
                    newarray[i] = array[i];
                }
                this.array = newarray;
            }
        }
        /// <summary>
        /// 判断是否为空
        /// </summary>
        /// <returns></returns>
        public bool Isempty()
        {
            if (array == null)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 获取大小的方法
        /// </summary>
        /// <returns></returns>
        public int Size()
        {
            if (array == null)
            {
                return 0;
            }
            else
            {
                return array.Length;
            }
        }
        /// <summary>
        /// 获取队列长度的属性
        /// </summary>
        public int Length
        {
            get
            {
                return Size();
            }
        }
    }
}

心得：也不知道这样能不能用，但是冗余重复代码仍然有很多，下一步尝试用面向对象的特性来写。