From 08e19b74aa7f61a9afd7df3c1f6a40ad0530e6a5 Mon Sep 17 00:00:00 2001 From: Jairopedr <62018318+jairopedr@users.noreply.github.com> Date: Sat, 27 May 2023 16:25:36 -0300 Subject: [PATCH] Adicionando conteudo --- .../c_estruturas_de_dados/b_filas/_index.md | 117 +++++++++++++- .../b_filas/b_fila_circular.md | 58 ++++++- .../b_filas/d_fila_dupla.md | 126 ++++++++++++++- .../b_filas/e_fila_encadeada.md | 95 +++++++++++- .../b_filas/f_fila_circular_e.md | 103 ++++++++++++- .../b_filas/h_fila_dupla_e.md | 145 +++++++++++++++++- 6 files changed, 638 insertions(+), 6 deletions(-) diff --git a/content/pt/c_estruturas_de_dados/b_filas/_index.md b/content/pt/c_estruturas_de_dados/b_filas/_index.md index 6219e91..519a4a9 100644 --- a/content/pt/c_estruturas_de_dados/b_filas/_index.md +++ b/content/pt/c_estruturas_de_dados/b_filas/_index.md @@ -4,5 +4,120 @@ title: "Filas" date: 2023-04-12T01:00:36-03:00 draft: true --- + +

Conteúdo

