Τι είναι η Ουρά (Queue);

Μια ουρά είναι μια δομή δεδομένων που λειτουργεί με την αρχή First In, First Out (FIFO), δηλαδή ο πρώτος που μπαίνει είναι και ο πρώτος που θα βγει. Φαντάσου μια ουρά από ανθρώπους που περιμένουν να μπουν σε ένα λεωφορείο: Ο πρώτος άνθρωπος που μπήκε στην ουρά θα είναι και ο πρώτος που θα ανέβει στο λεωφορείο. Το ίδιο συμβαίνει και με την ουρά στην προγραμματιστική λογική.

Πώς λειτουργεί η ουρά;

Σε μια ουρά μπορούμε να κάνουμε δύο βασικές ενέργειες:

  1. Enqueue: Προσθέτουμε ένα στοιχείο στο τέλος της ουράς.
  2. Dequeue: Αφαιρούμε το στοιχείο που βρίσκεται στην αρχή της ουράς.

Αυτές οι δύο ενέργειες μάς επιτρέπουν να προσθέτουμε στοιχεία στο τέλος της ουράς και να αφαιρούμε τα στοιχεία με τη σειρά που μπήκαν, ακριβώς όπως συμβαίνει και με τους ανθρώπους στην ουρά για το λεωφορείο.

Πώς να δημιουργήσεις μια ουρά στην C#;

Για να δημιουργήσεις μια ουρά στην C#, χρησιμοποιούμε την κλάση Queue<T>, όπου το T είναι ο τύπος των στοιχείων που θα έχει η ουρά (π.χ., int για ακέραιους αριθμούς ή string για συμβολοσειρές).

Ας δούμε ένα απλό παράδειγμα:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Δημιουργία μιας ουράς για ακέραιους αριθμούς
        Queue<int> queue = new Queue<int>();

        // Προσθήκη αριθμών στην ουρά (Enqueue)
        queue.Enqueue(10);
        queue.Enqueue(20);
        queue.Enqueue(30);

        // Εκτύπωση των στοιχείων της ουράς
        Console.WriteLine("Στοιχεία στην ουρά:");
        foreach (int number in queue)
        {
            Console.WriteLine(number);
        }

        // Αφαίρεση του πρώτου στοιχείου από την ουρά (Dequeue)
        int removedElement = queue.Dequeue();
        Console.WriteLine("\nΤο στοιχείο που αφαιρέθηκε είναι: " + removedElement);

        // Εκτύπωση των στοιχείων της ουράς μετά το Dequeue
        Console.WriteLine("Στοιχεία στην ουρά μετά το Dequeue:");
        foreach (int number in queue)
        {
            Console.WriteLine(number);
        }
    }
}

Αναλυτική Εξήγηση του Κώδικα:

  1. Δημιουργία Ουράς:
    • Χρησιμοποιούμε τη Queue<int> για να δημιουργήσουμε μια ουρά που αποθηκεύει ακέραιους αριθμούς.
  1. Προσθήκη Στοιχείων με Enqueue:
    • Προσθέτουμε τους αριθμούς 10, 20 και 30 στην ουρά με τη μέθοδο Enqueue(). Ο αριθμός 10 είναι ο πρώτος, και ο αριθμός 30 είναι ο τελευταίος.
  1. Αφαίρεση Στοιχείου με Dequeue:
    • Η μέθοδος Dequeue() αφαιρεί το πρώτο στοιχείο που μπήκε στην ουρά, δηλαδή το 10. Μετά από αυτό, το 20 θα είναι το πρώτο στοιχείο.

Άλλες Χρήσιμες Μέθοδοι για την Ουρά

Εκτός από τις βασικές μεθόδους Enqueue και Dequeue, η κλάση Queue<T> έχει και άλλες χρήσιμες μεθόδους:

1. Peek: Βλέπουμε το στοιχείο που βρίσκεται στην αρχή της ουράς χωρίς να το αφαιρέσουμε.

int firstElement = queue.Peek();
Console.WriteLine(“Το στοιχείο στην αρχή της ουράς είναι: ” + firstElement);

  • Peek(): Μας επιστρέφει το στοιχείο που βρίσκεται στην αρχή, αλλά δεν το αφαιρεί από την ουρά.

2. Count: Μας λέει πόσα στοιχεία υπάρχουν στην ουρά.

