C#数据结构与算法之队列浅析

开发 后端 算法
C#数据结构与算法之队列是什么概念呢?C#数据结构与算法之队列是如何实现的呢?那么本文就向你介绍这方面的内容。

C#数据结构与算法之队列是一种特殊的线性表,它只允许在表的前端(front)进行删除操作,而在表的后端(back)进行插入操作。进行插入操作的端称为队尾,进行删除操作的端称为队头。这也就是我们平常经常用说到的先进先出法则(FIFO),队列这种法则,在中国好久以前就开始运用了,例如粮仓管理官员,在没掌握这种法则前,仓库底部的粮食都因时间太久而坏掉了,后来有聪明人士在粮仓二边开个门,一边进仓一边出仓,这样管理就方便多了。队列中没有元素时,称为空队列。

C#数据结构与算法之队列实现的接口如下:

public interface IQueen﹤T﹥  
{  
    int Length();  
    bool IsEmpty();  
    bool IsFull();  
    void Clear();  
    void IN(T items);  
    T Out();  
    T GetFrontItem();  

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.

C#数据结构与算法之队列实现的原理与代码如下:

public class JQueen﹤T﹥ : IQueen﹤T﹥  
{  
    private int size;  
    private T[] item;  
    private int front;  
    private int back;  
 
    public JQueen()  
        : this(100)  
    {  
        size = 100;  
        item = new T[100];  
        front = back = -1;  
    }  
 
    public JQueen(int length)  
    {  
        size = length;  
        item = new T[length];  
        front = back = -1;  
    }  
 
    public T this[int index]  
    {  
        get { return item[index]; }  
        set { item[index] = value; }  
    }  
 
    public int Front  
    {  
        get { return front; }  
        set { front = value; }              
    }  
 
    public int Back  
    {  
        get { return back; }  
        set { back = value; }  
    }  
 
    public int MaxLength  
    {  
        get { return size; }  
        set { size = value; }  
    }          
 
    public int Length()  
    {  
        return (back - front + size) % size;  
    }  
 
    public bool IsEmpty()  
    {  
        return (front == back);  
    }  
 
    public bool IsFull()  
    {  
        return ((back + 1) % size == front);  
    }  
 
    public void Clear()  
    {  
        front = back = -1;  
    }  
 
    public void IN(T items)  
    {  
        if (IsFull())  
        {  
            throw new ArgumentOutOfRangeException("RangeException",
          "Queen RangeException: queen is full");  
        }  
        item[++back] = items;  
    }  
 
    public T Out()  
    {  
        T tmp = default(T);  
        if (IsEmpty())  
        {  
            throw new ArgumentOutOfRangeException("RangeException"
                 "Queen RangeException: queen is empty");  
        }  
        tmp = item[++front];  
        return tmp;  
    }  
 
    public T GetFrontItem()  
    {  
        if (IsEmpty())  
        {  
            throw new ArgumentOutOfRangeException("RangeException"
              "Queen RangeException: queen is empty");  
        }  
        return item[front + 1];  
    }  
 

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.
  • 46.
  • 47.
  • 48.
  • 49.
  • 50.
  • 51.
  • 52.
  • 53.
  • 54.
  • 55.
  • 56.
  • 57.
  • 58.
  • 59.
  • 60.
  • 61.
  • 62.
  • 63.
  • 64.
  • 65.
  • 66.
  • 67.
  • 68.
  • 69.
  • 70.
  • 71.
  • 72.
  • 73.
  • 74.
  • 75.
  • 76.
  • 77.
  • 78.
  • 79.
  • 80.
  • 81.
  • 82.
  • 83.
  • 84.
  • 85.
  • 86.
  • 87.
  • 88.
  • 89.
  • 90.
  • 91.
  • 92.
  • 93.
  • 94.
  • 95.
  • 96.
  • 97.
  • 98.
  • 99.

C#数据结构与算法之队列的测试队列代码:

public class Program  
{  
    static void Main(string[] args)  
    {  
        try 
        {  
            JQueen﹤string﹥ JQ = new JQueen﹤string﹥();  
            Console.WriteLine(JQ.IsEmpty());  //是否为空  
            Console.WriteLine(JQ.IsFull());   //是否满队  
            Console.WriteLine(JQ.MaxLength);  //初始化时队列的长度  
            Console.WriteLine(JQ.Length());     //队列元素长度  
            Console.WriteLine(JQ.Front);      //队头位置  
            Console.WriteLine(JQ.Back);       //队尾位置  
            JQ.IN("A");  //插入元素  
            JQ.IN("B");  
            JQ.IN("C");  
            JQ.IN("D");  
            Console.WriteLine(JQ.GetFrontItem());   //队头元素  
            Console.WriteLine("------元素出队后队头元素-------");  
            JQ.Out();  //出A  
            JQ.Out();   
            Console.WriteLine(JQ.GetFrontItem());   //出队二个元素后队头元素  
            Console.ReadLine();  
        }  
        catch (Exception ex)  
        {  
            Console.WriteLine(ex.Message);   //异常  
            Console.ReadLine();  
        }  
    }  

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.

C#数据结构与算法之队列程序运行结果如下:

C#数据结构与算法之队列程序运行结果

C#数据结构与算法之队列相关的内容就向你介绍到这里,希望通过C#数据结构与算法之队列的介绍使你对C#数据结构与算法有所了解。

【编辑推荐】

  1. C#二叉树遍历算法实现浅析
  2. C#算法之约瑟夫环算法浅析
  3. C#数据结构与算法之线性表浅析
  4. C#数据结构与算法之顺序表浅析
  5. C#数据结构与算法之构造线性表的类浅析
责任编辑:仲衡 来源: 博客园
相关推荐

2009-08-11 14:51:11

C#数据结构与算法

2009-08-11 14:30:32

C#数据结构与算法

2009-08-11 14:14:42

C#数据结构与算法

2009-08-11 14:36:17

C#数据结构与算法线性表

2009-08-03 17:38:12

排序算法C#数据结构

2021-03-09 06:30:32

JAVA数据结构算法

2021-07-16 07:57:34

Python数据结构

2009-08-12 18:35:17

C#数据结构

2009-08-11 09:19:52

C#选择排序C#算法

2020-12-31 05:31:01

数据结构算法

2020-10-30 09:56:59

Trie树之美

2022-09-21 07:57:33

二叉搜索树排序二叉树

2022-09-26 07:56:53

AVL算法二叉树

2011-04-11 11:23:17

队列数据结构

2011-04-11 12:48:36

队列数据结构C++

2020-10-21 14:57:04

数据结构算法图形

2021-06-11 06:10:09

Python数据结构算法

2023-03-08 08:03:09

数据结构算法归并排序

2020-12-17 10:12:33

数据结构算法队列

2020-10-12 11:48:31

算法与数据结构
点赞
收藏

51CTO技术栈公众号