+{{< toc "format=html" >}} + + + +## O que é uma fila? + +Em Ciências da Computação, uma fila é uma estrutura de dados que organiza elementos em uma ordem específica, conhecida como "primeiro a entrar, primeiro a sair" (FIFO - First-In-First-Out). Ela representa uma coleção de elementos em que novos elementos são adicionados ao final da fila e a remoção ocorre no início da fila. Em termos visuais, imagine uma fila de pessoas esperando em um guichê de atendimento, onde a pessoa que chegou primeiro é a primeira a ser atendida. + +A fila pode ser implementada usando diferentes estruturas de dados, como arrays, listas ligadas ou filas duplamente ligadas. Cada elemento na fila é chamado de item ou nó, e eles são mantidos em uma sequência linear. O primeiro elemento adicionado à fila é conhecido como "cabeça" ou "início", e o último elemento é chamado de "cauda" ou "fim". + + + +## Vantagens da Fila +- **Ordem garantida:** Uma das principais vantagens das filas é que elas garantem a ordem dos elementos. Quando os elementos são adicionados à fila, eles são processados na sequência em que foram inseridos, o que é importante em muitos casos, como processamento de pedidos ou eventos em ordem cronológica. + +- **Controle de prioridade:** As filas também podem ser usadas para controlar a prioridade de processamento. Por exemplo, em um sistema de gerenciamento de tarefas, tarefas com maior prioridade podem ser colocadas na frente da fila e, assim, serem processadas primeiro. + +- **Coordenação e sincronização:** Filas são frequentemente utilizadas para coordenar a comunicação e sincronização entre diferentes partes de um sistema. Por exemplo, em sistemas produtor-consumidor, onde um produtor gera dados e um consumidor os processa, uma fila pode ser usada para passar os dados de forma segura e sincronizada entre os dois. + +- **Implementação de algoritmos:** Filas são essenciais na implementação de algoritmos como Busca em Largura (BFS - Breadth-First Search), onde a ordem de processamento é fundamental. Além disso, filas são usadas em algoritmos de cache, agendamento de tarefas, impressão em spool, entre outros. + +- **Simplicidade conceitual:** A fila é uma estrutura de dados conceitualmente simples, o que a torna fácil de entender e implementar. Isso facilita o desenvolvimento de programas e algoritmos que envolvem a manipulação de elementos em uma sequência específica. + +- **Eficiência:** Tanto a inserção quanto a remoção de elementos em uma fila possuem uma complexidade de tempo constante, O(1). Isso significa que o tempo necessário para adicionar ou remover um elemento não depende do tamanho da fila. + +## Desvantagens da Fila + +- **Tamanho fixo:** Dependendo da implementação, filas podem ter um tamanho máximo fixo. Isso pode levar a problemas de estouro caso a fila atinja sua capacidade máxima. Se a fila atingir seu tamanho máximo e novos elementos forem adicionados, isso pode resultar em perda de dados ou no impedimento de inserção de novos elementos na fila. +- **Acesso limitado:** O acesso direto a elementos específicos em uma fila é limitado. Normalmente, só é possível acessar o primeiro elemento da fila e removê-lo. Se for necessário acessar elementos no meio da fila, pode ser necessário remover vários elementos na frente até chegar ao elemento desejado. +- **Ineficiência na remoção de elementos intermediários:** Se for necessário remover um elemento que não esteja no início da fila, todos os elementos anteriores precisam ser removidos antes dele. Isso pode ser ineficiente se houver a necessidade frequente de remover elementos em posições intermediárias. +- **Uso de memória contínua:** Alguns tipos de implementações de fila requerem o uso de memória contínua, o que significa que o espaço de memória para a fila precisa ser alocado de forma contínua. Isso pode ser um desafio em situações onde a memória é limitada ou fragmentada. +- **Limitações de desempenho em grandes filas:** Conforme a fila cresce em tamanho, as operações de enfileirar e desenfileirar podem se tornar mais lentas, especialmente se a implementação não for otimizada. O tempo de execução dessas operações pode aumentar linearmente com o tamanho da fila, o que pode ser um problema em casos de filas extremamente grandes. + +## Usos Comuns da Fila + +- **Gerenciamento de tarefas:** Filas são frequentemente utilizadas para o gerenciamento de tarefas, como em sistemas operacionais para escalonamento de processos. Por exemplo, em um sistema operacional, os processos são colocados em uma fila de prontos e o escalonador seleciona o próximo processo a ser executado com base no princípio FIFO. + +- **Processamento assíncrono:** Filas são úteis para processar tarefas assíncronas, onde as requisições são enfileiradas e processadas uma após a outra. Por exemplo, em um servidor web, as solicitações dos clientes podem ser colocadas em uma fila e processadas em ordem, garantindo um tratamento justo para cada solicitação. + +- **Simulação de eventos:** Em simulações computacionais, filas podem ser usadas para representar eventos futuros e processá-los na ordem correta. Por exemplo, em uma simulação de tráfego, os carros podem ser enfileirados em uma fila para atravessar um cruzamento, respeitando a ordem de chegada. + +- **Processamento de mensagens ou eventos em sistemas distribuídos:** Filas são comumente utilizadas em sistemas distribuídos para processar mensagens ou eventos assíncronos. Por exemplo, em um sistema de mensagens instantâneas, as mensagens podem ser enfileiradas em uma fila centralizada antes de serem entregues aos destinatários. + + +## Operações típicas com a Fila + +- **Enqueue:** Insere um elemento no final da fila. +- **Dequeue:** Remove o elemento no início da fila. +- **Front:** Retorna o elemento no início da fila sem removê-lo. +- **IsEmpty:** Verifica se a fila está vazia. +- **Size:** Retorna o número de elementos presentes na fila. +- **Clear:** Remove todos os elementos da fila, deixando-a vazia. +- **Contains:** Verifica se um determinado elemento está presente na fila. +- **Print:** Imprime todos os elementos da fila. +- **Rear:** Retorna o elemento no final da fila sem removê-lo. +- **Count:** Retorna o número de ocorrências de um determinado elemento na fila. +- **Remove:** Remove a primeira ocorrência de um elemento específico da fila. + + +## Utilização da Fila em Python + +Abaixo segue a implementação e o uso de algumas funções da Fila Simples em Python: +{{< tabs "ex_1" >}} +{{< tab "Python" >}} +```Python +class FilaSimples: + def __init__(self): + self.fila = [] + + def enqueue(self, item): + self.fila.append(item) + + def dequeue(self): + if self.is_empty(): + return "A fila está vazia." + return self.fila.pop(0) + + def front(self): + if self.is_empty(): + return "A fila está vazia." + return self.fila[0] + + def is_empty(self): + return len(self.fila) == 0 + + def size(self): + return len(self.fila) + + + + +fila = FilaSimples() +fila.enqueue("A") +fila.enqueue("B") +fila.enqueue("C") + +print(fila.dequeue()) # Saída: "A" +print(fila.front()) # Saída: "B" +print(fila.size()) # Saída: 2 +print(fila.is_empty()) # Saída: False + +{{< /tab >}} +{{< /tabs >}} + + +## Referências + +- [Wikipédia](https://pt.wikipedia.org/wiki/FIFO) +- [Treinaweb](https://www.treinaweb.com.br/blog/o-que-e-e-como-funciona-a-estrutura-de-dados-fila) +- [Otaviomiranda](https://www.otaviomiranda.com.br/2020/filas-em-python-com-deque-queue/) -//TODO \ No newline at end of file diff --git a/content/pt/c_estruturas_de_dados/b_filas/b_fila_circular.md b/content/pt/c_estruturas_de_dados/b_filas/b_fila_circular.md index 34bc449..446e772 100644 --- a/content/pt/c_estruturas_de_dados/b_filas/b_fila_circular.md +++ b/content/pt/c_estruturas_de_dados/b_filas/b_fila_circular.md @@ -4,5 +4,61 @@ title: "Fila circular (alocação contígua)" date: 2023-04-12T01:00:36-03:00 draft: false --- + +

