Merge pull request #2 from jairopedr/main

Adicionando conteudo

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
 ---
+<!--    Documentação - Fila
+Grupo:      Hugo Leonardo Viana
+            Jairo Pedro Santana
+            Mateus Borges e Guimarães
+            Willy Brener Alves Oliveira-->
+<h2> Conteúdo </h2>
+{{< 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

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
 ---
+<!--    Documentação - Fila
+Grupo:      Hugo Leonardo Viana
+            Jairo Pedro Santana
+            Mateus Borges e Guimarães
+            Willy Brener Alves Oliveira-->
+<h2> Conteúdo </h2>
+{{< 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

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
+<!--    Documentação - Fila
+Grupo:      Hugo Leonardo Viana
+            Jairo Pedro Santana
+            Mateus Borges e Guimarães
+            Willy Brener Alves Oliveira-->
+
+<h2> Conteúdo </h2>
+{{< 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
+
+- <a href="https://en.wikipedia.org/wiki/Double-ended_queue" target="_blank">Wikipedia</a>
+- <a href="https://www.tutorialspoint.com/applications-advantages-and-disadvantages-of-deque" target="_blank">Aplicações vantagens e desvantagens da Fila Dupla</a>
+- <a href="https://www.programiz.com/dsa/deque" target="_blank">Fila Dupla estrutura de dados</a>
+
+
+
+
+