Что такое очередь в Голанге?

Cto Takoe Ocered V Golange



Go — популярный язык программирования, который славится своей эффективностью, простотой использования и адаптивностью. Благодаря богатому набору инструментов и библиотек Go предоставляет разработчикам необходимые ресурсы для создания мощных и эффективных программных приложений. Хотя в Go нет хвосты в своей стандартной библиотеке в качестве структуры данных они могут быть реализованы различными способами. Мы поговорим о понятии хвосты и как их реализовать в этом уроке.

Что такое очередь?

хвосты представляют собой структуры данных, которые используются для хранения и извлечения элементов в заданном порядке. Это линейная структура данных, напоминающая стек и придерживающаяся FIFO (первым пришел, первым ушел) правило. Его можно сравнить со списком ожидания или очередью, где первый прибывший обслуживается первым. Существующие компоненты сбрасываются с передней части очередь , а сзади добавляются новые элементы.

Реализация очереди в Golang

осуществление очередь in Go прост и эффективен и может быть реализован с использованием следующих четырех методов.







1: Ломтики

В Го, кусочек представляет собой динамический массив, размер которого может изменяться. Для реализации очередь используя кусочек , мы можем добавить элементы на обратную сторону кусочек с помощью встроенной функции добавления и удаления элементов с передней части кусочек с помощью нарезки.



Этот подход прост в реализации и обеспечивает хорошую производительность для операций добавления и нарезки благодаря встроенным в Go слайсам. Однако метод нарезки, включающий копирование элементов в новый базовый массив, может стать неэффективным, если очередь расширяется и требует повторных операций удаления из очереди.



Следующий код определяет очередь реализация с использованием слайса в Go.





основной пакет

Импортировать 'ФМТ'

основная функция ( ) {

очередь '=' делать ( [ ] интерфейс { } , 0 )

очередь '=' добавить ( очередь , 'английский' )

очередь '=' добавить ( очередь , 'урду' )

очередь '=' добавить ( очередь , 'математика' )

если только ( очередь ) > 0 {

элемент '=' очередь [ 0 ]

очередь '=' очередь [ 1 : ]

ФМТ. Распечатать ( элемент )

}

если только ( очередь ) == 0 {

ФМТ. Распечатать ( 'Очередь пуста' )

} еще {

ФМТ. Распечатать ( очередь )

}

}

Приведенный выше код Go использует срез для создания простого очередь структура данных. добавить() Функция используется для постановки элементов в очередь в очередь slice, и операция среза, которая удаляет начальный элемент, используется для их удаления из очереди. С fmt.Println() , выведенный из очереди элемент печатается. Затем код использует только() функция определяет, пуста ли очередь, и если да, то пишет « Очередь пусто», используя функцию fmt.Println().

Выход



2: Связанные списки

Узлы, несущие значение и указатель на следующий узел в списке, составляют связанный список. С двумя указателями, один из которых указывает на начало (голову) списка, а другой — на конец (хвост), мы можем реализовать очередь с помощью связанного списка. Удаление элемента из очереди (удаление из очереди) включает в себя удаление узла в начале списка, а добавление элемента в очередь (внесение в очередь) включает добавление нового узла в конец списка.

Этот метод позволяет эффективно ставить в очередь и удалять из очереди операции, поскольку необходимо изменить только указатели начала и конца, в отличие от решения на основе среза, где элементы должны быть скопированы.

Используйте связанный список для реализации очередь с помощью приведенного ниже кода:

основной пакет

Импортировать 'ФМТ'

тип узла структура {

интерфейс значения { }

следующий * Узел

}

тип Очередь структура {

голова * Узел

хвост * Узел

}

основная функция ( ) {

очередь '=' & Очередь { голова : ноль , хвост : ноль }

новый узел '=' & Узел { ценить : 'английский' , следующий : ноль }

очередь. хвост '=' новый узел

очередь. голова '=' новый узел

новый узел '=' & Узел { ценить : 'урду' , следующий : ноль }

очередь. хвост . следующий '=' новый узел

очередь. хвост '=' новый узел

новый узел '=' & Узел { ценить : 'математика' , следующий : ноль }

очередь. хвост . следующий '=' новый узел

очередь. хвост '=' новый узел

если очередь. голова '=' ноль {

элемент '=' очередь. голова . ценить

очередь. голова '=' очередь. голова . следующий

ФМТ. Распечатать ( элемент )

}

если очередь. голова == ноль {

ФМТ. Распечатать ( 'Очередь пуста' )

}

}

Структура Node представляет каждый элемент в очереди и содержит два поля: поле значения для хранения значения элемента и поле next для указания на следующий элемент в очереди. Структура Queue использует свойства head и tail для отслеживания начала и конца очереди соответственно. хвост первый элемент определяется свойством head, а последний элемент — свойством tail.

Параметры головы и хвоста изначально установлены на ноль когда новый очередь устанавливается в функции main(). Указатели начала и конца обновлены, чтобы добавить три узла к очередь со значениями «английский», «урду», и «математика». 'английский' пункт тогда «выведен из очереди» (снято) с передней части очередь путем отображения его значения и перемещения указателя заголовка к следующему узлу в очередь . После исключения из очереди, если заголовок становится нулевым, это означает, что очередь пуста, и появляется сообщение « Очередь пусто».

Выход

3: Структуры