Conteúdo

+{{< toc "format=html" >}} + +Uma fila circular é uma estrutura de dados em que os elementos são organizados em uma sequência circular. Em uma fila circular, quando um elemento é removido do início da fila, o próximo elemento se torna o novo início, permitindo assim um aproveitamento eficiente do espaço de armazenamento. Neste contexto, vamos explorar a fila circular com foco nas vantagens, desvantagens, usos comuns, operações típicas e sua utilização em Python. + +## Vantagens da Fila Circular +- **Eficiência espacial:** Ao contrário de uma fila convencional, em que os elementos são armazenados sequencialmente, uma fila circular otimiza o uso de memória, pois os elementos podem ser armazenados em uma estrutura circular sem desperdiçar espaço. +- **Acesso rápido aos elementos:** Como a fila circular permite que o início da fila seja atualizado, o acesso aos elementos subsequentes é rápido e direto, sem a necessidade de percorrer toda a estrutura. + +## Desvantagens da Fila Circular +- **Tamanho fixo:** Uma fila circular possui um tamanho máximo predefinido. Se todos os slots estiverem ocupados e um novo elemento for adicionado, será necessário substituir um elemento existente para acomodar o novo. Isso pode causar a perda de dados se não for tratado adequadamente. +- **Complexidade de implementação:** A lógica de uma fila circular é mais complexa do que uma fila convencional, exigindo manipulação adicional dos índices para manter o rastreamento correto do início e do fim da fila. + +## Usos comuns da Fila Circular +- **Buffers circulares:** Uma fila circular é frequentemente utilizada em sistemas que precisam armazenar dados temporariamente, como buffers de áudio ou vídeo. Os dados mais antigos são substituídos pelos novos à medida que a fila é preenchida. +- **Gerenciamento de tarefas:** Em sistemas operacionais, uma fila circular pode ser usada para agendar e executar tarefas, garantindo que todas as tarefas sejam atendidas em uma ordem justa. + +## Operações típicas com a Fila Circular +- **Enfileirar (enqueue):** Adiciona um elemento ao final da fila circular. +- **Desenfileirar (dequeue):** Remove e retorna o elemento do início da fila circular. +- **Verificar se a fila está vazia:** Verifica se a fila circular está vazia, ou seja, se não contém elementos. +- **Verificar se a fila está cheia:** Verifica se a fila circular está cheia, ou seja, se todos os slots estão ocupados. + +## Utilização da Fila Circular em Python + +Em Python, a fila circular pode ser implementada utilizando listas e operações de índice. O módulo `collections` da biblioteca padrão também fornece a classe `deque`: + +{{< tabs "ex_1" >}} +{{< tab "Python" >}} +```Python +from collections import deque + +fila_circular = deque(maxlen=5) # Define um tamanho máximo para a fila circular + +fila_circular.append(1) # Enfileirar elemento 1 +fila_circular.append(2) # Enfileirar elemento 2 +fila_circular.append(3) # Enfileirar elemento 3 + +print(fila_circular) # Saída: deque([1, 2, 3], maxlen=5) + +elemento_removido = fila_circular.popleft() # Desenfileirar o primeiro elemento +print(elemento_removido) # Saída: 1 + +print(fila_circular) # Saída: deque([2, 3], maxlen=5) +{{< /tab >}} +{{< /tabs >}} + +## Referências + +- [Devmedia](https://www.devmedia.com.br/fila-circular-dinamica/24572) +- [Dantagens](https://acervolima.com/vantagens-da-fila-circular-em-relacao-a-fila-linear/) +- [Documentação Python](https://docs.python.org/3/library/collections.html#collections.deque) -//TODO \ No newline at end of file diff --git a/content/pt/c_estruturas_de_dados/b_filas/d_fila_dupla.md b/content/pt/c_estruturas_de_dados/b_filas/d_fila_dupla.md index 3f14518..d24c89d 100644 --- a/content/pt/c_estruturas_de_dados/b_filas/d_fila_dupla.md +++ b/content/pt/c_estruturas_de_dados/b_filas/d_fila_dupla.md @@ -5,4 +5,128 @@ date: 2023-04-12T01:00:36-03:00 draft: false --- -//TODO \ No newline at end of file + + +