int count = queue.Count;
Console.WriteLine(“Η ουρά έχει ” + count + ” στοιχεία.”);

  • Count: Επιστρέφει τον αριθμό των στοιχείων που υπάρχουν αυτή τη στιγμή στην ουρά.

3. Clear: Διαγράφει όλα τα στοιχεία από την ουρά.

queue.Clear();
Console.WriteLine(“Η ουρά είναι άδεια: ” + (queue.Count == 0));

queue.Clear();
Console.WriteLine(“Η ουρά είναι άδεια: ” + (queue.Count == 0));

  • Clear(): Αδειάζει την ουρά, διαγράφοντας όλα τα στοιχεία.

Πότε χρησιμοποιούμε την ουρά;

Οι ουρές είναι εξαιρετικά χρήσιμες όταν θέλουμε να διαχειριστούμε δεδομένα με σειρά πρώτος μέσα, πρώτος έξω (FIFO). Ακολουθούν μερικά παραδείγματα:

1. Διαχείριση Ουρών Αναμονής

Όπως οι ουρές στα σούπερ μάρκετ ή στα λεωφορεία, μια ουρά μπορεί να χρησιμοποιηθεί για να διαχειριστείς αιτήματα που έρχονται με τη σειρά. Το πρώτο αίτημα που φτάνει είναι και το πρώτο που θα εξυπηρετηθεί.

2. Διαχείριση Εκτυπωτή

Όταν στέλνεις έγγραφα για εκτύπωση, αυτά αποθηκεύονται σε μια ουρά εκτύπωσης. Το πρώτο έγγραφο που μπήκε στην ουρά εκτυπώνεται πρώτο, και τα υπόλοιπα ακολουθούν με τη σειρά.

3. Προγραμματισμός Εργασιών

Στον προγραμματισμό εργασιών σε υπολογιστές, οι ουρές χρησιμοποιούνται για να διαχειριστούν οι εργασίες που περιμένουν να εκτελεστούν.

Παράδειγμα: Ουρά Αναμονής Πελατών

Ας δούμε ένα πρόγραμμα που διαχειρίζεται μια ουρά από πελάτες. Κάθε φορά που φτάνει ένας πελάτης, προστίθεται στην ουρά, και ο πρώτος πελάτης που μπήκε είναι και ο πρώτος που εξυπηρετείται.

using System;
using System.Collections.Generic;

class Program
{
static void Main()
{
Queue customers = new Queue();

    // Προσθήκη πελατών στην ουρά
    customers.Enqueue("Πελάτης 1");
    customers.Enqueue("Πελάτης 2");
    customers.Enqueue("Πελάτης 3");

    Console.WriteLine("Πελάτες στην ουρά:");

    // Εκτύπωση των πελατών
    foreach (string customer in customers)
    {
        Console.WriteLine(customer);
    }

    // Εξυπηρέτηση του πρώτου πελάτη (Dequeue)
    string servedCustomer = customers.Dequeue();
    Console.WriteLine("\nΟ πελάτης που εξυπηρετήθηκε είναι: " + servedCustomer);

    // Εκτύπωση των υπόλοιπων πελατών
    Console.WriteLine("\nΟι πελάτες που απομένουν στην ουρά:");
    foreach (string customer in customers)
    {
        Console.WriteLine(customer);
    }
}

}

Αναλυτική Εξήγηση:

  1. Δημιουργία Ουράς Πελατών: Χρησιμοποιούμε μια ουρά από συμβολοσειρές (Queue<string>) για να αποθηκεύσουμε τους πελάτες.
  2. Προσθήκη Πελατών με Enqueue: Προσθέτουμε 3 πελάτες στην ουρά: “Πελάτης 1”, “Πελάτης 2”, “Πελάτης 3”.
  3. Εξυπηρέτηση Πελάτη με Dequeue: Ο πρώτος πελάτης που μπήκε στην ουρά, “Πελάτης 1”, εξυπηρετείται πρώτος και αφαιρείται από την ουρά.
  4. Εκτύπωση των Υπολοίπων Πελατών: Αφού εξυπηρετήθηκε ο πρώτος πελάτης, βλέπουμε τους υπόλοιπους πελάτες που παραμένουν στην ουρά.

Εξαιρέσεις στην Ουρά

Αν προσπαθήσεις να αφαιρέσεις (Dequeue) ή να δεις (Peek) το πρώτο στοιχείο από μια άδεια ουρά, η C# θα σου πετάξει μια εξαίρεση (exception) τύπου InvalidOperationException.

