O documento apresenta os conceitos básicos de listas e como modelá-las utilizando vetores em programação estruturada. Descreve listas como uma estrutura de dados que armazena elementos em uma sequência e apresenta algoritmos para adicionar, remover e acessar itens na lista.
O documento discute estruturas de dados, definindo-as como métodos particulares de implementar tipos abstratos de dados. Apresenta listas como uma estrutura de dados linear na qual os elementos preservam uma ordem sequencial, e descreve listas ordenadas como listas cujos elementos estão ordenados de acordo com um critério pré-estabelecido. Detalha a implementação de listas sequenciais e ordenadas sequenciais usando arrays.
Uma lista circular é uma lista encadeada onde o último nó aponta para o primeiro, formando um ciclo. Isso permite navegar entre o início e o fim da lista com apenas uma operação, ao contrário de listas simples que requerem várias operações. As operações básicas de uma lista circular incluem inserção e remoção nos extremos da lista e verificação se a lista está vazia.
1) O documento introduz filas de prioridade e como elas diferem de filas comuns, onde elementos possuem prioridades associadas e os de maior prioridade são removidos primeiro.
2) São discutidas implementações eficientes de filas de prioridade usando heaps, onde inserções e remoções ocorrem em tempo constante.
3) Heaps armazenam dados em árvores binárias de forma a atender propriedades específicas e podem ser representados em vetores de forma a tornar operações mais eficientes.
(1) O documento apresenta o TAD (Tipo Abstrato de Dados) listas estáticas encadeadas, que implementam listas encadeadas usando vetores e cursores para simular ponteiros. (2) As operações como inserção e remoção têm complexidade O(1), diferentemente de listas encadeadas normais que têm O(n). (3) A pesquisa de elementos na lista segue os cursores "prox" de cada nó, independentemente da posição real no vetor.
O documento apresenta as principais interfaces, implementações e algoritmos da Collection Framework do Java, incluindo List (ArrayList e LinkedList), Set (HashSet e TreeSet) e Map (HashMap e TreeMap). É explicado quando cada uma deve ser utilizada e quais são seus principais prós e contras.
Este documento apresenta um resumo sobre listas encadeadas. As principais ideias apresentadas são:
1) Listas encadeadas são uma estrutura de dados recursiva na qual os elementos são ligados uns aos outros através de ponteiros, permitindo adicionar elementos dinamicamente sem preocupar com o tamanho da memória;
2) As operações sobre listas encadeadas geralmente são implementadas de forma recursiva, tratando casos triviais e reduzindo o problema a subproblemas menores;
3) Exemplos de operações comuns como tamanho, busca e inserção
O documento descreve diferentes tipos de coleções em Java, incluindo vetores, conjuntos, pilhas, árvores binárias e tabelas de hash. Ele também discute a interface Collection e as interfaces Map, Set e List, além de exemplos de uso.
O documento discute estruturas de dados, definindo-as como métodos particulares de implementar tipos abstratos de dados. Apresenta listas como uma estrutura de dados linear na qual os elementos preservam uma ordem sequencial, e descreve listas ordenadas como listas cujos elementos estão ordenados de acordo com um critério pré-estabelecido. Detalha a implementação de listas sequenciais e ordenadas sequenciais usando arrays.
Uma lista circular é uma lista encadeada onde o último nó aponta para o primeiro, formando um ciclo. Isso permite navegar entre o início e o fim da lista com apenas uma operação, ao contrário de listas simples que requerem várias operações. As operações básicas de uma lista circular incluem inserção e remoção nos extremos da lista e verificação se a lista está vazia.
1) O documento introduz filas de prioridade e como elas diferem de filas comuns, onde elementos possuem prioridades associadas e os de maior prioridade são removidos primeiro.
2) São discutidas implementações eficientes de filas de prioridade usando heaps, onde inserções e remoções ocorrem em tempo constante.
3) Heaps armazenam dados em árvores binárias de forma a atender propriedades específicas e podem ser representados em vetores de forma a tornar operações mais eficientes.
(1) O documento apresenta o TAD (Tipo Abstrato de Dados) listas estáticas encadeadas, que implementam listas encadeadas usando vetores e cursores para simular ponteiros. (2) As operações como inserção e remoção têm complexidade O(1), diferentemente de listas encadeadas normais que têm O(n). (3) A pesquisa de elementos na lista segue os cursores "prox" de cada nó, independentemente da posição real no vetor.
O documento apresenta as principais interfaces, implementações e algoritmos da Collection Framework do Java, incluindo List (ArrayList e LinkedList), Set (HashSet e TreeSet) e Map (HashMap e TreeMap). É explicado quando cada uma deve ser utilizada e quais são seus principais prós e contras.
Este documento apresenta um resumo sobre listas encadeadas. As principais ideias apresentadas são:
1) Listas encadeadas são uma estrutura de dados recursiva na qual os elementos são ligados uns aos outros através de ponteiros, permitindo adicionar elementos dinamicamente sem preocupar com o tamanho da memória;
2) As operações sobre listas encadeadas geralmente são implementadas de forma recursiva, tratando casos triviais e reduzindo o problema a subproblemas menores;
3) Exemplos de operações comuns como tamanho, busca e inserção
O documento descreve diferentes tipos de coleções em Java, incluindo vetores, conjuntos, pilhas, árvores binárias e tabelas de hash. Ele também discute a interface Collection e as interfaces Map, Set e List, além de exemplos de uso.
O documento apresenta uma introdução ao LINQ (Language Integrated Query), incluindo suas principais funcionalidades como consultas declarativas em objetos, XML e bancos de dados SQL, além de exemplos de seu uso.
O documento descreve a classe ArrayList em Java, incluindo como declarar e inicializar uma lista, adicionar e remover elementos usando os métodos add, remove, set e get, e obter o tamanho da lista com o método size.
O documento descreve a classe ArrayList em Java, incluindo como declarar e inicializar uma lista, adicionar e remover elementos usando os métodos add, remove, set e get, e obter o tamanho da lista com o método size.
Este estudo comparou o desempenho de algoritmos de ordenação como Bubble Sort, Insertion Sort, Selection Sort, Merge Sort e Quick Sort em vetores de diferentes tamanhos e ordenações. Os resultados mostraram que Merge Sort e Quick Sort tiveram os melhores tempos de execução, enquanto Bubble Sort teve os piores tempos.
O documento discute filas de prioridade e como implementá-las de forma eficiente. Duas abordagens são descritas: uma que é eficiente para inserções e outra para remoções. Heaps são introduzidos como uma estrutura de dados que pode representar filas de prioridade de forma eficiente.
O documento descreve as listas encadeadas e como representá-las em C. As listas encadeadas representam uma sequência de objetos na memória ligados por ponteiros. Cada elemento da lista contém um campo de dados e um ponteiro para o próximo elemento, permitindo acesso flexível aos itens.
Estruturas de Dados - Listas Encadeadas (Linked List)Erick Petrucelli
Este documento discute estruturas de dados, incluindo estruturas lineares como pilhas, filas e listas, e não-lineares como tabelas de espalhamento e árvores. Ele se concentra em listas encadeadas, definindo uma classe Node para representar cada nó e uma classe LinkedList para implementar operações como inserção e remoção de nós em qualquer posição da lista.
O documento descreve as principais características e funcionalidades de listas em Python, incluindo: (1) listas podem conter valores de diferentes tipos; (2) suportam acesso seqüencial e direto por índice; e (3) operações como indexação, fatiamento, concatenação e repetição.
Fila de prioridade, pilha e fila são estruturas de dados. Uma fila de prioridade ordena itens por chave, com o de menor chave na frente. Itens são inseridos na posição ordenada e o de maior chave é removido.
O documento discute listas ligadas e algoritmos de estrutura de dados. Ele fornece definições de listas ligadas e explica como elas são compostas por nós ligados por ponteiros. O documento também apresenta exercícios sobre como criar estruturas de dados e implementar funções básicas como inserção, remoção e busca em listas ligadas.
15 algoritmos de busca em tabelas - sequencial e binariaRicardo Bolanho
Algoritmos de Busca em Tabelas descreve os principais algoritmos de busca em tabelas: busca sequencial, busca binária e suas variações. A busca sequencial varre toda a tabela linearmente. A busca binária requer que a tabela esteja ordenada e divide a busca em metade a cada iteração.
Listas são estruturas de dados que permitem armazenar e acessar sequencialmente uma coleção de elementos de qualquer tipo. Em Python, listas podem ser criadas usando colchetes e suportam operações como indexação, fatiamento, concatenação e repetição de elementos. Listas são objetos mutáveis que oferecem métodos para adicionar, remover e ordenar elementos.
O documento descreve uma lista encadeada de inteiros em C++. A lista armazena elementos de forma sequencial usando nós ligados por ponteiros. O documento explica a interface da classe lista e como implementar métodos como inserção, remoção e impressão percorrendo a lista através dos nós.
Por que dizemos que Scala é uma linguagem funcional?pmatiello
Scala é considerada uma linguagem funcional porque suporta:
1) Programação funcional através de funções de ordem superior e avaliação atrasada;
2) Transparência referencial evitando efeitos colaterais;
3) Streams permitem gerar sequências infinitas de maneira preguiçosa.
O documento discute coleções em Java, definindo-as como estruturas de dados que armazenam objetos. Apresenta os principais tipos de coleções: listas, conjuntos e mapas, descrevendo suas características e operações básicas como adição, remoção e acesso a elementos. Fornece também detalhes sobre classes e interfaces de coleções no Java.
1) O documento apresenta uma introdução sobre arrays no PHP, definindo-os como mapas ordenados que podem ser utilizados como listas, dicionários ou árvores.
2) São descritas funções para criar, manipular e ordenar arrays, como array(), count(), asort() e array_search().
3) O documento fornece exemplos práticos mostrando como declarar e imprimir diferentes tipos de arrays no PHP.
Aula sobre Brainstorming 07.09.2022.pptxssuserd654cb1
1) O documento apresenta o método de melhoria de resultados (MMR) e suas etapas, incluindo identificação de problemas, causas raízes e elaboração de planos de melhoria.
2) As etapas do MMR incluem conhecer o problema, quebrar o problema, identificar causas, elaborar planos de melhoria, implementar planos e acompanhar resultados.
3) A identificação de causas envolve brainstorming, priorização e mapeamento das causas raízes dos problemas escolhidos.
O documento discute alocação dinâmica de memória em C++. Apresenta as funções new e delete para alocar e desalocar memória no heap durante a execução do programa. Exemplifica o uso dessas funções para alocar variáveis e vetores.
Mais conteúdo relacionado
Semelhante a Aula_02_-_Listas_com_Vetores-OOP_2011_2.ppt
O documento apresenta uma introdução ao LINQ (Language Integrated Query), incluindo suas principais funcionalidades como consultas declarativas em objetos, XML e bancos de dados SQL, além de exemplos de seu uso.
O documento descreve a classe ArrayList em Java, incluindo como declarar e inicializar uma lista, adicionar e remover elementos usando os métodos add, remove, set e get, e obter o tamanho da lista com o método size.
O documento descreve a classe ArrayList em Java, incluindo como declarar e inicializar uma lista, adicionar e remover elementos usando os métodos add, remove, set e get, e obter o tamanho da lista com o método size.
Este estudo comparou o desempenho de algoritmos de ordenação como Bubble Sort, Insertion Sort, Selection Sort, Merge Sort e Quick Sort em vetores de diferentes tamanhos e ordenações. Os resultados mostraram que Merge Sort e Quick Sort tiveram os melhores tempos de execução, enquanto Bubble Sort teve os piores tempos.
O documento discute filas de prioridade e como implementá-las de forma eficiente. Duas abordagens são descritas: uma que é eficiente para inserções e outra para remoções. Heaps são introduzidos como uma estrutura de dados que pode representar filas de prioridade de forma eficiente.
O documento descreve as listas encadeadas e como representá-las em C. As listas encadeadas representam uma sequência de objetos na memória ligados por ponteiros. Cada elemento da lista contém um campo de dados e um ponteiro para o próximo elemento, permitindo acesso flexível aos itens.
Estruturas de Dados - Listas Encadeadas (Linked List)Erick Petrucelli
Este documento discute estruturas de dados, incluindo estruturas lineares como pilhas, filas e listas, e não-lineares como tabelas de espalhamento e árvores. Ele se concentra em listas encadeadas, definindo uma classe Node para representar cada nó e uma classe LinkedList para implementar operações como inserção e remoção de nós em qualquer posição da lista.
O documento descreve as principais características e funcionalidades de listas em Python, incluindo: (1) listas podem conter valores de diferentes tipos; (2) suportam acesso seqüencial e direto por índice; e (3) operações como indexação, fatiamento, concatenação e repetição.
Fila de prioridade, pilha e fila são estruturas de dados. Uma fila de prioridade ordena itens por chave, com o de menor chave na frente. Itens são inseridos na posição ordenada e o de maior chave é removido.
O documento discute listas ligadas e algoritmos de estrutura de dados. Ele fornece definições de listas ligadas e explica como elas são compostas por nós ligados por ponteiros. O documento também apresenta exercícios sobre como criar estruturas de dados e implementar funções básicas como inserção, remoção e busca em listas ligadas.
15 algoritmos de busca em tabelas - sequencial e binariaRicardo Bolanho
Algoritmos de Busca em Tabelas descreve os principais algoritmos de busca em tabelas: busca sequencial, busca binária e suas variações. A busca sequencial varre toda a tabela linearmente. A busca binária requer que a tabela esteja ordenada e divide a busca em metade a cada iteração.
Listas são estruturas de dados que permitem armazenar e acessar sequencialmente uma coleção de elementos de qualquer tipo. Em Python, listas podem ser criadas usando colchetes e suportam operações como indexação, fatiamento, concatenação e repetição de elementos. Listas são objetos mutáveis que oferecem métodos para adicionar, remover e ordenar elementos.
O documento descreve uma lista encadeada de inteiros em C++. A lista armazena elementos de forma sequencial usando nós ligados por ponteiros. O documento explica a interface da classe lista e como implementar métodos como inserção, remoção e impressão percorrendo a lista através dos nós.
Por que dizemos que Scala é uma linguagem funcional?pmatiello
Scala é considerada uma linguagem funcional porque suporta:
1) Programação funcional através de funções de ordem superior e avaliação atrasada;
2) Transparência referencial evitando efeitos colaterais;
3) Streams permitem gerar sequências infinitas de maneira preguiçosa.
O documento discute coleções em Java, definindo-as como estruturas de dados que armazenam objetos. Apresenta os principais tipos de coleções: listas, conjuntos e mapas, descrevendo suas características e operações básicas como adição, remoção e acesso a elementos. Fornece também detalhes sobre classes e interfaces de coleções no Java.
1) O documento apresenta uma introdução sobre arrays no PHP, definindo-os como mapas ordenados que podem ser utilizados como listas, dicionários ou árvores.
2) São descritas funções para criar, manipular e ordenar arrays, como array(), count(), asort() e array_search().
3) O documento fornece exemplos práticos mostrando como declarar e imprimir diferentes tipos de arrays no PHP.
Semelhante a Aula_02_-_Listas_com_Vetores-OOP_2011_2.ppt (20)
Aula sobre Brainstorming 07.09.2022.pptxssuserd654cb1
1) O documento apresenta o método de melhoria de resultados (MMR) e suas etapas, incluindo identificação de problemas, causas raízes e elaboração de planos de melhoria.
2) As etapas do MMR incluem conhecer o problema, quebrar o problema, identificar causas, elaborar planos de melhoria, implementar planos e acompanhar resultados.
3) A identificação de causas envolve brainstorming, priorização e mapeamento das causas raízes dos problemas escolhidos.
O documento discute alocação dinâmica de memória em C++. Apresenta as funções new e delete para alocar e desalocar memória no heap durante a execução do programa. Exemplifica o uso dessas funções para alocar variáveis e vetores.
O documento discute diferentes tipos de listas encadeadas, incluindo:
1) Pilhas encadeadas e filas encadeadas, que estendem a estrutura de lista encadeada para implementar pilhas e filas;
2) Listas duplamente encadeadas, que permitem navegação bidirecional através dos elementos da lista.
O documento descreve os conceitos de alocação dinâmica de memória em C++. Explica que a memória alocada dinamicamente é obtida do heap e que os operadores new e delete são usados para alocar e liberar essa memória durante a execução do programa.
Listas circulares são úteis para:
1) Modelar rotas circulares como rotas aéreas volta-ao-mundo
2) Escalonamento de processos em sistemas operacionais usando o método round-robin
3) Escalonamento de impressoras em sistemas de impressão controlando várias impressoras em uma fila única
1) O documento discute alocação dinâmica de memória em C usando as funções malloc() e free();
2) malloc() aloca memória no heap de forma dinâmica durante a execução do programa e retorna um ponteiro para essa área, enquanto free() libera a memória alocada anteriormente;
3) A alocação dinâmica permite que programas C alocam memória de forma flexível de acordo com as necessidades em tempo de execução.
O documento descreve os conceitos básicos de listas e como modelar listas utilizando vetores em programação estruturada. As principais ideias apresentadas são:
1) Uma lista é um conjunto de dados ordenados ou não, que podem ocupar espaços de memória contíguos ou não;
2) Listas podem ser modeladas usando vetores, necessitando de um indicador do último elemento e tratamento para quando a lista está cheia;
3) São apresentados algoritmos básicos como adicionar, remover, verificar se a lista está cheia/vazia
O documento discute listas encadeadas, pilhas encadeadas, filas encadeadas e listas duplamente encadeadas. Ele explica como cada estrutura de dados funciona, como são representadas e quais operações podem ser realizadas nelas.
Este documento discute a complexidade de algoritmos e como analisá-la. Explica que a complexidade de tempo de um algoritmo é expressa como uma função do tamanho do problema e que a notação Big-O é usada para descrever o comportamento assintótico predominante. Também apresenta exemplos como ordenação de vetores e mostra que algoritmos para o mesmo problema podem ter diferentes complexidades de tempo.
O documento discute a complexidade de algoritmos e como analisá-la. Explica que a complexidade é medida pelo tempo de execução em função do tamanho do problema e apresenta exemplos de algoritmos com diferentes complexidades como constante, linear, quadrática e cúbica. Também apresenta regras para calcular a complexidade de algoritmos como laços aninhados e instruções consecutivas.
1) A alocação dinâmica de memória permite que um programa aloca memória durante a execução.
2) As funções malloc() e free() são usadas para alocar e liberar memória dinamicamente do heap.
3) A função malloc() aloca memória do heap e retorna um ponteiro void para a área alocada. A função free() libera a memória alocada anteriormente pelo malloc().
Este documento apresenta os objetivos, metodologia, avaliação e programa da disciplina de Estruturas de Dados. Os principais pontos são:
1) O objetivo é ensinar técnicas de organização de dados e manipulação de estruturas de dados usando programação;
2) As aulas serão teóricas e práticas alternadas para aplicação imediata dos conceitos;
3) A avaliação inclui trabalhos, testes e projetos de implementação individual e em grupo.
O documento descreve estruturas de dados básicas utilizando vetores, especificamente pilhas e filas. Ele define estruturas de dados, discute seus aspectos estruturais e funcionais, e fornece exemplos de algoritmos para implementar pilhas e filas usando vetores, incluindo operações como empilhar, desempilhar, incluir e retirar.
Em um mundo cada vez mais digital, a segurança da informação tornou-se essencial para proteger dados pessoais e empresariais contra ameaças cibernéticas. Nesta apresentação, abordaremos os principais conceitos e práticas de segurança digital, incluindo o reconhecimento de ameaças comuns, como malware e phishing, e a implementação de medidas de proteção e mitigação para vazamento de senhas.
PRODUÇÃO E CONSUMO DE ENERGIA DA PRÉ-HISTÓRIA À ERA CONTEMPORÂNEA E SUA EVOLU...Faga1939
Este artigo tem por objetivo apresentar como ocorreu a evolução do consumo e da produção de energia desde a pré-história até os tempos atuais, bem como propor o futuro da energia requerido para o mundo. Da pré-história até o século XVIII predominou o uso de fontes renováveis de energia como a madeira, o vento e a energia hidráulica. Do século XVIII até a era contemporânea, os combustíveis fósseis predominaram com o carvão e o petróleo, mas seu uso chegará ao fim provavelmente a partir do século XXI para evitar a mudança climática catastrófica global resultante de sua utilização ao emitir gases do efeito estufa responsáveis pelo aquecimento global. Com o fim da era dos combustíveis fósseis virá a era das fontes renováveis de energia quando prevalecerá a utilização da energia hidrelétrica, energia solar, energia eólica, energia das marés, energia das ondas, energia geotérmica, energia da biomassa e energia do hidrogênio. Não existem dúvidas de que as atividades humanas sobre a Terra provocam alterações no meio ambiente em que vivemos. Muitos destes impactos ambientais são provenientes da geração, manuseio e uso da energia com o uso de combustíveis fósseis. A principal razão para a existência desses impactos ambientais reside no fato de que o consumo mundial de energia primária proveniente de fontes não renováveis (petróleo, carvão, gás natural e nuclear) corresponde a aproximadamente 88% do total, cabendo apenas 12% às fontes renováveis. Independentemente das várias soluções que venham a ser adotadas para eliminar ou mitigar as causas do efeito estufa, a mais importante ação é, sem dúvidas, a adoção de medidas que contribuam para a eliminação ou redução do consumo de combustíveis fósseis na produção de energia, bem como para seu uso mais eficiente nos transportes, na indústria, na agropecuária e nas cidades (residências e comércio), haja vista que o uso e a produção de energia são responsáveis por 57% dos gases de estufa emitidos pela atividade humana. Neste sentido, é imprescindível a implantação de um sistema de energia sustentável no mundo. Em um sistema de energia sustentável, a matriz energética mundial só deveria contar com fontes de energia limpa e renováveis (hidroelétrica, solar, eólica, hidrogênio, geotérmica, das marés, das ondas e biomassa), não devendo contar, portanto, com o uso dos combustíveis fósseis (petróleo, carvão e gás natural).
As classes de modelagem podem ser comparadas a moldes ou
formas que definem as características e os comportamentos dos
objetos criados a partir delas. Vale traçar um paralelo com o projeto de
um automóvel. Os engenheiros definem as medidas, a quantidade de
portas, a potência do motor, a localização do estepe, dentre outras
descrições necessárias para a fabricação de um veículo
A linguagem C# aproveita conceitos de muitas outras linguagens,
mas especialmente de C++ e Java. Sua sintaxe é relativamente fácil, o que
diminui o tempo de aprendizado. Todos os programas desenvolvidos devem
ser compilados, gerando um arquivo com a extensão DLL ou EXE. Isso torna a
execução dos programas mais rápida se comparados com as linguagens de
script (VBScript , JavaScript) que atualmente utilizamos na internet
2. Lista - Definição
Uma Lista é um conjunto de dados
dispostos e / ou acessáveis em uma
seqüência determinada.
– Este conjunto de dados pode possuir uma
ordem intrínseca (Lista Ordenada) ou não;
– Este conjunto de dados pode ocupar
espaços de memória fisicamente
consecutivos, espelhando a sua ordem, ou
não;
– se os dados estiverem dispersos
fisicamente, para que este conjunto seja
uma lista, ele deve possuir operações e
informações adicionais que permitam que
seja tratado como tal (Lista Encadeada).
3. Vimos dois aspectos
Em um projeto de software, dois aspectos
devem ser considerados:
• de que forma estão organizados os dados,
qual a sua estrutura;
• quais procedimentos atuam sobre estes
dados, que operações podem ser realizadas
sobre eles.
• Vamos ver agora estes aspectos para as
listas.
4. Listas • A Lista é uma estrutura de dados
cujo funcionamento é inspirado
no de uma lista “natural”.
20
55
4
12
89
24
89
55
24
20
12
4 • Uma lista pode ser ordenada ou
não:
• quando for ordenada, pode o ser por
alguma característica intrínseca dos
dados (ex: ordem alfabética);
• pode também refletir a ordem
cronológica (ordem de inserção) dos
dados;
• em Smalltalk, a OrderedCollection é
uma lista cronológica (add:), a
SortedCollection é uma lista ordenada
por um critério interno.
6. Modelagem de Listas utilizando Programação
Estruturada
• Modelaremos a Estrutura de Dados Lista
utilizando a técnica da Programação
Orientada a Objeto, armazenando os dados
em um Vetor (Array).
– Veremos somente algoritmos;
– veremos algoritmos tanto para uma lista
cronológica quanto para uma lista ordenada.
• Procedimento Didático:
– modelagem da Lista e de seus algoritmos usando
Orientação a Objetos;
– exercícios.
7. Modelagem da Lista
• Aspecto Estrutural:
– necessitamos de um vetor para armazenar as informações;
– necessitamos de um indicador da posição atual do último
elemento da lista;
– necessitamos de uma constante que nos diga quando a lista
está cheia e duas outras para codificar erros.
• Pseudo-código:
constantes MAXLISTA = 100;
classe Lista {
inteiro dados[MAXLISTA];
inteiro último;
};
8. Modelagem da Lista
• Aspecto Funcional:
– colocar e retirar dados da lista;
– testar se a lista está vazia ou cheia (dentre
outros testes);
– inicializar a lista e garantir a ordem de seus
elementos.
9. Modelagem da Lista
• Operações: adicionar e retirar dados da lista
– Adiciona(dado)
– AdicionaNoInício(dado)
– AdicionaNaPosição(dado, posição)
– AdicionaEmOrdem(dado)
– Retira()
– RetiraDoInício()
– RetiraDaPosição(posição)
– RetiraEspecífico(dado)
10. Modelagem da Lista
• Operações: testar a lista
–ListaCheia
–ListaVazia
–Posição(dado)
–Contém(dado)
–Igual(dado1, dado2)
–Maior(dado1, dado2)
–Menor(dado1, dado2)
11. Modelagem da Lista
• Operações: inicializar ou limpar a lista
–InicializaLista
–DestróiLista
13. Algoritmo DestróiLista
MÉTODO destróiLista()
início
último <- -1;
fim;
Observação: este algoritmo parece redundante.
Colocar a sua semântica em separado da
inicialização, porém, é importante. Mais tarde
veremos que, utilizando alocação dinâmica de
memória, possuir um destrutor para Lista é muito
importante.
16. Algoritmo Adiciona
• Procedimento:
– testamos se há espaço;
– incrementamos o último;
– adicionamos o novo dado.
• Parâmetros:
– o dado a ser inserido;
4
5
20
55
4
12
89
24
17. Algoritmo Adiciona
Constantes
ERROLISTACHEIA = -1;
ERROLISTAVAZIA = -2;
ERROPOSIÇÃO = -3;
Inteiro MÉTODO adiciona(inteiro dado)
início
SE (listaCheia) ENTÃO
RETORNE(ERROLISTACHEIA)
SENÃO
último <- último + 1;
dados[último] <- dado;
RETORNE(último);
FIM SE
fim;
19. Algoritmo Retira
Inteiro MÉTODO retira()
início
SE (listaVazia) ENTÃO
RETORNE(ERROLISTAVAZIA)
SENÃO
último <- último – 1;
RETORNE(dados[último + 1]);
FIM SE
fim;
Observação: note que aqui se aplicam as mesmas restrições
das diversas variantes do algoritmo desempilha.
20. Algoritmo AdicionaNoInício
• Procedimento:
– testamos se há espaço;
– incrementamos o último;
– empurramos tudo para
trás;
– adicionamos o novo dado
na primeira posição.
• Parâmetros:
– o dado a ser inserido;
4
55
4
12
89
24 5
55
4
12
89
24
20
21. Algoritmo AdicionaNoInício
Inteiro MÉTODO adicionaNoInício(inteiro dado)
variáveis
inteiro posição; //Variável auxiliar para “caminhar”
início
SE (listaCheia) ENTÃO
RETORNE(ERROLISTACHEIA)
SENÃO
último <- último + 1;
posição <- último;
ENQUANTO (posição > 0) FAÇA
//Empurrar tudo para trás
dados[posição] <-
aLista.dados[posição - 1];
posição <- posição - 1;
FIM ENQUANTO
dados[0] <- dado;
RETORNE(0);
FIM SE
fim;
22. Algoritmo AdicionaNoInício
Inteiro MÉTODO adicionaNoInício(inteiro dado)
variáveis
inteiro posição; //Variável auxiliar para “caminhar”
início
SE (listaCheia) ENTÃO
RETORNE(ERROLISTACHEIA)
SENÃO
último <- último + 1;
posição <- último;
ENQUANTO (posição > 0) FAÇA
//Empurrar tudo para trás
dados[posição] <-
aLista.dados[posição - 1];
posição <- posição - 1;
FIM ENQUANTO
dados[0] <- dado;
RETORNE(0);
FIM SE
fim;
23. Algoritmo AdicionaNoInício
Inteiro MÉTODO adicionaNoInício(inteiro dado)
variáveis
inteiro posição; //Variável auxiliar para “caminhar”
início
SE (listaCheia) ENTÃO
RETORNE(ERROLISTACHEIA)
SENÃO
último <- último + 1;
posição <- último;
ENQUANTO (posição > 0) FAÇA
//Empurrar tudo para trás
dados[posição] <-
aLista.dados[posição - 1];
posição <- posição - 1;
FIM ENQUANTO
dados[0] <- dado;
RETORNE(0);
FIM SE
fim;
24. Algoritmo AdicionaNoInício
Inteiro MÉTODO adicionaNoInício(inteiro dado)
variáveis
inteiro posição; //Variável auxiliar para “caminhar”
início
SE (listaCheia) ENTÃO
RETORNE(ERROLISTACHEIA)
SENÃO
último <- último + 1;
posição <- último;
ENQUANTO (posição > 0) FAÇA
//Empurrar tudo para trás
dados[posição] <-
aLista.dados[posição - 1];
posição <- posição - 1;
FIM ENQUANTO
dados[0] <- dado;
RETORNE(0);
FIM SE
fim;
25. Algoritmo RetiraDoInício
• Procedimento:
– testamos se há elementos;
– decrementamos o último;
– salvamos o primeiro
elemento;
– empurramos tudo para a
frente.
5
4
20
55
4
12
89
24
55
4
12
89
24 20
26. Algoritmo RetiraDoInício
Inteiro MÉTODO retiraDoInício()
variáveis
inteiro posição, valor;
início
SE (listaVazia) ENTÃO
RETORNE(ERROLISTAVAZIA)
SENÃO
último <- último - 1;
valor <- dados[0];
posição <- 0;
ENQUANTO (posição <= último) FAÇA
//Empurrar tudo para a frente
dados[posição] <-
aLista.dados[posição + 1];
posição <- posição + 1;
FIM ENQUANTO
RETORNE(valor);
FIM SE
fim;
27. Algoritmo RetiraDoInício
Inteiro MÉTODO retiraDoInício()
variáveis
inteiro posição, valor;
início
SE (listaVazia) ENTÃO
RETORNE(ERROLISTAVAZIA)
SENÃO
último <- último - 1;
valor <- dados[0];
posição <- 0;
ENQUANTO (posição <= último) FAÇA
//Empurrar tudo para a frente
dados[posição] <-
aLista.dados[posição + 1];
posição <- posição + 1;
FIM ENQUANTO
RETORNE(valor);
FIM SE
fim;
28. Algoritmo RetiraDoInício
Inteiro MÉTODO retiraDoInício()
variáveis
inteiro posição, valor;
início
SE (listaVazia) ENTÃO
RETORNE(ERROLISTAVAZIA)
SENÃO
último <- último - 1;
valor <- dados[0];
posição <- 0;
ENQUANTO (posição <= último) FAÇA
//Empurrar tudo para a frente
dados[posição] <-
aLista.dados[posição + 1];
posição <- posição + 1;
FIM ENQUANTO
RETORNE(valor);
FIM SE
fim;
29. Algoritmo RetiraDoInício
Inteiro MÉTODO retiraDoInício()
variáveis
inteiro posição, valor;
início
SE (listaVazia) ENTÃO
RETORNE(ERROLISTAVAZIA)
SENÃO
último <- último - 1;
valor <- dados[0];
posição <- 0;
ENQUANTO (posição <= aLista.último) FAÇA
//Empurrar tudo para a frente
dados[posição] <-
aLista.dados[posição + 1];
posição <- posição + 1;
FIM ENQUANTO
RETORNE(valor);
FIM SE
fim;
30. Algoritmo AdicionaNaPosição
• Procedimento:
– testamos se há espaço e se a posição existe;
– incrementamos o último;
– empurramos tudo para trás a partir da posição;
– adicionamos o novo dado na posição informada.
• Parâmetros:
– o dado a ser inserido;
– a posição onde inserir;
31. Algoritmo AdicionaNaPosição
Inteiro MÉTODO adicionaNaPosição(inteiro dado, inteiro destino)
variáveis
inteiro posição;
início
SE (listaCheia) ENTÃO
RETORNE(ERROLISTACHEIA)
SENÃO
SE (destino > último + 1 OU destino < 0) ENTÃO
RETORNE(ERROPOSIÇÃO);
FIM SE
último <- último + 1;
posição <- último;
ENQUANTO (posição > destino) FAÇA
//Empurrar tudo para trás
dados[posição] <-
aLista.dados[posição - 1];
posição <- posição - 1;
FIM ENQUANTO
dados[destino] <- dado;
RETORNE(aonde);
FIM SE
fim;
32. Algoritmo AdicionaNaPosição
Inteiro MÉTODO adicionaNaPosição(inteiro dado, inteiro destino)
variáveis
inteiro posição;
início
SE (listaCheia) ENTÃO
RETORNE(ERROLISTACHEIA)
SENÃO
SE (destino > último + 1 OU destino < 0) ENTÃO
RETORNE(ERROPOSIÇÃO);
FIM SE
último <- último + 1;
posição <- último;
ENQUANTO (posição > destino) FAÇA
//Empurrar tudo para trás
dados[posição] <-
dados[posição - 1];
posição <- posição - 1;
FIM ENQUANTO
dados[destino] <- dado;
RETORNE(aonde);
FIM SE
fim;
33. Algoritmo AdicionaNaPosição
Inteiro MÉTODO adicionaNaPosição(inteiro dado, inteiro destino)
variáveis
inteiro posição;
início
SE (listaCheia) ENTÃO
RETORNE(ERROLISTACHEIA)
SENÃO
SE (destino > último + 1 OU destino < 0) ENTÃO
RETORNE(ERROPOSIÇÃO);
FIM SE
último <- último + 1;
posição <- último;
ENQUANTO (posição > destino) FAÇA
//Empurrar tudo para trás
dados[posição] <-
dados[posição - 1];
posição <- posição - 1;
FIM ENQUANTO
dados[destino] <- dado;
RETORNE(aonde);
FIM SE
fim;
34. Algoritmo AdicionaNaPosição
Inteiro MÉTODO adicionaNaPosição(inteiro dado, inteiro destino)
variáveis
inteiro posição;
início
SE (listaCheia) ENTÃO
RETORNE(ERROLISTACHEIA)
SENÃO
SE (destino > último + 1 OU destino < 0) ENTÃO
RETORNE(ERROPOSIÇÃO);
FIM SE
último <- último + 1;
posição <- último;
ENQUANTO (posição > destino) FAÇA
//Empurrar tudo para trás
dados[posição] <-
dados[posição - 1];
posição <- posição - 1;
FIM ENQUANTO
dados[destino] <- dado;
RETORNE(aonde);
FIM SE
fim;
35. Algoritmo RetiraDaPosição
• Procedimento:
– testamos se há elementos e se a posição
existe;
– decrementamos o último;
– salvamos elemento na posição;
– empurramos tudo para frente até posição.
• Parâmetros:
– o dado a ser inserido;
– a posição onde inserir;
36. Algoritmo RetiraDaPosição
Inteiro MÉTODO retiraDaPosição(inteiro fonte)
variáveis
inteiro posição, valor;
início
SE (fonte > último OU fonte < 0) ENTÃO
RETORNE(ERROPOSIÇÃO)
SENÃO
SE (listaVazia) ENTÃO
RETORNE(ERROLISTAVAZIA)
SENÃO
último <- último - 1;
valor <- dados[fonte];
posição <- fonte;
ENQUANTO (posição <= último) FAÇA
//Empurrar tudo para frente
dados[posição] <-
dados[posição + 1];
posição <- posição + 1;
FIM ENQUANTO
RETORNE(valor);
FIM SE
FIM SE
fim;
37. Algoritmo RetiraDaPosição
Inteiro MÉTODO retiraDaPosição(inteiro fonte)
variáveis
inteiro posição, valor;
início
SE (fonte > último OU fonte < 0) ENTÃO
RETORNE(ERROPOSIÇÃO)
SENÃO
SE (listaVazia) ENTÃO
RETORNE(ERROLISTAVAZIA)
SENÃO
último <- último - 1;
valor <- dados[fonte];
posição <- fonte;
ENQUANTO (posição <= último) FAÇA
//Empurrar tudo para frente
dados[posição] <-
dados[posição + 1];
posição <- posição + 1;
FIM ENQUANTO
RETORNE(valor);
FIM SE
FIM SE
fim;
38. Algoritmo RetiraDaPosição
Inteiro MÉTODO retiraDaPosição(inteiro fonte)
variáveis
inteiro posição, valor;
início
SE (fonte > último OU fonte < 0) ENTÃO
RETORNE(ERROPOSIÇÃO)
SENÃO
SE (listaVazia) ENTÃO
RETORNE(ERROLISTAVAZIA)
SENÃO
último <- último - 1;
valor <- dados[fonte];
posição <- fonte;
ENQUANTO (posição <= último) FAÇA
//Empurrar tudo para frente
dados[posição] <-
dados[posição + 1];
posição <- posição + 1;
FIM ENQUANTO
RETORNE(valor);
FIM SE
FIM SE
fim;
39. Algoritmo RetiraDaPosição
Inteiro MÉTODO retiraDaPosição(inteiro fonte)
variáveis
inteiro posição, valor;
início
SE (fonte > último OU fonte < 0) ENTÃO
RETORNE(ERROPOSIÇÃO)
SENÃO
SE (listaVazia) ENTÃO
RETORNE(ERROLISTAVAZIA)
SENÃO
último <- último - 1;
valor <- dados[fonte];
posição <- fonte;
ENQUANTO (posição <= último) FAÇA
//Empurrar tudo para frente
dados[posição] <-
dados[posição + 1];
posição <- posição + 1;
FIM ENQUANTO
RETORNE(valor);
FIM SE
FIM SE
fim;
40. Algoritmo RetiraDaPosição
Inteiro MÉTODO retiraDaPosição(inteiro fonte)
variáveis
inteiro posição, valor;
início
SE (fonte > último OU fonte < 0) ENTÃO
RETORNE(ERROPOSIÇÃO)
SENÃO
SE (listaVazia) ENTÃO
RETORNE(ERROLISTAVAZIA)
SENÃO
último <- último - 1;
valor <- dados[fonte];
posição <- fonte;
ENQUANTO (posição <= último) FAÇA
//Empurrar tudo para frente
dados[posição] <-
dados[posição + 1];
posição <- posição + 1;
FIM ENQUANTO
RETORNE(valor);
FIM SE
FIM SE
fim;
41. Algoritmo AdicionaEmOrdem
• Procedimento:
– necessitamos de uma função para
comparar os dados (maior);
– testamos se há espaço;
– procuramos pela posição onde inserir
comparando dados;
– chamamos adicionaNaPosição.
• Parâmetros:
– o dado a ser inserido;
42. Algoritmo Maior
Booleano MÉTODO maior(inteiro dado1, inteiro dado2)
início
SE (dado1 > dado2) ENTÃO
RETORNE(Verdadeiro)
SENÃO
RETORNE(Falso);
FIM SE
fim;
Observação: quando o dado a ser armazenado em uma lista for
algo mais complexo do que um inteiro, a comparação de
precedência não será mais tão simples (ex.: Empregado1 >
Empregado2) e será resultado de um conjunto mais complexo
de operações.
Para deixar os algoritmos de operações sobre lista
independentes do tipo de dado específico armazenado na lista,
usamos uma função deste tipo.
43. Algoritmo AdicionaEmOrdem
Inteiro MÉTODO adicionaEmOrdem(inteiro dado)
variáveis
inteiro posição; //Variável auxiliar para “caminhar”
início
SE (listaCheia) ENTÃO
RETORNE(ERROLISTACHEIA)
SENÃO
posição <- 0;
ENQUANTO (posição <= último E
maior(dado, dados[posição])) FAÇA
//Encontrar posição para inserir
posição <- posição + 1;
FIM ENQUANTO
RETORNE(adicionaNaPosição(dado, posição));
FIM SE
fim;
44. Algoritmo RetiraEspecífico
• Retira um dado específico da lista.
• Procedimento:
– testamos se há elementos;
– testamos se o dado existe e qual sua
posição;
– necessitamos de uma função
Posição(dado);
– chamamos RetiraDaPosição.
• Parâmetros:
– o dado a ser retirado;
45. Algoritmo Posição
Inteiro MÉTODO posição(inteiro dado)
variáveis
inteiro posição;
início
posição <- 0;
ENQUANTO (posição <= último E
NÃO(IGUAL(dado, dados[posição]))) FAÇA
posição <- posição + 1;
FIM ENQUANTO
SE (posição > último) ENTÃO
RETORNE(ERROPOSIÇÃO)
SENÃO
RETORNE(posição);
FIM SE
fim;
46. Algoritmo RetiraEspecífico
Inteiro MÉTODO retiraEspecífico(inteiro dado)
variáveis
inteiro posição;
início
SE (listaVazia) ENTÃO
RETORNE(ERROLISTAVAZIA)
SENÃO
posição <- posição(dado);
SE (posição < 0) ENTÃO
RETORNE(ERROPOSIÇÃO)
SENÃO
RETORNE(retiraDaPosição(posição));
FIM SE
FIM SE
fim;
47. Algoritmos Restantes
• As seguintes funções ficam por conta do
aluno :
– booleano Contém(dado)
– booleano Igual(dado1, dado2)
– booleano Menor(dado1, dado2)
48. Exercício 2:
Trabalho com Passagem de Parâmetros
• Agora você vai fazer um programa que manipula mais de uma
lista;
• como aplicação imaginemos um sistema de contabilidade
simples;
• você vai ter um Plano de Contas constituído por duas listas:
débitos e créditos;
• Será implementado um conjunto de Classes (Lançamento e
ListaContábil) para isso.
49. Modelagem de um Lançamento
• Cada lista de débitos ou créditos é constituída
por lançamentos. Cada lançamento possui:
– um valor real (positivo);
– um nome. Por exemplo, “Pagar proteção à Mafia”
• Estrutura:
Classe Lançamento {
caracter *nome;
real valor;
};
50. Modelagem de um tipo Lista para
Débitos ou Créditos
• Pseudo-código:
constantes MAXLISTA = 100;
Classe ListaContábil {
Lançamento dados[MAXLISTA];
inteiro último;
};
51. Usando (pseudo-código)
• Crie variáveis globais:
ListaContábil débitos, créditos;
• Faça um menu para escolher entre débito e
crédito e crie um lançamento
Lançamento lançamento;
• Utilize os objetos para adicionar elementos na
lista, por exemplo:
débito.adiciona(lançamento);
52. Modelagem da estrutura
1
Lista de débitos ou
de créditos com Vetor
de Estruturas do tipo
Lançamento
Strings lidos
do usuário
e alocados
no Heap
S a b ã o 0
P a s s a g e n s 0
R$ 5,00
R$ 505,00
53. Usando (código “C++”)
• Para ler os dados do lançamento:
ListaContabil debitos, creditos;
char *nome = new char[80];
float valor;
printf("nDigite o nome do lançamento: ");
scanf("n%999[^n]s ", nome);
printf("Digite o valor a ser pago: ");
scanf("%f", &valor);
Lancamento lancamento(nome, valor);
• Depois adiciona na lista desejada:
debito.adiciona(lancamento);