verschil tussen “Enquumue” en “Dequate”

Kan iemand alstublieft de belangrijkste verschillen uitleggen? Ik heb geen duidelijke kennis over deze functies in de programmering voor elke taal.

Antwoord 1, Autoriteit 100%

Enkele basisgegevensstructuren in programmeertalen zoals C en C++ zijn stapels en wachtrijen.

De stapelgegevensstructuur volgt het “eerste in het laatste” beleid (FILO) waar het eerste element ingevoegd of “geduwd” in een stapel is het laatste element dat is verwijderd of “gepoeld” van de stapel.

Op dezelfde manier volgt een gegevensstructuur van de wachtrij een “eerste in het eerste” beleid (zoals in het geval van een normale wachtrij wanneer we in de rij staan ​​aan de teller), waar het eerste element in de wachtrij wordt geduwd of “ingeschakeld” en hetzelfde element wanneer het uit de wachtrij moet worden verwijderd, is “depeed”.

Dit is behoorlijk vergelijkbaar met Push and Pop in een stapel, maar de voorwaarden enquue en dequoeue vermijden verwarring over de vraag of de gegevensstructuur in gebruik een stapel of een wachtrij is.

Klasse-codeers heeft een eenvoudig programma om het Enquise- en DEQUEUE-proces aan te tonen. U kunt het bekijken ter referentie.

http://classcoders.blogspot.in/ 2012/01 / Enque-and-deque-in-c.html

Antwoord 2, Autoriteit 74%

EnqueueEN dequeueDe neiging hebben om operaties op een wachtrij, een datastructuur die precies doet wat het klinkt zoals het doet.

U kunt de items aan het ene uiteinde en dequue aan de andere kantelen, net als een rij mensen die in de rij schrijft voor tickets voor het laatste Taylor Swift Concert (ik zou oorspronkelijk Billy Joel gaan zeggen, maar dat zou me ernstig zijn).

Er zijn variaties van wachtrijen zoals dubbel-eindigde waar u aan beide uiteinden kunt enquêtes en dequate, maar de overgrote meerderheid zou de eenvoudigere vorm zijn:

          +---+---+---+
enqueue -> | 3 | 2 | 1 | -> dequeue
           +---+---+---+

Dat diagram toont een wachtrij waarin je de nummers 1, 2 en 3 in die volgorde hebt geplaatst, zonder er nog een te verwijderen.

Bij wijze van voorbeeld, hier is wat Python-code die een simplistische wachtrij in actie laat zien, met functies voor enqueueen dequeue. Als het serieuzere code was, zou het als een klasse worden geïmplementeerd, maar het zou voldoende moeten zijn om de werking te illustreren:

import random
def enqueue(lst, itm):
    lst.append(itm)        # Just add item to end of list.
    return lst             # And return list (for consistency with dequeue).
def dequeue(lst):
    itm = lst[0]           # Grab the first item in list.
    lst = lst[1:]          # Change list to remove first item.
    return (itm, lst)      # Then return item and new list.
# Test harness. Start with empty queue.
myList = []
# Enqueue or dequeue a bit, with latter having probability of 10%.
for _ in range(15):
    if random.randint(0, 9) == 0 and len(myList) > 0:
        (itm, myList) = dequeue(myList)
        print(f"Dequeued {itm} to give {myList}")
    else:
        itm = 10 * random.randint(1, 9)
        myList = enqueue(myList, itm)
        print(f"Enqueued {itm} to give {myList}")
# Now dequeue remainder of list.
print("========")
while len(myList) > 0:
    (itm, myList) = dequeue(myList)
    print(f"Dequeued {itm} to give {myList}")

Een voorbeeld hiervan toont het in werking:

Enqueued 70 to give [70]
Enqueued 20 to give [70, 20]
Enqueued 40 to give [70, 20, 40]
Enqueued 50 to give [70, 20, 40, 50]
Dequeued 70 to give [20, 40, 50]
Enqueued 20 to give [20, 40, 50, 20]
Enqueued 30 to give [20, 40, 50, 20, 30]
Enqueued 20 to give [20, 40, 50, 20, 30, 20]
Enqueued 70 to give [20, 40, 50, 20, 30, 20, 70]
Enqueued 20 to give [20, 40, 50, 20, 30, 20, 70, 20]
Enqueued 20 to give [20, 40, 50, 20, 30, 20, 70, 20, 20]
Dequeued 20 to give [40, 50, 20, 30, 20, 70, 20, 20]
Enqueued 80 to give [40, 50, 20, 30, 20, 70, 20, 20, 80]
Dequeued 40 to give [50, 20, 30, 20, 70, 20, 20, 80]
Enqueued 90 to give [50, 20, 30, 20, 70, 20, 20, 80, 90]
========
Dequeued 50 to give [20, 30, 20, 70, 20, 20, 80, 90]
Dequeued 20 to give [30, 20, 70, 20, 20, 80, 90]
Dequeued 30 to give [20, 70, 20, 20, 80, 90]
Dequeued 20 to give [70, 20, 20, 80, 90]
Dequeued 70 to give [20, 20, 80, 90]
Dequeued 20 to give [20, 80, 90]
Dequeued 20 to give [80, 90]
Dequeued 80 to give [90]
Dequeued 90 to give []

Antwoord 3, Autoriteit 23%

Dit zijn voorwaarden die gewoonlijk worden gebruikt bij het beschrijven van een “FIFO” -wachtrij, dat is “eerste in, eerst uit”. Dit werkt als een lijn. Je besluit om naar de film te gaan. Er is een lange rij om tickets te kopen, je besluit om in de wachtrij te gaan om tickets te kopen, dat is “Enquumue”. Op een gegeven moment bevindt u zich aan de voorkant van de lijn, en u krijgt een ticket te kopen, op welk punt u de lijn verlaat, dat is “DEQUEUE”.

Antwoord 4, Autoriteit 7%

Een wachtrij is een bepaalde 2-zijdige gegevensstructuur. U kunt aan één kant nieuwe elementen toevoegen en elementen van de andere kant verwijderen (in tegenstelling tot een stapel die slechts één zijde heeft). Enquoue betekent om een ​​element toe te voegen, dequate om een ​​element te verwijderen. Neem een ​​kijkje hier .

Antwoord 5, Autoriteit 2%

Naar mijn mening een van de slechtgekozen woord om het proces te beschrijven, omdat het niet gerelateerd is aan alles in het echte leven of iets dergelijks. In het algemeen is het woord “QUEUE ” erg slecht alsof het wordt uitgesproken, het klinkt als het Engelse karakter “Q” . Zie hier de inefficiëntie?

Enquumue: om iets in een wachtrij te plaatsen; om een ​​element toe te voegen aan de staart van een wachtrij;

Dequeue om iets uit een wachtrij te nemen; Om het eerste beschikbare element uit het hoofd van een wachtrij te verwijderen

Bron: https://www.thefreedictionary.com

Antwoord 6, Autoriteit 2%

Enquumue Middelen om een ​​element toe te voegen, dequeue om een ​​element te verwijderen.

var stackInput= []; // First stack
var stackOutput= []; // Second stack
// For enqueue, just push the item into the first stack
function enqueue(stackInput, item) {
  return stackInput.push(item);
}
function dequeue(stackInput, stackOutput) {
  // Reverse the stack such that the first element of the output stack is the
  // last element of the input stack. After that, pop the top of the output to
  // get the first element that was ever pushed into the input stack
  if (stackOutput.length <= 0) {
    while(stackInput.length > 0) {
      var elementToOutput = stackInput.pop();
      stackOutput.push(elementToOutput);
    }
  }
  return stackOutput.pop();
}