Какво е опашка?
Опашки са структури от данни, които се използват за съхраняване и извличане на елементи в предварително определен ред. Това е линейна структура от данни, която прилича на стек и се придържа към FIFO (First-In, First-Out) правило. Може да се сравни със списък с чакащи или линия, където първият пристигнал човек се обслужва първи. Съществуващите компоненти се изпускат от предната част на опашка , а на гърба се добавят нови елементи.
Внедряване на опашка в Golang
Изпълнението на a опашка in Go е проста и ефективна и може да се внедри с помощта на следните четири метода.
1: Резени
В Go, a парче е динамичен масив, който може да променя размера си. За прилагане на a опашка с помощта на a парче , можем да добавим елементи на гърба на парче с помощта на вградената функция за добавяне и премахване на елементи от предната част на парче с помощта на нарязване.
Този подход е лесен за изграждане и предлага добра производителност за операции за добавяне и нарязване благодарение на вградените срезове на Go. Въпреки това, методът за нарязване, който включва копиране на елементи в нов основен масив, може да стане неефективен, ако опашка разширява и налага повтарящи се операции за премахване на опашката.
Следният код дефинира опашка реализация с помощта на срез в Go.
основен пакет
импортиране 'fmt'
основна функция ( ) {
опашка := направи ( [ ] интерфейс { } , 0 )
опашка = добавям ( опашка , 'Английски' )
опашка = добавям ( опашка , 'урду' )
опашка = добавям ( опашка , 'математика' )
ако само ( опашка ) > 0 {
вещ := опашка [ 0 ]
опашка = опашка [ 1 : ]
fmt. Println ( вещ )
}
ако само ( опашка ) == 0 {
fmt. Println ( 'Опашката е празна' )
} друго {
fmt. Println ( опашка )
}
}
Горният Go код използва срез, за да конструира директен опашка структура на данни. The добавям () функцията се използва за поставяне на елементи в опашката опашка slice и операция на slice, която премахва първоначалния елемент, се използва за изваждането им от опашката. с fmt.Println() , елементът от опашката се отпечатва. След това кодът използва само() функция, за да определи дали опашката е празна и ако е, пише „ Опашка е празен” с помощта на функцията fmt.Println().
Изход
2: Свързани списъци
Възлите, които носят стойност и указател към следващия възел в списъка, съставят свързан списък. С два указателя, единият сочещ към предната част (главата) на списъка, а другият сочещ към задната част (опашката), можем да реализираме опашка използвайки свързан списък. Премахването на елемент от опашката (изваждане от опашката) включва премахване на възела в началото на списъка, докато добавянето на елемент към опашката (поставяне в опашката) включва добавяне на нов възел в задната част на списъка.
Този метод позволява ефективни операции за поставяне в опашка и премахване от опашка, тъй като трябва да се променят само указателите на главата и опашката, за разлика от базираното на срез решение, при което елементите трябва да бъдат копирани.
Използвайте свързан списък, за да реализирате a опашка като използвате предоставения код по-долу:
основен пакетимпортиране 'fmt'
тип Node структура {
стойностен интерфейс { }
следващия * Възел
}
тип Опашка структура {
глава * Възел
опашка * Възел
}
основна функция ( ) {
опашка := и Опашка { глава : нула , опашка : нула }
нов възел := и Възел { стойност : 'Английски' , следващия : нула }
опашка. опашка = нов възел
опашка. глава = нов възел
нов възел = и Възел { стойност : 'урду' , следващия : нула }
опашка. опашка . следващия = нов възел
опашка. опашка = нов възел
нов възел = и Възел { стойност : 'математика' , следващия : нула }
опашка. опашка . следващия = нов възел
опашка. опашка = нов възел
ако опашка. глава != нула {
вещ := опашка. глава . стойност
опашка. глава = опашка. глава . следващия
fmt. Println ( вещ )
}
ако опашка. глава == нула {
fmt. Println ( 'Опашката е празна' )
}
}
Структурата Node представлява всеки елемент в опашката и съдържа две полета: поле за стойност за съхраняване на стойността на елемента и следващото поле за насочване към следващия елемент в опашката. Структурата Queue използва свойствата на главата и опашката, за да следи съответно предната и задната част на опашката. The опашка първият елемент се обозначава със свойството head, докато последният му елемент се обозначава със свойството tail.
Параметрите на главата и опашката първоначално са зададени на нула когато нов опашка се установява във функцията main(). Указателите на главата и опашката се актуализират, за да се добавят три възела към опашка със стойностите „английски“, „урду“, и „математика“. The 'Английски' т. е тогава „изваден от опашка“ (отстранен) от предната част на опашка чрез показване на неговата стойност и придвижване на показалеца на главата към следващия възел в опашка . След изваждане от опашката, ако главата стане нула, това означава, че опашката е празна и съобщението „ Опашка е празен” се отпечатва.
Изход
3: Конструкции
В Go можете да създадете персонализирана структура от данни, наречена a структура да представлява a опашка . Това структура може да има полета за съхраняване на опашка елементи и методи за добавяне и премахване на елементи, проверка дали опашката е празна и получаване на текущия размер на опашката.
Този начин за създаване на a опашка in Go предлага удобна и капсулирана реализация с лесни за използване методи, които могат да бъдат разширени и персонализирани с повече функции. Това е гъвкав подход, който позволява да се правят промени в изпълнението или да се добавят нови възможности, когато е необходимо.
Създаване на персонализиран структура с методи включва писане на допълнителен код в сравнение с другите два начина, което може да увеличи сложността. Но също така осигурява повече гъвкавост и контрол върху изпълнението на опашка .
Следващият пример показва създаването на структура от данни за представяне на a опашка в Go.
основен пакетимпортиране 'fmt'
тип Опашка структура {
елементи [ ] интерфейс { }
}
функ ( р * Опашка ) Поставете в опашка ( интерфейс на елемента { } ) {
р. елементи = добавям ( р. елементи , вещ )
}
функ ( р * Опашка ) Извадете от опашката ( ) интерфейс { } {
ако само ( р. елементи ) == 0 {
връщане нула
}
вещ := р. елементи [ 0 ]
р. елементи = р. елементи [ 1 : ]
връщане вещ
}
функ ( р * Опашка ) Празно е ( ) bool {
връщане само ( р. елементи ) == 0
}
функ ( р * Опашка ) Размер ( ) вътр {
връщане само ( р. елементи )
}
основна функция ( ) {
опашка := и Опашка { елементи : направи ( [ ] интерфейс { } , 0 ) }
опашка. Поставете в опашка ( 'Английски' )
опашка. Поставете в опашка ( 'урду' )
опашка. Поставете в опашка ( 'математика' )
вещ := опашка. Извадете от опашката ( )
fmt. Println ( вещ )
ако опашка. Празно е ( ) {
fmt. Println ( 'Опашката е празна' )
}
размер := опашка. Размер ( )
fmt. Println ( 'Размер на опашката:' , размер )
}
В горния код елемент се добавя към среза на елемента чрез Поставяне на опашка() метод, който го премества в края на опашка . Следвайки Първи влязъл, първи излязъл (FIFO) принцип, на Извади от опашката() метод изважда елемент от предната част на опашка и го връща. Дължината на среза на елемента се проверява като част от Празно е() проверка на метода, за да видите дали опашка празно е. Като връща дължината на среза на елементите, размер() метод връща текущия опашка размер.
Функцията main() използва Структура на опашка за създаване на нов опашка , добавете елементи към него, премахнете елементи от него, определете дали опашка е празен и изчислете неговия размер.
Изход
4: Канали
В Go вграденият тип канал може да се използва за внедряване на a опашка структура на данни. Каналът може да бъде създаден с размер на буфера, за да се ограничи броят на елементите, които могат да бъдат поставени в опашка във всеки даден момент. За да добавите елемент към опашка , то може да бъде изпратено до канала с помощта на <- оператор, докато за премахване на елемент от опашката, той може да бъде получен от канала с помощта на същия оператор.
Този подход може да бъде доста полезен в ситуации, при които едновременният достъп до опашка се изисква, тъй като каналите по своята същност са безопасни за едновременна употреба.
Важно е да запомните, че Go каналите са въведени. Това означава, че можете да изпращате само стойности от определен тип през канал и можете да получавате само стойности от същия тип от канала.
Това е илюстрация на това как да използвате канал за изграждане на a опашка структура на данните в Go.
основен пакетимпортиране (
'fmt'
'време'
)
тип Опашка структура {
елементи chaninterface { }
}
funcNewQueue ( ) * Опашка {
р := и Опашка {
елементи : направи ( chan интерфейс { } ) ,
}
отивам q. processItems ( )
връщане р
}
функ ( р * Опашка ) processItems ( ) {
за вещ := диапазон q. елементи {
ако вещ == 'Английски' {
fmt. Println ( „Изваден от опашката:“ , вещ )
}
}
}
функ ( р * Опашка ) Поставете в опашка ( интерфейс на елемента { } ) {
р. елементи <- вещ
}
funcmain ( ) {
опашка := Нова опашка ( )
опашка. Поставете в опашка ( 'Английски' )
опашка. Поставете в опашка ( 'урду' )
опашка. Поставете в опашка ( 'математика' )
време . сън ( 2 * време . Второ )
}
Горният код създава a Структура на опашка с едно поле елементи който е канал на интерфейс{} Тип. The NewQueue() функцията създава нов екземпляр на Опашка и го инициализира „артикули“ поле с нов небуфериран канал. Той също така стартира нова горутина за обработка на елементите, добавени към опашката, използвайки processItems() функция. The processItems() функцията проверява дали полученият елемент е равен на 'Английски' и отпечатва съобщение на конзолата само за този елемент. The Поставяне на опашка() се използва за добавяне на нови елементи към опашката.
Изход
Заключение
Опашката е основна структура от данни в Go, използвана за съхраняване и извличане на елементи в определен ред. Изпълнението на a опашка в Go е безопасен за нишки, което ги прави идеален избор за внедряване на едновременност в програми. Може да се реализира с помощта на срезове, свързани списъци, структури и канали. Пълните подробности вече са предоставени в дадените по-горе указания.