#include "dados.

h"

// retorna um novo no
no *lista::inserir(lista *&l, int &valor){

int novo_valor;
std::cout << "Valor> ";
std::cin >> novo_valor;

//aloca memoria para o novo no

no *tmp = new no();

tmp->v = novo_valor;

//salva o endereco do proximo no - NULL (ta no fim da lista)

tmp->proximo = NULL;
tmp->anterior = NULL;

l->tamanho += 1; //aumentou um no lista

return tmp; //retorna novo no
}

// retorna um novo no
void lista::novovalor(lista *&l){

int novo_valor;
std::cout << "Valor> ";
std::cin >> novo_valor;

l->inserir(l, novo_valor);

void lista::remover(lista *&l){

int n;

no *tmp = new no();

tmp = l->inicio;

std::cout << "Excluir Valor> ";

std::cin >> n;

while (tmp){
if( tmp->v != n){
tmp = tmp->proximo;
continue;
}

no *apagando = tmp;
 if (apagando == l->inicio){ // primeiro ponto da lista
if( l->tamanho == 1){ // um unico no na lista
free(apagando);
l->inicio = NULL;
l->fim = NULL;
}else{
l->inicio = l->inicio->proximo;
l->inicio->anterior = NULL;
free(apagando);
}
l->tamanho -= 1;
}else if (apagando == l->fim){ // apagando no final
l->fim = l->fim->anterior;
l->fim->proximo = NULL;
free(apagando);
l->tamanho -= 1;
}else{ // apagando no meio.
tmp->anterior->proximo = tmp->proximo;
tmp->proximo->anterior = tmp->anterior;
free(apagando);
l->tamanho -= 1;
}
tmp = tmp -> proximo;
}
}

void no::apaga_recursivamente(no *&atual){

if(atual->proximo){
atual->apaga_recursivamente(atual->proximo);
}
free(atual);
}

void lista::ordenar(lista *&l){

no *tmp = new no();

tmp = l->inicio;

lista *ordenada = new lista(); // lista para armazenar a lista original

ordenada
//lista::lista(&ordenada); //inicia lista ordenada do tipo lista

//lista [a]<->[c]<->[a]<->[d]<->[x]<->[c]<->[b]<->[a]<->[k]<->[e]
//listar auxiliar [a]<->[a]<->[a]<->[c]<->[c]<->[d]<->[e]...

//ordenar a lista em uma lista temporaria.

while(tmp){
if ( ordenada->inicio == NULL ){ // lista temporaria vazia, inclui v
no inicio
ordenada->inicio = ordenada->inserir(ordenada, tmp->v);
ordenada->fim = ordenada->inicio;
}else if( tmp->v <= ordenada->inicio->v ){ // novo no é menor que o
no inicial, inclui no inicio.
no *novo = ordenada->inserir(ordenada, tmp->v);
novo->proximo = ordenada->inicio;
ordenada->inicio->anterior = novo;
ordenada->inicio = novo;
}else if( tmp->v >= ordenada->fim->v ){ // novo no é maior que o
ultimo no, inclui no final.
no *novo = ordenada->inserir(ordenada, tmp->v);
novo->anterior = ordenada->fim;
ordenada->fim->proximo = novo;
ordenada->fim = novo;
}else{ // novo no ta no meio da lista, procurar onde incluir
no *tmp_ordenado = ordenada->inicio;
while(tmp_ordenado->proximo != NULL){
if (tmp_ordenado->v <= tmp->v && tmp_ordenado->proximo->v >
tmp->v){ // o no atual é menor, e o atual->prox é maior. incluir no mio
dele
break;
}
tmp_ordenado = tmp_ordenado -> proximo;
}
no *novo = inserir(ordenada, tmp->v);
novo->proximo = tmp_ordenado->proximo;
novo->anterior = tmp_ordenado;
novo->proximo->anterior = novo;
tmp_ordenado->proximo = novo;
}
tmp = tmp->proximo;
}

//imprimindo a lista ordenada

no *tmp_ordenado = ordenada->inicio;
while(tmp_ordenado){
std::cout << tmp_ordenado->v;
tmp_ordenado = tmp_ordenado->proximo;
}

std::cout << " \n ";

tmp_ordenado->apaga_recursivamente(ordenada->inicio); // libera memoria

void lista::listar(lista *&l){

int n; //vai listar so onde v == n

no *tmp = l->inicio;
int posAtual = 1;

std::cout << "Listar Valor> ";

std::cin >> n;

//se entrar com l para listar todos, senao lista so o solicitado

if( n == 'l'){
 while (tmp){
std::cout << "\n Valor " << posAtual << "> " << tmp->v;
tmp = tmp->proximo;
posAtual += 1;
}
}else{
while (tmp){
//compara as strings - retorna 0 se encontrar
if( tmp->v == n){
std::cout << "\n Valor " << posAtual << "> " << tmp->v;
}
tmp = tmp->proximo;
posAtual += 1;
}
}
}

int lista::menu(lista *&l){

int opcao;

std::cout << "\n\n[1]incluir [2]remover [3]listar [4]ordenar [5]sair>

";

//escolher opcao do usario

std::cin >> opcao;

switch(opcao){

case 1: l->novovalor(l);break;
case 2: l->remover(l);break;
case 3: l->listar(l);break;
case 4: l->ordenar(l);break;
case 5: break;
default: std::cout << "Opcao Invalida> ";
}

return opcao;
}

int main(){

lista *l = new lista();

//lista.lista(&l);

//loop para sempre retornar ao menu apos executar

while(l->menu(l) != 5);