Παράδειγμα:

Queue queue = new Queue();

try
{
int firstElement = queue.Dequeue(); // Αυτό θα προκαλέσει εξαίρεση αν η ουρά είναι άδεια
}
catch (InvalidOperationException ex)
{
Console.WriteLine(“Σφάλμα: Η ουρά είναι άδεια.”);
}

Αυτός είναι ένας τρόπος να διαχειριστείς σφάλματα όταν προσπαθείς να αλληλεπιδράσεις με μια άδεια ουρά.

Συμπέρασμα

Οι ουρές (queues) είναι μια πολύ χρήσιμη δομή δεδομένων για την αποθήκευση και διαχείριση δεδομένων με τη σειρά που έρχονται (FIFO). Μπορείς να τις χρησιμοποιήσεις για να διαχειριστείς αναμονές, αιτήματα, εργασίες, και πολλά άλλα.

Βασικές μέθοδοι που πρέπει να θυμάσαι:

  • Enqueue(): Προσθέτει ένα στοιχείο στο τέλος της ουράς.
  • Dequeue(): Αφαιρεί το στοιχείο από την αρχή της ουράς.
  • Peek(): Βλέπει το πρώτο στοιχείο της ουράς χωρίς να το αφαιρέσει.
  • Count: Επιστρέφει τον αριθμό των στοιχείων που υπάρχουν στην ουρά.
  • Clear(): Διαγράφει όλα τα στοιχεία από την ουρά.

υπάρχουν μερικά επιπλέον σημαντικά σημεία που καλό είναι να γνωρίζεις σχετικά με τις ουρές (queues) στην C#. Αυτά τα σημεία θα σε βοηθήσουν να κατανοήσεις καλύτερα τις ουρές και πώς μπορούν να χρησιμοποιηθούν σε διάφορες καταστάσεις.

1. Περιορισμοί των Ουρών (Queues)

Η βασική λειτουργία των ουρών είναι η αρχή First In, First Out (FIFO), που σημαίνει ότι το πρώτο στοιχείο που μπαίνει είναι και το πρώτο που βγαίνει. Παρόλο που αυτή η λειτουργία είναι πολύ χρήσιμη σε πολλές περιπτώσεις (όπως η διαχείριση ουρών αναμονής), υπάρχει ένας περιορισμός:

  • Δεν μπορείς να προσπελάσεις στοιχεία στη μέση της ουράς. Μπορείς μόνο να προσθέσεις στοιχεία στο τέλος (με το Enqueue) και να αφαιρέσεις από την αρχή (με το Dequeue).

2. Διαφορετικοί Τύποι Ουρών

Εκτός από την απλή ουρά (Queue<T>), υπάρχουν και άλλοι τύποι ουρών που καλύπτουν πιο ειδικές ανάγκες. Κάποιοι από αυτούς τους τύπους είναι:

1. Priority Queue (Ουρά Προτεραιότητας)

Μια Priority Queue είναι μια ουρά όπου τα στοιχεία έχουν προτεραιότητα. Αντί να εξυπηρετούνται τα στοιχεία με τη σειρά που μπήκαν (FIFO), τα στοιχεία με την υψηλότερη προτεραιότητα εξυπηρετούνται πρώτα. Δυστυχώς, η C# δεν έχει ενσωματωμένη κλάση PriorityQueue όπως άλλες γλώσσες, αλλά μπορείς να υλοποιήσεις κάτι παρόμοιο με χρήση της κλάσης SortedList ή SortedDictionary.

2. Deque (Double-Ended Queue)

Η Deque (Double-ended Queue) είναι μια ουρά όπου μπορείς να προσθέσεις και να αφαιρέσεις στοιχεία τόσο από την αρχή όσο και από το τέλος. Για να χρησιμοποιήσεις μια Deque, μπορείς να χρησιμοποιήσεις την κλάση LinkedList<T>, η οποία σου επιτρέπει να προσθέτεις και να αφαιρείς στοιχεία από την αρχή και το τέλος.

Παράδειγμα χρήσης Deque με LinkedList:

using System;
using System.Collections.Generic;

class Program
{
static void Main()
{
LinkedList deque = new LinkedList();

    // Προσθήκη στοιχείων στο τέλος
    deque.AddLast(10);
    deque.AddLast(20);

    // Προσθήκη στοιχείων στην αρχή
    deque.AddFirst(5);

    // Αφαίρεση στοιχείων από την αρχή
    deque.RemoveFirst();

    // Αφαίρεση στοιχείων από το τέλος
    deque.RemoveLast();

    Console.WriteLine("Τελικά στοιχεία στο deque:");
    foreach (var item in deque)
    {
        Console.WriteLine(item);
    }
}

}

3. Παράλληλες Ουρές (Concurrent Queues)

Αν χρησιμοποιείς ουρές σε περιβάλλοντα όπου πολλοί χρήστες ή πολλά νήματα (threads) προσπαθούν να προσθέσουν και να αφαιρέσουν στοιχεία ταυτόχρονα, θα χρειαστείς την κλάση ConcurrentQueue<T>. Αυτή η κλάση είναι σχεδιασμένη να είναι ασφαλής για χρήση σε πολυνηματικά περιβάλλοντα, εξασφαλίζοντας ότι τα στοιχεία προστίθενται και αφαιρούνται με σωστό και ασφαλή τρόπο χωρίς σφάλματα συγχρονισμού.

Παράδειγμα με ConcurrentQueue:

using System;
using System.Collections.Concurrent;

class Program
{
static void Main()
{
ConcurrentQueue queue = new ConcurrentQueue();

    // Προσθήκη στοιχείων σε πολυνηματικό περιβάλλον
    queue.Enqueue(10);
    queue.Enqueue(20);
    queue.Enqueue(30);

    // Αφαίρεση στοιχείου με ασφάλεια
    if (queue.TryDequeue(out int result))
    {
        Console.WriteLine("Το στοιχείο που αφαιρέθηκε είναι: " + result);
    }
}

}

4. Εξαιρέσεις σε Ουρές

Όπως αναφέρθηκε, αν προσπαθήσεις να αφαιρέσεις ένα στοιχείο από μια άδεια ουρά με το Dequeue() ή να δεις το πρώτο στοιχείο με το Peek(), η C# θα πετάξει μια InvalidOperationException.

Για να αποφύγεις την εξαίρεση, μπορείς να χρησιμοποιήσεις την Count ή μεθόδους όπως TryDequeue() και TryPeek(), που επιστρέφουν true αν η λειτουργία είναι επιτυχής και false αν η ουρά είναι άδεια.

Παράδειγμα με TryDequeue():

Queue queue = new Queue();

if (queue.TryDequeue(out int result))
{
Console.WriteLine(“Το στοιχείο που αφαιρέθηκε είναι: ” + result);
}
else
{
Console.WriteLine(“Η ουρά είναι άδεια.”);
}

5. Χρήσεις των Ουρών στην Πραγματική Ζωή

Οι ουρές είναι χρήσιμες σε πολλά πραγματικά σενάρια και εφαρμογές, όπως:

  • Διαχείριση ουρών πελατών: Όπως σε μια τράπεζα ή σούπερ μάρκετ, οι πελάτες εξυπηρετούνται με τη σειρά που φτάνουν.
  • Εκτυπωτές: Όταν στέλνεις έγγραφα σε έναν εκτυπωτή, αυτά αποθηκεύονται σε μια ουρά εκτύπωσης.
  • Διαχείριση διεργασιών σε λειτουργικά συστήματα: Οι εργασίες που περιμένουν να εκτελεστούν σε ένα λειτουργικό σύστημα μπορούν να αποθηκεύονται σε μια ουρά.

Συμπέρασμα

Οι ουρές (queues) είναι μια πολύ χρήσιμη δομή δεδομένων για τη διαχείριση στοιχείων με τη σειρά πρώτος μέσα, πρώτος έξω (FIFO). Αν κατανοήσεις τη βασική λειτουργία τους, μπορείς να τις χρησιμοποιήσεις σε πολλές εφαρμογές, από τη διαχείριση αιτημάτων μέχρι πολυνηματικά συστήματα.

Επιπλέον σημαντικά σημεία:

  • Υπάρχουν διαφορετικοί τύποι ουρών όπως Priority Queue και Deque για πιο σύνθετα σενάρια.
  • Αν δουλεύεις με πολλά νήματα, είναι καλύτερο να χρησιμοποιείς τη ConcurrentQueue<T> για ασφάλεια.
  • Αντί να χρησιμοποιείς Dequeue() και Peek() που μπορούν να προκαλέσουν εξαίρεση σε άδεια ουρά, μπορείς να χρησιμοποιήσεις μεθόδους όπως TryDequeue().
ασκησεις ουρεςDownload