В Go вы можете создать пользовательскую структуру данных, называемую структура представлять очередь . Этот структура может иметь поля для хранения очередь элементы и методы для добавления и удаления элементов, проверки, пуста ли очередь, и получения текущего размера очереди.

Этот способ создания очередь in Go предлагает удобную и инкапсулированную реализацию с простыми в использовании методами, которые можно расширять и настраивать с помощью дополнительных функций. Это гибкий подход, который позволяет вносить изменения в реализацию или добавлять новые возможности по мере необходимости.

Создание пользовательского структура с методами требует написания дополнительного кода по сравнению с двумя другими способами, что может увеличить сложность. Однако он также обеспечивает большую гибкость и контроль над реализацией очередь .

В следующем примере показано создание структуры данных для представления очередь в Го.

основной пакет

Импортировать 'ФМТ'

тип Очередь структура {
предметы [ ] интерфейс { }
}

функция ( д * Очередь ) поставить в очередь ( интерфейс элемента { } ) {
кв. предметы '=' добавить ( кв. предметы , элемент )
}

функция ( д * Очередь ) Удалить из очереди ( ) интерфейс { } {
если только ( кв. предметы ) == 0 {
возвращаться ноль
}
элемент '=' кв. предметы [ 0 ]
кв. предметы '=' кв. предметы [ 1 : ]
возвращаться элемент
}

функция ( д * Очередь ) Пусто ( ) логический {
возвращаться только ( кв. предметы ) == 0
}

функция ( д * Очередь ) Размер ( ) инт {
возвращаться только ( кв. предметы )
}


основная функция ( ) {

очередь '=' & Очередь { предметы : делать ( [ ] интерфейс { } , 0 ) }

очередь. поставить в очередь ( 'английский' )
очередь. поставить в очередь ( 'урду' )
очередь. поставить в очередь ( 'математика' )

элемент '=' очередь. Удалить из очереди ( )
ФМТ. Распечатать ( элемент )
если очередь. Пусто ( ) {
ФМТ. Распечатать ( 'Очередь пуста' )
}

размер '=' очередь. Размер ( )
ФМТ. Распечатать ( 'Размер очереди:' , размер )
}

В приведенном выше коде элемент добавляется к срезу элемента с помощью Ставить в очередь() метод, который перемещает его в конец очередь . После Первый пришел, первый ушел (FIFO) принцип, Удалить из очереди () Метод выводит элемент из передней части очередь и возвращает его. Длина среза элемента проверяется как часть Пусто() проверка метода, чтобы убедиться, что очередь пусто. Возвращая длину среза элементов, Размер() метод возвращает текущий хвост размер.

Функция main() использует Структура очереди создать новый очередь , добавлять в него элементы, удалять из него элементы, определять, очередь пусто, и вычислить его размер.

Выход

4: Каналы

В Go встроенный тип канала можно использовать для реализации очередь структура данных. Канал может быть создан с размером буфера, чтобы ограничить количество элементов, которые могут быть поставлены в очередь в любой момент времени. Чтобы добавить элемент в очередь , его можно отправить на канал с помощью <- оператора, а для удаления элемента из очереди его можно получить из канала с помощью того же оператора.

Этот подход может быть весьма полезен в ситуациях, когда одновременный доступ к очередь требуется, поскольку каналы по своей природе безопасны для одновременного использования.

Очень важно помнить, что каналы Go типизированы. Это означает, что через канал можно отправлять только значения определенного типа и получать из канала только значения того же типа.

Это иллюстрация того, как использовать канал для построения очередь Структура данных в Go.

основной пакет

Импортировать (
'ФМТ'
'время'
)

тип Очередь структура {
элементы интерфейса { }
}

funcNewQueue ( ) * Очередь {


д '=' & Очередь {

предметы : делать ( чан интерфейс { } ) ,
}
иди к. processItems ( )
возвращаться д
}

функция ( д * Очередь ) processItems ( ) {
для элемент '=' диапазон q. предметы {
если элемент == 'английский' {
ФМТ. Распечатать ( 'Исключен из очереди:' , элемент )
}
}
}


функция ( д * Очередь ) поставить в очередь ( интерфейс элемента { } ) {

кв. предметы <- элемент

}

функция ( ) {
очередь '=' Новая очередь ( )

очередь. поставить в очередь ( 'английский' )
очередь. поставить в очередь ( 'урду' )
очередь. поставить в очередь ( 'математика' )

время . Спать ( 2 * время . Второй )
}

Приведенный выше код создает Структура очереди с одним полем предметы который является каналом интерфейс{} тип. НоваяОчередь() функция создает новый экземпляр Очередь и инициализирует его 'предметы' поле с новым небуферизованным каналом. Он также запускает новую горутину для обработки элементов, добавленных в очередь, с помощью элементы процесса() функция. элементы процесса() функция проверяет, равен ли полученный элемент 'английский' и выводит сообщение на консоль только для этого элемента. Ставить в очередь() Функция используется для добавления новых элементов в очередь.

Выход

Заключение

Очередь — это важная структура данных в Go, используемая для хранения и извлечения элементов в определенном порядке. осуществление очередь in Go является потокобезопасным, что делает их идеальным выбором для реализации параллелизма в программах. Его можно реализовать с помощью срезов, связанных списков, структур и каналов. Полная информация уже представлена ​​в приведенных выше рекомендациях.