【愚公系列】2023年11月 数据结构(五)-队列

using System;
using System.Collections;

class Program
{
    static void Main(string[] args)
    {
        Queue myQueue = new Queue();

        // 向队列中添加元素
        myQueue.Enqueue("C#");
        myQueue.Enqueue("Java");
        myQueue.Enqueue("Python");

        // 获取队列中元素的数量
        Console.WriteLine("队列中元素的数量：{0}", myQueue.Count);

        // 获取并移除队列中的第一个元素
        string firstElement = (string)myQueue.Dequeue();
        Console.WriteLine("第一个元素是：{0}", firstElement);

        // 获取队列中的第一个元素，但不移除该元素
        string peekedElement = (string)myQueue.Peek();
        Console.WriteLine("队列中的第一个元素是：{0}", peekedElement);

        // 遍历队列中的元素
        Console.WriteLine("队列中的元素：");
        foreach (string element in myQueue)
        {
            Console.WriteLine(element);
        }
    }
}

队列中元素的数量：3
第一个元素是：C#
队列中的第一个元素是：Java
队列中的元素：
Java
Python

public void Queue()
{
    var test = new ConcurrentQueue<TestModel>();//安全队列
    //var test = Channel.CreateBounded<TestModel>(int.MaxValue);//管道
    //var test = new Stack<TestModel>();//栈
    //var test = new Queue<TestModel>();//队列
    for (int i = 0; i < 1_000_000; i++)
    {
        test.Enqueue(new TestModel());
        //test.Writer.TryWrite(new TestModel()); 
        //test.Push(new TestModel());
        //test.Enqueue(new TestModel()); 
    } 
}

public void QueueIO()
{
    var test = new ConcurrentQueue<TestModel>();
    //var test = Channel.CreateBounded<TestModel>(int.MaxValue);
    //var test = new Stack<TestModel>();
    //var test = new Queue<TestModel>();
    for (int i = 0; i < 1_000_000; i++)
    {
        test.Enqueue(new TestModel());
        //test.Writer.TryWrite(new TestModel()); 
        //test.Push(new TestModel()); 
        //test.Enqueue(new TestModel()); 
    }

    for (int i = 0; i < 1_000_000; i++)
    {
        test.TryDequeue(out var _);
        //test.Reader.TryRead(out var _);
        //test.Pop();
        //test.Dequeue();
    }
}

/* 基于链表实现的队列 */
class LinkedListQueue {
	private ListNode? front, rear; // 头节点 front ，尾节点 rear
	private int queSize = 0;
	public LinkedListQueue() {
		front = null;
		rear = null;
	}
	/* 获取队列的长度 */
	public int size() {
		return queSize;
	}
	/* 判断队列是否为空 */
	public bool isEmpty() {
		return size() == 0;
	}
	/* 入队 */
	public void push(int num) {
		// 尾节点后添加 num
		ListNode node = new ListNode(num);
		// 如果队列为空，则令头、尾节点都指向该节点
		if (front == null) {
			front = node;
			rear = node;
		// 如果队列不为空，则将该节点添加到尾节点后
		} else if (rear != null) {
			rear.next = node;
			rear = node;
		}
		queSize++;
	}
	/* 出队 */
	public int pop() {
		int num = peek();
		// 删除头节点
		front = front?.next;
		queSize--;
		return num;
	}
	/* 访问队首元素 */
	public int peek() {
		if (size() == 0 || front == null)
			throw new Exception();
		return front.val;
	}
	/* 将链表转化为 Array 并返回 */
	public int[] toArray() {
		if (front == null)
			return Array.Empty<int>();
		ListNode node = front;
		int[] res = new int[size()];
		for (int i = 0; i < res.Length; i++) {
			res[i] = node.val;
			node = node.next;
		}
		return res;
	}
}

/* 基于环形数组实现的队列 */
class ArrayQueue {
	private int[] nums; // 用于存储队列元素的数组
	private int front; // 队首指针，指向队首元素
	private int queSize; // 队列长度
	public ArrayQueue(int capacity) {
		nums = new int[capacity];
		front = queSize = 0;
	}
	/* 获取队列的容量 */
	public int capacity() {
		return nums.Length;
	}
	/* 获取队列的长度 */
	public int size() {
		return queSize;
	}
	/* 判断队列是否为空 */
	public bool isEmpty() {
		return queSize == 0;
	}
	/* 入队 */
	public void push(int num) {
		if (queSize == capacity()) {
			Console.WriteLine(" 队列已满");
			return;
		}
		// 计算尾指针，指向队尾索引 + 1
		// 通过取余操作，实现 rear 越过数组尾部后回到头部
		int rear = (front + queSize) % capacity();
		// 将 num 添加至队尾
		nums[rear] = num;
		queSize++;
	}
	/* 出队 */
	public int pop() {
		int num = peek();
		// 队首指针向后移动一位，若越过尾部则返回到数组头部
		front = (front + 1) % capacity();
		queSize--;
		return num;
	}
	/* 访问队首元素 */
	public int peek() {
		if (isEmpty())
			throw new Exception();
		return nums[front];
	}
	/* 返回数组 */
	public int[] toArray() {
		// 仅转换有效长度范围内的列表元素
		int[] res = new int[queSize];
		for (int i = 0, j = front; i < queSize; i++, j++) {
			res[i] = nums[j % this.capacity()];
		}
		return res;
	}
}