Dificuldade em fazer uma lista dupla encadeada [RESOLVIDO]
1. Dificuldade em fazer uma lista dupla encadeada [RESOLVIDO]
lendel
(usa Linux Mint)
Enviado em 22/08/2021 - 11:10h
#include <cstdlib>
#include <iostream>
#include <iomanip>
#include "Funcoes22049.h"
using namespace std;
int main (int argc, char *argv[])
{
ListaDupla list1;
list1.insere(1,0), list1.insere(2,1), list1.insere(5,2), list1.insere(7,3);
cout << "tamanho: " << list1.tamanho() << endl;
int y = 0;
cout << "Quantidade: " << list1.quantidade(y) << endl;
cout << "Lista" << endl;
list1.imprimeLista();
list1.retira(2);
cout << "tamanho: " << list1.tamanho() << endl;
int x = 0;
list1.obtem(x,1);
cout << "Valor: " << 5 << " posição: 3" << endl;
cout << "Lista" << endl;
list1.imprimeLista();
if(list1.tamanho() == 0)
cout << "lista está vazia" << endl;
else{
cout << "tamanho: " << list1.tamanho() << endl;
};
cout << "Quantidade: " << list1.quantidade(y) << endl;
}
#include "Funcoes22049.h"
#include <iomanip>
#include <iostream>
using namespace std;
ListaDupla::ListaDupla()
{
primeiro = NULL;
ultimo = NULL;
}
void ListaDupla::limpa()
{
Elemento *z = primeiro; // z aponta para o início.
// Percorrer toda a lista para desalocar os elementos.
Elemento *y = NULL;
while(z != 0){
y = z->prox;
delete z;
z = y;
}
primeiro = 0; // Indica que a lista está vazia.
}
bool ListaDupla::vazia()
{
return primeiro == 0;
}
ListaDupla::~ListaDupla()
{
limpa();
}
bool ListaDupla::insere(Valor x, int pos)
{
if(pos < 0) return false; // pos inválida.
else{
Elemento *y, *z, *w;
// y é o ponteiro anterior e z o atual.
y = 0; // y não aponta para ninguém.
z = primeiro; // z aponta para o primeiro elemento.
int p = 0; // Indice do primeiro elemento.
while(p < pos && z != 0){ // A posição é válida.
p++; // Próximo indice.
y = z; // O anterior é o atual.
z = z->prox; // O atual é o proximo da lista.
}
if(z == 0 && p == pos || z != 0){ // pos. inválida.
w = new Elemento; // Tenta criar um novo elem.
if(w != 0){ // Elemento criado.
w->val = x;
if(pos == 0) { // Ins. prim. pos.
w->ant = NULL;
w->prox = primeiro;
primeiro->ant = w;
primeiro = w;
}else{ // Inserção demais posições.
w->prox = y->prox; // anterior aponta para o proximo
y->prox = w;
w->ant = y;
if(z != NULL)
z->ant = w;
}
while(z->prox != NULL) // procuramos o ultimo elemento
z = z->prox;
ultimo = z;
quant++;
return true;
}
else return false; // Elemento não criado.
}
else return false; // Inserção em posição inválida.
}
}
bool ListaDupla::retira(int pos)
{
// Verifica se é uma posição válida para remover.
if(pos < 0 || pos >= tamanho())
return false; // Não é válida, não removeu.
else{ // É válida.
Elemento *y = primeiro; // y aponta p/ o primeiro.
if(pos == 0) { // Remoção na primeira posição.
// Removeremos o primeiro elemento da lista.
primeiro = y->prox; // O segundo será o primeiro.
primeiro->ant = NULL; // anterior do primeiro aponta para nulo
delete y; // Remove o primeiro elemento da memoria.
quant--;
}
else{ // A posição para remoção não é a primeira.
// Percorre a lista até a posição da remoção.
for(int i = 1; i < pos; i++){
y = y->prox;}
Elemento *z = y->prox; // z aponta p/ o próximo.
if(z->prox == NULL){ // z aponta para o ultimo
y->prox = NULL; // y passa apontar para ultimo
}
else { // y aponta para o proximo
y->prox=z->prox;
y->prox->ant = z->ant;
}
while(y->prox != NULL) // procuramos o ultimo elemento
y = y->prox;
ultimo = y;
delete z; // Remove o elemento da memória.
quant--;
}
return true; // Indica que removeu o valor.
}
}
int ListaDupla::tamanho()
{
if(primeiro == 0) return 0; // Está vazia.
else{ // Não está vazia.
int c = 1; // Inicializa o contador c em 1.
Elemento *z = primeiro; // z aponta para o primeiro.
// Percorre a lista até o último elemento.
while(z->prox != 0){
c++;
z = z->prox;
}
return c; // Retorna o tamanho contado por c.
}
}
bool ListaDupla::obtem(Valor &x, int pos)
{
if(pos < 0 || pos >= tamanho())
return false; // Não é válida, não obteve.
else{ // E válida.
Elemento *z = primeiro; // z aponta para o primeiro.
// Percorre a lista até a posição pos do elem. x.
for(int i = 0; i < pos; i++) z = z->prox;
x = z->val; // Volta em x o valor (referência).
return true; // Indica que obteve o valor.
}
}
void ListaDupla::imprimeLista(){
Elemento *z = primeiro;
cout << "L -> ";
while(z != NULL){
cout << z->val << " -> ";
z = z->prox;
}
cout << "NULL" << endl;
Elemento *w = ultimo;
cout << "L -> ";
while(w != NULL){
cout << w->val << " -> ";
w = w->ant;
}
cout << "NULL" << endl;
}
int ListaDupla::quantidade(Valor &q)
{
return quant;
}
#ifndef LISTADUPLA_H
#define LISTADUPLA_H
//#include "Funcoes22047.h"
class ListaDupla //: public Lista
{
private:
typedef int Valor;
struct Elemento
{
Valor val; // Material da seção.
Elemento *prox; // Aponta para proximo.
Elemento *ant; // Aponta para anterior.
};
int quant = 0;
Elemento *primeiro; // Aponte para o primeiro.
Elemento *ultimo; // Aponte para o ultimo.
public:
// Construtor padrão:
ListaDupla();
// Destruidor da lista:
~ListaDupla();
// Insere o valor x na posição pos da lista:
bool insere(Valor x, int pos);
// Retire o elemento da posição pos da lista:
bool retira(int pos);
// Retorna o tamanho da lista:
int tamanho();
// Indica se a lista está vazia:
bool vazia();
// Remove todos os elementos da lista:
void limpa();
// Obtém o valor x da posição pos da lista:
bool obtem(Valor &x, int pos);
// Imprimir os dados da lista em suas posições
void imprimeLista();
// Obtém a quantidade inserida na lista
int quantidade(Valor &q);
};
#endif
resultado ao copilar
Falha de segmentação (imagem do núcleo gravada)
O problema maior se encontra na função inserir e na função retirar
A maior comunidade GNU/Linux da América Latina! Artigos, dicas, tutoriais, fórum, scripts e muito mais. Ideal para quem busca auto-ajuda.
Site hospedado por:
