Também olhem o link do professor da UFMG passado em um post anterior.
//criar um nó, seria criar o primeiro elemento da lista
// mais na frente vamos ter TlistaEnc l e TlistaEnc *l
// Vamos usar o l* quando queremos manipular um dado(inserir, remover…), pois estamos pegando o endereço dele.
// Vamos usar o l quando queremos queremos pegar uma cópia do valor e quem vai ser manipulado é a cópia.
int instrucoes(void){
int i;
system(“cls”);
printf(“Editor de Listas\n”
“————————\n”
” (0) Criar Lista\n”
” (1) Exibir Lista\n”
” (2) Inserir\n”
” (3) Remover\n”
” (4) Exibir Elemento\n”
” (5) Exibir Posicao\n”
” (6) Esvaziar Lista\n”
” (7) Sair\n\n “
” Opcao -> “);
scanf(“%d%*c”,&i);
return i;
}
int verificaSePossivel(int x){
return (x==1); // se for == 1 ele retorna verdadeiro != 0, senão ele retorna 0.
}
//como estamos criando o nó precisamos do endereço dele, então colocamos o l(sem asterisco), pois vamos alocar um espaço na memória.
/****************************************************************************
Criamos esta função para conseguir criar um nó para manipularmos encadeamente
1)Enviamos como argumento uma lista (TlistaEnc l), e não o seu endereço,
isto é apenas o molde.
2)logo em seguida com o molde podemos alocar dinamicamente a memória
necessária para o nó
****************************************************************************/
int criarNo(TlistaEnc *l){
if(l=(no*)malloc(sizeof(no)!=0)) return 1;
return 0;
}
/****************************************************************************
Criamos esta função para conseguirmos Criar um lista
1)Para criar uma lista precisamos aponta-la para null
2)Informamos o endereço de memória de uma lista “TlistaEnc *l”
3)Como temos que mudar o valor da variável da lista temos que usar o * antes
da variável para modificar o valor no endereço(TlistaEnc *l) fornecido
para o valor null, com o intuito de criar a lista.
****************************************************************************/
void criarLista(TlistaEnc *l){
//preparando o elemento para adicionar = colocar a lista apontando para null
*l=null;
}
/****************************************************************************
Criamos esta função para conseguir verificar se a lista está Vazia
1)Ela verifica se l==null, se for retorna 1 se não for retorna 0.
2)E a função retorna o valor retornado da comparação l==null(1 ou 0)
****************************************************************************/
int listaVazia(TlistaEnc l){
return(l==null); /* forma não compacta if(l==null){ return 1; } return 0; */
}
/****************************************************************************
Criamos esta função para conseguirmos o tamanho da estrutura.
1)insere na função uma variavel com o endereço da lista
2)É verificado se no inicio aponta para nulo, se for
retorna o tamanho 0, pois a lsita está vazia
3)Retorna o tamanho, qualquer que for, se ela estiver vazia
retorna 0 se possuir valores retorna o valor
***************************************************************************/
int tamanhoDaLista(TlistaEnc *l){
int tamanho =0;
while(l!=null){
l=l->prox;
tamanho+;
}
return tamanho;
}
/****************************************************************************
Criamos esta função para conseguirmos retornar o valor na posição
solicitada
1)Informamos uma lista sem o “*”, pois não vamos modificar o seu valor
apenas queremos verificar seua existência, então iremos ler os dados.
2)Informamos a posição desejada a encontrar o dado.
3)Enviamos o endereço de uma variável para que possamos retornar dentro
dela o valor a ser amostrado. Praticamente copiamos para o endereço
dessa variável o valor do dado nesta posição.
4)É verificado se a posição é válida: posição não pode ser menor que 0
e não pode ser maior que o tamanho da lista, pois se é maior que a
lista não existe!(ou existe lixo de memória!).
5)Também é verificado se a lista não está vazia passando a função
listaVazia( umaLista ),criada acima para verificação.
6)Processo de busca se dá quando verificamos se ela não é nula e se
a posicaoAtual de busca é menor que a posição solicitada para busca
7)Enquanto ocorre o processo de busca sempre enquanto for diferente de
nulo ou posicaoAtual menor que posição ele captura o valor do próximo
e executa a incrementação da posição atual(posicaoAtual++).
8)Por fim ele vai inserir o valor de lista->dado naa variável dadoFornecido
*****************************************************************************/
int elementoNaPosicao(TlistaEnc l, int posicao, int *dadoFornecido){
int posicaoAtual=1;
if(posicao<=0 || listaVazia(l) || posicao>tamanhoDaLista(l) ) return 0; //return 0 = erro, não pode…
while( (l!=null) && (posicaoAtual<posicao) {
l = l->prox;
posicaoAtual++;
}
*dadoFornecido = l->dado;
return 1;
}
/****************************************************************************
Criamos esta função para conseguir procurar a posicao de um elemento(um dado)
fornecido. comparando-os(dado fornecido com os dados da lista).
1)Informamos a lista(TlistaEnc l), como só informamos e não vamos modificar
enviamos apenas o l sem o simbolo “*” e um dado para comparação(int dado).
2)Comerçamos com a posicao=1, pois é a primeira posição a ser pesquizada,
lembre que posição é diferente de indice!!!
3)Comparamos se a lista é vazia, que entra na condição de invalidez, não
possui este item informado na lista,pois a lista não possui nenhum item
ai tem que retornar 0 = não possui este item na lista!!!!
4)O loop é feito da seguinte maneira, enquanto a lista for diferente
de nulo(isto significa “Enquanto a lista existir”).
5)A comparação é feita da seguinte maneira, se o dado for diferente do dado
da lista capture o endereço da proximo nó(l=l->prox) e incremente 1 na
posicao, pois estamos agora em outra posição da lista. Se encontrarmos
significa que o dado fornecido não é diferente do dado atual
(dado==l->dado), ele entra no else agora e retorna sua posição. Caso não
encontre ele não entra no else, acaba a lista e ativa a única condição do
while(funciona até chegar no final da lista) e acaba retornando 0.
****************************************************************************/
int posicaoDoElemento(TlistaEnc l , int dado){
int posicao=1;
if(listaVazia(l)) return 0;
while(l!=null){
if (dado!=l->dado){
l=l->prox;
posicao++;
}
else return posicao;
}
return 0; // o retorno 0 tanto pode ser pq a lista está vazia, quanto que não existe na lista, pois se ela está
// vazia não existe na lista, não existe nada.
}
/****************************************************************************
Criamos essa função para poder inserirmos um dado (int dado) em uma estrutura
possui 3 condições :
–> (1a) Inserir em uma lista vazia.
–> (2a) Inserir na primeira posição.
–> (3a) Inserir em qualquer posição.
–>Para todas as as condições precisamos:
enviar um ponteiro da lista (TlistaEnc *l), uma posição de entrada de dado
(int posicao) e o dado propiarmente dito (int dado).
um no devemos criar(no *novo), e um tipo lista(TlistaEnc *l), com “*”, pois
vamos adicionar(manipular) um valor. E por fim um contador aonde iremos
ter a posicao atual em procura na lista.
1)Inserir em uma lista vazia :
1.1)Precisamos verificar se ela está vazia, se ela estiver podemos continuar
1.2)Verificamos se a posicao é menor e igul a 0, pois não existe.
1.3)Obedecendo essas regras acima podemos agora adicionar o dado.
1.4)Primeiro adicionamos ao no auxiliar em sua parte de dado o dado enviado
(int dado)
1.5)Depois setamos o valor de prox(ponteiro da estrutura) em null, para que
ele possa depois adicionar mais valores a lista.
1.6)Agora ao conteudo(*nome da lista) da lista(TlistaEnc *l) iremos adicionar
o novo nó criado para isto.
2)Inserir Na Primeira Posição
2.1)Verificamos se a posição é igual a 1, pois é a condição.
2.2)Alocamos memória para o no.
2.3)Tendo memória livre, podemos continuar, agora capiturando o dado para
o espaço reservado a dados no no auxiliar
2.4)Apontamos agora o no auxiliar para quem a lista aponta(*l)
//obs. se quiserssemos apontar para a lista seria l, mas como queremos
//apontar para quem ela aponta colocamos o *l.
2.5)agora temos que colocar a lista para apontar para o no auxiliar, jun-
tando os elementos e ordenando a lista.
3)Inserir em qualquer Posição
3.1)Criamos uma lista auxiliar para usar agora nessa opção, primeiramente
colocamos ela para apontar para quem a lista enviada(TlistaEnc l) aponta
3.2)Depois utilizamos o while para percorrer a lista auxiliar com intuito de
chegar na posição anterior(contador<posicao) a qual queremos adicionar
o elemento, e verificamos se a auxiliar não é null, pois teria acabado
os elementos da lista. A variável contador serve apénas para chegar uma
posição antes da desejada.
3.3)Alocamos memória para o nó auxiliar(no* novo).
3.4)Jogamos o dado fornecido(int dado) para a posição de dados do
nó auxiliar (novo->dado).
3.5)Mandamos este nó auxiliar apontar para quem a lista auxiliar aponta
>>queremos adicionar no indice 3
>>lista->n1->n2->n3->n4
>>listaAux=>n2->n3->n4 lista auxiliar se torna n2 ela tem o dado e
>> controle de quem aponta
//noAux=>listaAux=>n2->n3->n4 === noAux->n3->n4
3.6)Agora para finalizar apotamos a lista Auxiliar(TlistaEnc aux) para o no
auxiliar(no * novo), selando a lista.vizualmente é assim :
// lista=>n1->( listaAux == n2 )->n3->n4
noAux-|
// lista=>n1->( listaAux == n2 ) (se desfaz pois agora listaAux aponta para noAux) n3->n4
|—————————————————–> noAux-|
>>terminando assim :
// lista=>n1->( listaAux == n2 ) n3->n4
|—-> noAux-|
>> Lista aponta sempre para n1, lista auxiliar se transforma em n2
>> (posição antecedente a que queremos inserir), em seguida o nó Auxiliar
>> que aponta para n3 e n3 aponta para n4, terminando a lsita encadeada.
>> lista=>n1->( listaAux == n2 ) —>noAux–> n3->n4
****************************************************************************/
int inserirElemento(TlistaEnc *l, int posicao, int dado){
no * novo;
TlistaEnc aux;
int contador=1;
if(listaVazia(*l)){
if ( (posicao!=1) || novo=(no*)malloc(sizeof(no))==null){ return 0; }
else {
novo->dado = dado;
novo->prox ==null;
*l=novo;
return 1;
}
}
if(posicao==1){
if(novo=(no*)malloc(sizeof(no))==null){ return 0; }
else {
novo->dado = dado;
novo->prox = *l;
*l = novo;
return 1;
}
}
// preciso só chegar na posição anterior &&(contador<posicao)
aux = *l; // diz que o auxiliar é igual a lista (uma cópia)
while( (aux!=null) &&(contador<posicao) ){
aux = aux->prox;
contador++;
}
if(novo = (no*)malloc(sizeof(no))==null)
return 0;
else{
novo->dado = dado;
novo->prox = aux->prox;
aux->prox = novo;
}
}
/****************************************************************************
Criamos essa função para poder remover um dado (int *dado) em uma estrutura
colocamos o * em dado pois queremos devolver este dado para que ele não seja
perdido, apenas removido, podemos querer manipula-lo mais a frente.
Criamos uma list auxiliar(TlistaEnc aux) e um nó(no * anterior)
criamos um contador para controlar a posição certa para a remoção
1)Primeiro verificamos se a lista não está vazia,pois em lista vazia não
possui membros a serem deletados.
2)colocamos nossa lista auxiliar(TlistaEnc aux) apontar para quem nossa
lista enviada aponta(TlistaEnc *l).
3)Percorremos a lista enviada com a lista auxiliar, e com o um nó chamado
anterior(no *anterior), capituramos a variavel anterior e com ela podemos
criar o elo com outros termos da lista, e em seguida a lista auxiliar anda
para a posição de remorção.
4)Verificamos se lista Auxiliar não é nula
5)Jogamos a nossa variavel dado o valor a ser removido(aux->dado)
6)Mas se a posição de remorção for 1 só precisamos pedir para a lista apontar
para a lista auxiliar proxima posição, removendo o da 1a posição.
7)Removendo o auxiliar da memória damos um free(auxiliar).
****************************************************************************/
int removerElemento(TlistaEnc *l, int posicao, int *dado){
TlistaEnc aux;
no * anterior;
int contador=1;
if (listaVazia(*l)||posicao<0) return 0 ;
aux = *l;
while( (aux!=null)&& (contador<posicao) ){
anterior = aux;
aux=aux->prox;
contador++;
}
if(aux==null) return 0; // ele chegou no ultimo elemento e passou para o próximo
*dado = aux->dado;
if(posicao==1){ *l= aux->prox; }
else{ anterior->prox = aux->prox; }
free(aux);
return 1;
//região de memória sempre dê um free!!! != de variavel comum
}
/****************************************************************************
Criamos essa função para poder remover um dado (int *dado) em uma estrutura
A única coisa exclusiva criada foi um inteiro indice para imprimir o indice
de cada elemento da lista.
1)verificamos se a lsita está vazia.
2)criamos algo para aparecer antes e imprimimos no while toda a lista
3)A unica preoculpação é no while colocar a lista = lista->proximo, para
incrmentar uma posição e passar para o próximo elemento.
****************************************************************************/
int imprimirLista(TlistaEnc l){
int indice =1;
if(listaVazia(l)) return 0;
printf(“———————-\n”);
printf(“Indice | Dado \n”);
while(!listaVazia(l)){
printf(“%d | %d\n”,indice,l->dado); //verificar se indice ++ imprime o indice depois incrementa
indice++;
// está alterando a nova, pois ela é uma cópia, pois não tem o *
l=l->prox;
}
printf(“———————-\n”);
return 1;
}