Conteúdo

+{{< toc "format=html" >}} + + + + +Em ciência da computação , uma Fila dupla é um tipo de dado abstrato que generaliza uma fila , para a qual elementos podem ser adicionados ou removidos da frente (cabeçalho) ou de trás (cauda). + +Uma Fila dupla é uma estrutura de dados que permite a inserção e remoção de elementos de ambas as extremidades. Isso é diferente de uma fila, que só permite a inserção em uma extremidade e a remoção na outra extremidade, seguindo uma ordem FIFO (first in first, out / primeiro a entrar, primeiro a sair). Filas duplas podem ter vários subtipos, incluindo Filas duplas restritos à entrada, onde a exclusão pode ser feita em ambas as extremidades, mas a inserção só pode ser feita em uma extremidade, e Filas duplas restritos à saída, onde a inserção pode ser feita em ambas as extremidades, mas a exclusão só pode ser feito de uma ponta. + +Filas duplas são uma estrutura de dados fundamental na computação, e muitas outras estruturas de dados podem ser implementadas usando-as. Por exemplo, filas e pilhas podem ser consideradas especializações de Filas duplas. As operações básicas em uma Fila dupla são adicionar elementos a qualquer uma das extremidades e remover elementos de ambas as extremidades. + +## Vantagens da Fila Dupla + +A principal vantagem da Fila dupla sobre a Fila convencional é a possibilidade de adicionar ou remover os itens de ambos os lados da Fila Dupla. Na Fila convencional você só pode adicionar os dados de trás e removê-los de frente, além disso a Fila dupla também tem a vantagem de ser dinâmica em tamanho, oferecer um bom tempo para a execução das operações entre outras. + + + + + +## Desvantagens da Fila Dupla + +As principais desvantagens da Fila dupla são: + +- Maior consumo de memória: O processo da Fila Dupla tem maior taxa de consumo de memória. +- Sincronização: Tem problemas de sincronização com multi thread. +- Suporte: Não pode ser implementado em todas as plataformas. +- Classificação: Não é adequado para implementar operações de classificação. +- Limitada: A Fila Dupla tem poucas funcionalidades. + +## Usos Comuns da Fila Dupla + +- Realizar operações de desfazimento no software. +- Para armazenar histórico em navegadores. +- Para implementar pilhas e filas. + +Um exemplo em que uma Fila Dupla pode ser usada é o algoritmo de roubo de trabalho. Este algoritmo implementa escalonamento de tarefas para vários processadores. Uma Fila Dupla separada com threads a serem executados é mantida para cada processador. Para executar a próxima thread, o processador obtém o primeiro elemento da Fila Dupla (usando a operação da Fila Dupla ("remover primeiro elemento")). Se a thread atual bifurcar, ela é colocada de volta na frente da Fila Dupla ("inserir elemento na frente") e uma nova thread é executada. Quando um dos processadores termina a execução de suas próprias threads (ou seja, sua Fila Dupla está vazia), ele pode "roubar" uma thread de outro processador: ele pega o último elemento da Fila Dupla de outro processador ("remove último elemento") e executa isto. O algoritmo de roubo de trabalho é usado pela biblioteca Threading Building Blocks (TBB) da Intel para programação paralela. + +## Operações típicas com a Fila Dupla + +***push_back():*** insira um elemento da parte de trás de uma Fila Dupla. + +***push_front():*** insira um elemento da frente de uma Fila Dupla. + +***pop_back*** remove o elemento da parte de trás de uma Fila Dupla. + +***pop_front():*** remove o elemento da frente da Fila Dupla. + +***front():*** retorna o elemento na frente de uma Fila Dupla. + +***back():*** retorna o elemento no final da Fila Dupla. + +***at()-set:*** retorna no índice especificado. + +***size():*** o número de elementos retorna. + +***empty():*** retorna verdadeiro se a Fila Dupla estiver vazia. + + +## Utilização da Fila Dupla em Python + +Abaixo segue a implementação e o uso de algumas funções da Fila Dupla em Python: + +**Fila Dupla implementação em Python** + +{{< tabs "ex_1" >}} +{{< tab "Python" >}} +```Python +class Deque: + def __init__(self): + self.items = [] + + def isEmpty(self): + return self.items == [] + + def addRear(self, item): + self.items.append(item) + + def addFront(self, item): + self.items.insert(0, item) + + def removeFront(self): + return self.items.pop(0) + + def removeRear(self): + return self.items.pop() + + def size(self): + return len(self.items) + + +d = Deque() +print(d.isEmpty()) +d.addRear(8) +d.addRear(5) +d.addFront(7) +d.addFront(10) +print(d.size()) +print(d.isEmpty()) +d.addRear(11) +print(d.removeRear()) +print(d.removeFront()) +d.addFront(55) +d.addRear(45) +print(d.items) + +{{< /tab >}} +{{< /tabs >}} + +## Referências + +- Wikipedia +- Aplicações vantagens e desvantagens da Fila Dupla +- Fila Dupla estrutura de dados + + + + + diff --git a/content/pt/c_estruturas_de_dados/b_filas/e_fila_encadeada.md b/content/pt/c_estruturas_de_dados/b_filas/e_fila_encadeada.md index 83d44e8..120ad58 100644 --- a/content/pt/c_estruturas_de_dados/b_filas/e_fila_encadeada.md +++ b/content/pt/c_estruturas_de_dados/b_filas/e_fila_encadeada.md @@ -4,5 +4,98 @@ title: "Fila encadeada" date: 2023-04-12T01:00:36-03:00 draft: false --- + +

Conteúdo

+{{< toc "format=html" >}} -//TODO \ No newline at end of file + +Uma fila encadeada é uma estrutura de dados linear usada na computação para armazenar elementos onde a inserção e exclusão ocorrem em extremidades diferentes. É um tipo de fila onde cada elemento, chamado nó, contém um valor e um ponteiro para o próximo nó da fila. Essa estrutura de dados segue o princípio FIFO (First In First Out). Ou seja, o primeiro item a ser adicionado é o primeiro item a ser removido. + +## Diferença entre Fila e Fila Encadeada + +A diferença principal entre uma fila convencional e uma fila encadeada é a forma como os elementos são armazenados e acessados. Em uma fila convencional, os elementos são armazenados em uma estrutura contígua de memória, como um array, e as operações de inserção e remoção são realizadas deslocando-se os elementos na estrutura. + +Por outro lado, em uma fila encadeada, cada elemento (nó) possui um ponteiro para o próximo nó, permitindo que os elementos sejam armazenados de forma não contígua na memória. Isso facilita a inserção e a remoção de elementos, pois não é necessário deslocar todos os elementos da fila. + +## Vantagens da Fila Encadeada + +- Inserção e remoção eficientes: A fila encadeada permite a inserção e a remoção de elementos em tempo constante, independentemente do tamanho da fila. Isso ocorre porque a estrutura encadeada não requer deslocamento de elementos como em uma fila convencional. +- Uso eficiente de memória: A fila encadeada utiliza apenas a quantidade de memória necessária para armazenar os elementos presentes na fila. Isso é especialmente útil quando o tamanho da fila varia ao longo do tempo. +- Flexibilidade: A estrutura de uma fila encadeada permite a implementação de operações adicionais, como inserção em qualquer posição da fila, remoção de elementos específicos, entre outros. + +## Desvantagens da Fila Encadeada + +- Acesso sequencial: Ao contrário de estruturas de dados como arrays ou listas, o acesso aleatório aos elementos de uma fila encadeada não é possível. É necessário percorrer sequencialmente os nós para acessar um elemento em uma posição específica. +- Uso adicional de memória: Cada nó em uma fila encadeada requer uma área de memória adicional para armazenar o ponteiro para o próximo nó. Em comparação com uma fila convencional, isso pode resultar em um consumo maior de memória. + +## Usos Comuns da Fila Encadeada + +A fila encadeada é comumente utilizada em situações em que a ordem de inserção dos elementos é importante e a remoção segue a ordem de chegada. Alguns exemplos de uso incluem: + +- Simulações de eventos discretos, como a simulação de um sistema de atendimento ao cliente em uma empresa. +- Filas de tarefas em sistemas operacionais, onde os processos são colocados em uma fila para serem executados pelo processador. +- Implementação de caches de memória, em que os elementos menos utilizados são removidos da fila para abrir espaço para novos elementos. + +## Operações típicas da Fila Encadeada + +As operações básicas em uma fila encadeada incluem: + +- Enqueue (Inserir): Adiciona um elemento ao final da fila. +- Dequeue (Remover): Remove o elemento do início da fila. +- Front (Primeiro): Retorna o valor do elemento no início da fila, sem removê-lo. +- IsEmpty (Vazia): Verifica se a fila está vazia. +- Size (Tamanho): Retorna o número de elementos presentes na fila. + +## Utilização da Fila Encadeada em Python + +A implementação de uma fila encadeada em Python pode ser feita utilizando classes e objetos. Cada nó da fila é representado por um objeto que contém o valor e uma referência para o próximo nó. Abaixo segue a implementação e o uso de algumas funções da Fila Encadeada em Python: + +```python +class Node: + def __init__(self, value): + self.value = value + self.next = None + +class Queue: + def __init__(self): + self.head = None + self.tail = None + + def enqueue(self, value): + new_node = Node(value) + if self.tail: + self.tail.next = new_node + else: + self.head = new_node + self.tail = new_node + + def dequeue(self): + if not self.head: + raise Exception("A fila está vazia") + value = self.head.value + self.head = self.head.next + if not self.head: + self.tail = None + return value + + def is_empty(self): + return self.head is None + + def size(self): + count = 0 + current = self.head + while current: + count += 1 + current = current.next + return count +``` + +## Referências: + +- [SlideShare](https://pt.slideshare.net/FabianaLorenzi1/filas-encadeadas) +- [Readthedocs.io](https://aprendacompy.readthedocs.io/pt/latest/capitulo_19.html) +- [Growth](https://growthdev.com.br/programacao/estruturas-de-dados-listas-filas-pilhas-conjuntos-arvores-e-tabela-espelhadas/) diff --git a/content/pt/c_estruturas_de_dados/b_filas/f_fila_circular_e.md b/content/pt/c_estruturas_de_dados/b_filas/f_fila_circular_e.md index 6065342..dfe6b71 100644 --- a/content/pt/c_estruturas_de_dados/b_filas/f_fila_circular_e.md +++ b/content/pt/c_estruturas_de_dados/b_filas/f_fila_circular_e.md @@ -5,4 +5,105 @@ date: 2023-04-12T01:00:36-03:00 draft: false --- -//TODO \ No newline at end of file + + +

