Queue

public class Node<T>
{
// 1. Made the constructor data parameter nullable to match the property if T can be null
public Node(T data)
{
Data = data;
Next = null; // 2. Explicitly initializing Next to null for clarity
}

public T Data { get; set; }

// 3. Marked Next as nullable (Node<T>?) to explicitly show it can be null at the end of the list
public Node<T>? Next { get; set; }
}

using System;
using System.Collections;
using System.Collections.Generic;

namespace SimpleAlgorithmsApp
{
public class Queue<T> : IEnumerable<T>
{
private Node<T>? head;
private Node<T>? tail;
private int count;

public void Enqueue(T data)
{
Node<T> node = new Node<T>(data);
Node<T>? tempNode = tail;
tail = node;

if (count == 0)
{
head = tail;
}
else
{
if (tempNode != null)
{
tempNode.Next = tail;
}
}
count++;
}

public T Dequeue()
{
if (count == 0 || head == null)
throw new InvalidOperationException(“Queue is empty.”);

T output = head.Data;
head = head.Next;
count–;

if (count == 0)
{
tail = null;
}

return output;
}

public T First
{
get
{
if (IsEmpty || head == null)
throw new InvalidOperationException(“Queue is empty.”);
return head.Data;
}
}

public T Last
{
get
{
if (IsEmpty || tail == null)
throw new InvalidOperationException(“Queue is empty.”);
return tail.Data;
}
}

public int Count => count;
public bool IsEmpty => count == 0;

public void Clear()
{
head = null;
tail = null;
count = 0;
}

// FIXED: Replaced manual null checks with type-safe EqualityComparer
public bool Contains(T data)
{
Node<T>? current = head;
EqualityComparer<T> comparer = EqualityComparer<T>.Default;

while (current != null)
{
if (comparer.Equals(current.Data, data))
return true;

current = current.Next;
}
return false;
}

IEnumerator IEnumerable.GetEnumerator()
{
return this.GetEnumerator();
}

public IEnumerator<T> GetEnumerator()
{
Node<T>? current = head;
while (current != null)
{
yield return current.Data;
current = current.Next;
}
}
}
}

public void Enqueue(T data)
{
Node<T> node = new Node<T>(data);

if (head == null)
{
// If the queue is empty, the new node is both the head and the tail
head = node;
tail = node;
}
else
{
// If the queue has items, link the current tail to the new node,
// then update the tail pointer.
tail!.Next = node;
tail = node;
}

count++;
}

public T Dequeue()
{
// 1. Better practice to check if the head itself is null alongside the count
if (count == 0 || head == null)
throw new InvalidOperationException(“Queue is empty.”);

T output = head.Data;
head = head.Next;
count–;

// FIXED: Prevent state desynchronization / memory leak
if (count == 0)
{
tail = null;
}

return output;
}

Queue<string> queue = new Queue<string>();
queue.Enqueue(“Kate”);
queue.Enqueue(“Sam”);
queue.Enqueue(“Alice”);
queue.Enqueue(“Tom”);

foreach (string item in queue)
Console.WriteLine(item);
Console.WriteLine();

string firstItem = queue.Dequeue();
Console.WriteLine($”Retrieved item: {firstItem}”);
Console.WriteLine();

foreach (string item in queue)
Console.WriteLine(item);