迎接2012之集合和泛型(5)------队列的顺序结构基本实现

最新推荐文章于 2023-08-21 11:33:03 发布

huihuidetiantang

最新推荐文章于 2023-08-21 11:33:03 发布

阅读量243

点赞数

分类专栏：迎接2012 文章标签： object class string

本文链接：https://blog.csdn.net/huihuidetiantang/article/details/6955172

版权

迎接2012 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

一、非泛型实现

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Data;
using System.Data.SqlClient;
using System.Text.RegularExpressions;
using System.Reflection;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            Queue s = new Queue(3);
            s.EnQueue(3);
            s.EnQueue(4);
            s.EnQueue(5);
            Console.WriteLine(s.Peek());
            Console.WriteLine(s.DeQueue());
        }
    }
    /// <summary>
    /// 队列的顺序结构基本实现(非泛型)
    /// </summary>
    public class Queue
    {
        /// <summary>
        /// 存放元素的数组
        /// </summary>
        public object[] array;
        /// <summary>
        /// 元素的上标
        /// </summary>
        public int first;
        /// <summary>
        /// 元素的下标
        /// </summary>
        public int tail;
        /// <summary>
        /// 默认的构造函数
        /// </summary>
        public Queue()
        {
            this.array = new object[10];
            this.first = 0;
            this.tail = 0;
        }
        /// <summary>
        /// 构造函数重载
        /// </summary>
        /// <param name="capcity"></param>
        public Queue(int count)
        {
            this.array = new object[count];
            this.first = 0;
            this.tail = 0;
        }
        /// <summary>
        /// 元素个数
        /// </summary>
        public int count
        {
            get { return (tail - first + array.Length) % array.Length; }
        }
        /// <summary>
        /// 扩大容器
        /// </summary>
        private void Dilatation()
        {
            //将数组个数扩大为原来的两倍
            object[] newarray = new object[this.array.Length * 2];
            for (int i = 0; i < this.array.Length; i++)
            {
                newarray[i] = this.array[i];
            }
            this.array = newarray;
        }
        /// <summary>
        /// 入队
        /// </summary>
        /// <param name="obj"></param>
        public void EnQueue(object obj)
        {
            //判断是否为满，满的话扩容，最后就是添加元素
            if ((tail + 1) % array.Length == first)
            {
                Dilatation();
            }
            tail = (tail + 1) % array.Length;
            array[tail] = obj;



        }
        /// <summary>
        /// 出队
        /// </summary>
        public object DeQueue()
        {
            if (first != tail)
            {
                first = (first + 1) % array.Length;
                return array[first];
            }
            else
            {
                return "";
            }
        }
        /// <summary>
        /// 查找元素是否存在
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public bool Contains(object obj)
        {
            bool b = false;
            for (int i = 0; i < this.array.Length; i++)
            {
                if (this.array[i].Equals(obj))
                {
                    b = true;
                    break;
                }
            }
            return b;
        }
        /// <summary>
        /// 取队首
        /// </summary>
        public object Peek()
        {
            if (first != tail)
            {
                return array[(first + 1) % array.Length];
            }
            else
            {
                return "";
            }
        }
    }

}

二、泛型实现

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Data;
using System.Data.SqlClient;
using System.Text.RegularExpressions;
using System.Reflection;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            Queue<int> s = new Queue<int>(3);
            s.EnQueue(3);
            s.EnQueue(4);
            s.EnQueue(5);
            Console.WriteLine(s.Peek());
            Console.WriteLine(s.DeQueue());
        }
    }
    /// <summary>
    /// 队列的顺序结构基本实现(泛型)
    /// </summary>
    public class Queue<T>
    {
        /// <summary>
        /// 存放元素的数组
        /// </summary>
        public T[] array;
        /// <summary>
        /// 元素的上标
        /// </summary>
        public int first;
        /// <summary>
        /// 元素的下标
        /// </summary>
        public int tail;
        /// <summary>
        /// 默认的构造函数
        /// </summary>
        public Queue()
        {
            this.array = new T[10];
            this.first = 0;
            this.tail = 0;
        }
        /// <summary>
        /// 构造函数重载
        /// </summary>
        /// <param name="capcity"></param>
        public Queue(int count)
        {
            this.array = new T[count];
            this.first = 0;
            this.tail = 0;
        }
        /// <summary>
        /// 元素个数
        /// </summary>
        public int count
        {
            get { return (tail - first + array.Length) % array.Length; }
        }
        /// <summary>
        /// 扩大容器
        /// </summary>
        private void Dilatation()
        {
            //将数组个数扩大为原来的两倍
            T[] newarray = new T[this.array.Length * 2];
            for (int i = 0; i < this.array.Length; i++)
            {
                newarray[i] = this.array[i];
            }
            this.array = newarray;
        }
        /// <summary>
        /// 入队
        /// </summary>
        /// <param name="obj"></param>
        public void EnQueue(T obj)
        {
            //判断是否为满，满的话扩容，最后就是添加元素
            if ((tail + 1) % array.Length == first)
            {
                Dilatation();
            }
            tail = (tail + 1) % array.Length;
            array[tail] = obj;



        }
        /// <summary>
        /// 出队
        /// </summary>
        public T DeQueue()
        {
            if (first == tail)
            {
                Console.WriteLine("不存在");
            }
            first = (first + 1) % array.Length;
            return array[first];
        }
        /// <summary>
        /// 查找元素是否存在
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public bool Contains(T obj)
        {
            bool b = false;
            for (int i = 0; i < this.array.Length; i++)
            {
                if (this.array[i].Equals(obj))
                {
                    b = true;
                    break;
                }
            }
            return b;
        }
        /// <summary>
        /// 取队首
        /// </summary>
        public T Peek()
        {
            if (first == tail)
            {
                Console.WriteLine("不存在");
            }
            return array[(first + 1) % array.Length];
        }
    }

}