Conteúdo

+{{< toc "format=html" >}} + + +Uma fila circular com nós encadeados é uma estrutura de dados que combina as características de uma fila circular e uma lista encadeada. Ela permite a inserção e remoção eficiente de elementos no início e no final da fila, independentemente do tamanho da fila. +Em uma fila circular com nós encadeados, cada elemento é armazenado em um nó, que contém um valor e um ponteiro/referência para o próximo nó da fila. O último nó da fila aponta para o primeiro nó, formando um ciclo. + +## Vantagens da Fila Circular com nós encadeados + +- **Eficiência:** Uma fila circular com nós encadeados possui um desempenho eficiente em termos de inserção e remoção de elementos, independentemente do tamanho da fila. Isso ocorre porque a estrutura permite que os elementos sejam adicionados ou removidos no início ou no final da fila em tempo constante. +- **Utilização eficiente de memória:** A fila circular utiliza a memória de forma eficiente, pois não há desperdício de espaços vazios entre os elementos. +- **Implementação simples:** A implementação de uma fila circular com nós encadeados é relativamente simples, o que facilita sua compreensão e manutenção. + +## Desvantagens da Fila Circular com nós encadeados + +- **Tamanho fixo:** A fila circular com nós encadeados requer um tamanho fixo pré-definido. Isso significa que a capacidade da fila precisa ser especificada no momento da sua criação, e não pode ser alterada dinamicamente. Se a fila atingir sua capacidade máxima, novos elementos não poderão ser adicionados até que outros sejam removidos. +- **Acesso sequencial:** A fila circular permite o acesso sequencial aos elementos. Portanto, se for necessário acessar um elemento em uma posição específica, é necessário percorrer todos os elementos anteriores. + +## Usos comuns da Fila Circular com nós encadeados + +- **Gerenciamento de tarefas:** Uma fila circular com nós encadeados é frequentemente utilizada em sistemas de gerenciamento de tarefas, onde as tarefas são adicionadas à fila e processadas de acordo com sua ordem de chegada. +- **Armazenamento temporário:** Pode ser utilizada como uma estrutura de dados para armazenar temporariamente elementos que aguardam processamento posterior. +- **Simulação de eventos:** Em simulações, a fila circular pode ser usada para modelar a fila de eventos que devem ser processados em uma ordem específica. + +## Operações típicas com a Fila Circular com nós encadeados + +- **Enfileirar (enqueue):** Adiciona um elemento no final da fila. +- **Desenfileirar (dequeue):** Remove o elemento do início da fila. +- **Verificar se a fila está vazia:** Retorna verdadeiro se a fila estiver vazia, e falso caso contrário. +- **Verificar se a fila está cheia:** Retorna verdadeiro se a fila estiver cheia, e falso caso contrário. +- **Obter o tamanho da fila:** Retorna o número de elementos presentes na fila. + +## Utilização Fila Circular com nós encadeados em python + +{{< tabs "ex_1" >}} +{{< tab "Python" >}} +```Python +class Node: + def __init__(self, value): + self.value = value + self.next = None + +class CircularQueue: + def __init__(self, capacity): + self.capacity = capacity + self.head = None + self.tail = None + self.size = 0 + + def is_empty(self): + return self.size == 0 + + def is_full(self): + return self.size == self.capacity + + def enqueue(self, value): + if self.is_full(): + print("A fila está cheia. Não é possível enfileirar o elemento.") + return + + new_node = Node(value) + + if self.is_empty(): + self.head = new_node + self.tail = new_node + new_node.next = new_node + else: + new_node.next = self.tail.next + self.tail.next = new_node + self.tail = new_node + + self.size += 1 + + def dequeue(self): + if self.is_empty(): + print("A fila está vazia. Não é possível desenfileirar.") + return None + + value = self.head.value + + if self.size == 1: + self.head = None + self.tail = None + else: + self.head = self.head.next + self.tail.next = self.head + + self.size -= 1 + + return value +{{< /tab >}} +{{< /tabs >}} + +## Referências +- Documentação Python +- Stackoverflow \ No newline at end of file diff --git a/content/pt/c_estruturas_de_dados/b_filas/h_fila_dupla_e.md b/content/pt/c_estruturas_de_dados/b_filas/h_fila_dupla_e.md index 1b1b610..5dfb855 100644 --- a/content/pt/c_estruturas_de_dados/b_filas/h_fila_dupla_e.md +++ b/content/pt/c_estruturas_de_dados/b_filas/h_fila_dupla_e.md @@ -5,4 +5,147 @@ date: 2023-04-12T01:00:36-03:00 draft: false --- -//TODO \ No newline at end of file + + +

Conteúdo

+{{< toc "format=html" >}} + +Uma Fila Dupla com nós encadeados é uma estrutura de dados que estende o conceito de uma Fila Dupla, onde cada elemento (nó) contém um valor e uma referência ao próximo nó e ao nó anterior. Essa estrutura de dados permite a inserção e remoção de elementos em ambas as extremidades da fila, assim como uma Fila Dupla convencional, mas com a vantagem adicional de ter acesso aos nós adjacentes. + +## Vantagens da Fila dupla com nós encadeados + +**Flexibilidade:** A Fila Dupla com nós encadeados permite a inserção e remoção eficiente de elementos tanto na frente quanto na parte de trás da fila, oferecendo flexibilidade em termos de manipulação dos dados. + +**Eficiência:** Comparada a outras estruturas de dados, a Fila Dupla com nós encadeados pode fornecer operações de inserção e remoção mais eficientes em ambas as extremidades. + +**Acesso aos nós adjacentes:** A capacidade de acessar os nós adjacentes em uma Fila Dupla com nós encadeados pode ser útil em certos cenários, permitindo operações mais avançadas. + +## Desvantagens da Fila dupla com nós encadeados + +**Complexidade:** A implementação da Fila Dupla com nós encadeados pode ser mais complexa do que uma Fila Dupla convencional, devido à necessidade de gerenciar as referências entre os nós. + +**Consumo de memória:** A estrutura de nós encadeados requer armazenamento adicional para as referências entre os nós, o que pode resultar em um consumo de memória maior em comparação com estruturas de dados mais simples. + +## Usos Comuns da Fila dupla com nós encadeados + +**Implementação de algoritmos de busca avançados:** A capacidade de acessar os nós adjacentes em uma Fila Dupla com nós encadeados pode ser útil na implementação de algoritmos de busca mais avançados, como busca bidirecional. + +**Manipulação de histórico:** A Fila Dupla com nós encadeados pode ser usada para armazenar histórico de operações, permitindo desfazer e refazer ações em determinado contexto. + +**Implementação de caches:** Em certos cenários, a Fila Dupla com nós encadeados pode ser usada para implementar caches de dados, permitindo acesso rápido a elementos recentemente usados. + +## Operações típicas com a Fila dupla com nós encadeados + +- **Inserção na frente:** Adicionar um novo nó na frente da fila. +- **Inserção na parte de trás:** Adicionar um novo nó na parte de trás da fila. +- **Remoção na frente:** Remover o nó na frente da fila. +- **Remoção na parte de trás:** Remover o nó na parte de trás da fila. +- **Acesso ao nó adjacente anterior:** Obter a referência para o nó anterior a um nó específico. +- **Acesso ao nó adjacente posterior:** Obter a referência para o nó posterior a um nó específico. + +## Utilização da Fila dupla com nós encadeados em Python + +Abaixo segue uma possível implementação da Fila Dupla com nós encadeados em Python: + +```Python +class Node: + def __init__(self, value): + self.value = value + self.next = None + self.prev = None + + class DoublyLinkedListDeque: + def __init__(self): + self.front = None + self.rear = None + + def isEmpty(self): + return self.front is None + + def addFront(self, value): + new_node = Node(value) + if self.isEmpty(): + self.front = self.rear = new_node + else: + new_node.next = self.front + self.front.prev = new_node + self.front = new_node + + def addRear(self, value): + new_node = Node(value) + if self.isEmpty(): + self.front = self.rear = new_node + else: + new_node.prev = self.rear + self.rear.next = new_node + self.rear = new_node + + def removeFront(self): + if self.isEmpty(): + return None + front_value = self.front.value + if self.front is self.rear: + self.front = self.rear = None + else: + self.front = self.front.next + self.front.prev = None + return front_value + + def removeRear(self): + if self.isEmpty(): + return None + rear_value = self.rear.value + if self.front is self.rear: + self.front = self.rear = None + else: + self.rear = self.rear.prev + self.rear.next = None + return rear_value + + def size(self): + count = 0 + curr = self.front + while curr: + count += 1 + curr = curr.next + return count +``` + +**Exemplo de uso da Fila Dupla com nós encadeados** +```python +d = DoublyLinkedListDeque() +print(d.isEmpty()) # True + +d.addFront(8) +d.addRear(5) +d.addFront(7) +d.addFront(10) +print(d.size()) # 4 +print(d.isEmpty()) # False + +d.addRear(11) +print(d.removeRear()) # 11 +print(d.removeFront()) # 10 + +d.addFront(55) +d.addRear(45) +print(d.size()) # 5 +print(d.removeFront()) # 55 +print(d.removeRear()) # 45 +print(d.size()) # 3 +``` + + + + + +## Referências + +- Wikipedia +- Fila Dupla com nós encadeados + +