Boa noite a todos.
Estou fazendo um trabalho em c, só que estou com 13 erro que não consigo descobrir qual é… acho que tem a ver com a rotina dele.
Se alguém puder me explicar fico agradecido.
Obrigado…
//<!--------------------------------------------------------------------------->
//<!-- UNIBAN - Universidade Bandeirante de São Paulo -->
//<!-- Instituto Politécnico -->
//<!-- Cursos de Sistema de Informação e Processamento de Dados -->
//<!-- Arquivo : main.cpp -->
//<!-- Função : Manipulação de uma lista encadeada simples. -->
//<!-- Autor : Fabricio da Silva Soares -->
//<!-- : Avenida Brás Leme, 3029 - Campi Marte - Santana -->
//<!-- : São Paulo/SP - Fone (0xx11) 6472-9000 -->
//<!-- : ead@fabricio.inf.br -->
//<!-- Responsável: Fabricio da Silva Soares (ead@fabricio.inf.br) -->
//<!-- Data : 25/03/2008 -->
//<!-- Alteração : 25/03/2008 - Inicialização da programação. -->
//<!-- Revisão : 25/03/2008 - -->
//<!--------------------------------------------------------------------------->
//<!--------------------------------------------------------------------------->
//<!-- Bibliotecas Importadas -->
//<!--------------------------------------------------------------------------->
#include "ListaSimples.hpp"
//<!--------------------------------------------------------------------------->
//<!-- Funções -->
//<!--------------------------------------------------------------------------->
//<!--------------------------------------------------------------------------->
//<!-- Função : int main() -->
//<!-- Parâmetros : int argc, char* argv[] -->
//<!-- Retorno : return 0 -->
//<!-- Objetivo : Função principal do sistema de manipulação de listas. -->
//<!--------------------------------------------------------------------------->
int main(int argc, char* argv[]) {
// Inicializa a lista encadeada simples em memória.
inicializeList();
// Armazena as opções de escolha do usuário.
int option = 0;
// Loop para mostrar as opções do usuário no sistema.
do {
// Limpa a tela do console MS-DOS.
system("cls");
// Cabeçalho principal do sistema de manipulação de listas.
printf("\n\t\tPROGRAMA PARA INSERCAO DE INFORMACOES EM LISTA");
printf("\n\n\t1 - Para inserir informacoes.");
printf("\n\t2 - Para mostrar as informacoes da lista.");
printf("\n\t3 - Para deletar a primeira informacao da lista.");
printf("\n\t4 - Para deletar a ultima informacao da lista.");
printf("\n\t5 - Para obter o tamanho da lista.");
printf("\n\t6 - Para BubbleSort.");
printf("\n\t7 - Para InsertionSort.");
printf("\n\t8 - Para SelectionSort.");
printf("\n\t0 - Para sair do programa.");
printf("\n\n\tDIGITE SUA OPCAO: ");
// Lê a opção selecionada pelo usuário.
scanf("%d", &option);
// Verifica qual a opção escolhida pelo usuário.
switch (option) {
// Verifica se o usuário selecionou as opções 1, 2, 3 ou 4, redireciona para a
// função correspondente.
case 1 : insertData(); break;
case 2 : printList(); break;
case 3 : removeFirst(); break;
case 4 : removeEnd(); break;
case 5 : obtemTamanho(); break;
//case 6 : classifLista(); break;
//case 7 : insertClassif(); break;
//case 8 : searchClassif(); break;
}
// Verifica se o usuário selecionou uma opção diferente de "0" (Zero).
} while (option != 0);
// Destroí toda a lista duplamente encadeada da memória.
destroyList();
// Finaliza o sistema de manipulação de listas duplamente encadeadas.
return 0;
}
//<!--------------------------------------------------------------------------->
//<!-- Função : bool inicializeList() -->
//<!-- Parâmetros : Função sem parâmetros -->
//<!-- Retorno : return true -->
//<!-- Objetivo : Inicializar a lista encadeada simples em memória. -->
//<!--------------------------------------------------------------------------->
bool inicializeList() {
// Todos os ponteiros das estruturas do tipo "nodo" recebem valor igual a nulo.
pFirst = pEnd = pCurrent = NULL;
// Finaliza a função retornando "true".
return true;
}
//<!--------------------------------------------------------------------------->
//<!-- Função : bool destroyList() -->
//<!-- Parâmetros : Função sem parâmetros -->
//<!-- Retorno : return true -->
//<!-- Objetivo : Limpar a lista encadeada simples da memória. -->
//<!--------------------------------------------------------------------------->
bool destroyList() {
// Aponta o ponteiro de manipulação de nós para o inicio da lista.
pCurrent = pFirst;
// Percorre a lista do início ao fim.
while (pCurrent != NULL) {
// O ponteiro inicial avança um nó a frente.
pFirst = pCurrent->pNext;
// Libera a estrutura de dados do tipo "data" do nó atual.
free(pCurrent->pData);
// Libera o nó atual.
free(pCurrent);
// Aponta o ponteiro de manipulação de nós para o início da lista.
pCurrent = pFirst;
}
// Inicializa a lista encadeada simples em memória.
inicializeList();
// Finaliza a função retornando "true".
return true;
}
//<!--------------------------------------------------------------------------->
//<!-- Função : tData *createData() -->
//<!-- Parâmetros : Função sem parâmetros -->
//<!-- Retorno : return pAssist -->
//<!-- Objetivo : Alocar em memória um espaço para a estrutura de dados do -->
//<!-- : tipo "data" e retorna o endereço de memória para um -->
//<!-- : ponteiro do sistema. -->
//<!--------------------------------------------------------------------------->
tData *createData() {
// pAssist: Ponteiro auxiliar utilizado para criar uma estrutura "data".
tData *pAssist;
// Aloca em memória um espaço para a estrutura de dados do tipo "data".
pAssist = (tData *) malloc (sizeof(tData));
// Finaliza a função retornando o ponteiro "pAssist".
return pAssist;
}
//<!--------------------------------------------------------------------------->
//<!-- Função : tNodo *createNodo() -->
//<!-- Parâmetros : Função sem parâmetros -->
//<!-- Retorno : return pAssist -->
//<!-- Objetivo : Alocar em memória um espaço para a estrutura de dados do -->
//<!-- : tipo "nodo" e retorna o endereço de memória para um -->
//<!-- : ponteiro do sistema. -->
//<!--------------------------------------------------------------------------->
tNodo *createNodo() {
// pAssist: Ponteiro auxiliar utilizado para criar uma estrutura "nodo".
tNodo *pAssist;
// Aloca em memória um espaço para a estrutura de dados do tipo "nodo".
pAssist = (tNodo *) malloc (sizeof(tNodo));
// Finaliza a função retornando o ponteiro "pAssist".
return pAssist;
}
//<!--------------------------------------------------------------------------->
//<!-- Função : void insertFirst() -->
//<!-- Parâmetros : Função sem parâmetros -->
//<!-- Retorno : Função sem retorno -->
//<!-- Objetivo : Lê uma informação e insere no Inicio da lista. -->
//<!--------------------------------------------------------------------------->
void insertFirst() {
// pData: Ponteiro para uma estrutura do tipo "data".
tData* pData;
// Armazena as opções de escolha do usuário.
int option = 0;
// Loop para mostrar as opções do usuário no sistema.
do {
// Cria uma estrutura de dados do tipo "data".
pData = createData();
// Informa ao usuário as suas opções no sistema.
printf("\n\tDigite a informacao que deseja inserir na lista: ");
// Lê a informação digitada pelo usuário e insere na estrutura "data".
scanf("%d", &pData->number);
// Insere a informação do usuário no final da lista.
insertFirs(pData);
do {
// Informa ao usuário as suas opções no sistema.
printf("\tDeseja inserir outra informacao? (1)Sim ou (2)Nao: ");
// Lê a opção selecionada pelo usuário.
scanf("%d", &option);
// Verifica se o usuário selecionou uma opção diferente de "1" ou "2".
} while ((option != 1) && (option != 2));
// Verifica se o usuário selecionou uma opção diferente de "2" (Não).
} while (option != 2);
}
//<!--------------------------------------------------------------------------->
//<!-- Função : bool insertFirs() -->
//<!-- Parâmetros : tData *pData -->
//<!-- Retorno : return true -->
//<!-- Objetivo : Inserir uma estrutura "data" no inicio da lista. -->
//<!--------------------------------------------------------------------------->
bool insertFirs(tData *pData) {
// Cria uma estrutura de dados do tipo "nodo".
pCurrent = createNodo();
// Verifica se a lista está vazia.
if (pFirst == NULL) {
// Todos os ponteiros recebem o endereço em memória do único nó na lista.
pFirst = pEnd = pCurrent;
// O ponteiro para o próximo "nodo" aponta para Nulo.
pFirst->pNext = NULL;
// A estrutura de nós atual aponta para a estrutura de dados passada como
// parâmetro da função.
pFirst->pData = pData;
// Finaliza a função retornando "true".
return true;
}
// Caso já exista uma lista em memória.
// O ponteiro "posterior" aponta para o antigo first.
pCurrent->pNext = pFirst;
// A estrutura de nós atual aponta para a estrutura de dados passada como
// parâmetro da função.
pCurrent->pData = pData;
// O atual passa a ser o primeiro na lista.
pFirst = pCurrent;
// Finaliza a função retornando "true".
return true;
}
//<!--------------------------------------------------------------------------->
//<!-- Função : void insertData() -->
//<!-- Parâmetros : Função sem parâmetros -->
//<!-- Retorno : Função sem retorno -->
//<!-- Objetivo : Lê uma informação e insere no final da lista. -->
//<!--------------------------------------------------------------------------->
void insertData() {
// pData: Ponteiro para uma estrutura do tipo "data".
tData* pData;
// Armazena as opções de escolha do usuário.
int option = 0;
// Loop para mostrar as opções do usuário no sistema.
do {
// Cria uma estrutura de dados do tipo "data".
pData = createData();
// Informa ao usuário as suas opções no sistema.
printf("\n\tDigite a informacao que deseja inserir na lista: ");
// Lê a informação digitada pelo usuário e insere na estrutura "data".
scanf("%d", &pData->number);
// Insere a informação do usuário no final da lista.
insertList(pData);
do {
// Informa ao usuário as suas opções no sistema.
printf("\tDeseja inserir outra informacao? (1)Sim ou (2)Nao: ");
// Lê a opção selecionada pelo usuário.
scanf("%d", &option);
// Verifica se o usuário selecionou uma opção diferente de "1" ou "2".
} while ((option != 1) && (option != 2));
// Verifica se o usuário selecionou uma opção diferente de "2" (Não).
} while (option != 2);
}
//<!--------------------------------------------------------------------------->
//<!-- Função : bool insertList() -->
//<!-- Parâmetros : tData *pData -->
//<!-- Retorno : return true -->
//<!-- Objetivo : Inserir uma estrutura "data" no final da lista. -->
//<!--------------------------------------------------------------------------->
bool insertList(tData *pData) {
// Cria uma estrutura de dados do tipo "nodo".
pCurrent = createNodo();
// Verifica se a lista está vazia.
if (pFirst == NULL) {
// Todos os ponteiros recebem o endereço em memória do único nó na lista.
pFirst = pEnd = pCurrent;
// O ponteiro para o próximo "nodo" aponta para Nulo.
pFirst->pNext = NULL;
// A estrutura de nós atual aponta para a estrutura de dados passada como
// parâmetro da função.
pFirst->pData = pData;
// Finaliza a função retornando "true".
return true;
}
// Caso já exista uma lista em memória.
// O ponteiro "posterior" aponta para nulo.
pCurrent->pNext = NULL;
// A estrutura de nós atual aponta para a estrutura de dados passada como
// parâmetro da função.
pCurrent->pData = pData;
// O ponteiro "posterior" do último nó da lista aponta para o ponteiro de
// manipulação de nós.
pEnd->pNext = pCurrent;
// O último nó passa a ser o nó inserido na lista.
pEnd = pCurrent;
// Finaliza a função retornando "true".
return true;
}
//<!--------------------------------------------------------------------------->
//<!-- Função : bool obtemTamano() -->
//<!-- Parâmetros : Função com parâmetros -->
//<!-- Retorno : return tamanho da lista -->
//<!-- Objetivo : Identificar quantos registros tem na lista. -->
//<!--------------------------------------------------------------------------->
bool obtemTamanho() {
// Verifica o tamanho da lista.
int cont = 0;
pCurrent = pFirst;
while (pCurrent != NULL){
cont++;
pCurrent = pCurrent->pNext;
}
// Finaliza a função retornando "A quantidade de ocorrências preenchidas".
printf(" \n Essa Lista possui %d",cont);
getchar();
getchar();
return true;
}
//<!--------------------------------------------------------------------------->
//<!-- Função : bool obtemPosicao() -->
//<!-- Parâmetros : Função com parâmetros -->
//<!-- Retorno : return tamanho da lista -->
//<!-- Objetivo : Identificar quantos registros tem na lista. -->
//<!--------------------------------------------------------------------------->
bool obtemPosicao() {
// Verifica o tamanho da lista.
int number = 16;
int cont = 0;
pCurrent = pFirst;
while (pCurrent !=NULL){
cont++;
if (pCurrent->pData->number == number)
break;
pCurrent = pCurrent->pNext;
}
getchar();
getchar();
// Finaliza a função retornando "A quantidade de ocorrências preenchidas".
printf(" \n A Posicao do Dado esta na posicao %d",cont);
return true;
}
//<!--------------------------------------------------------------------------->
//<!-- Função : bool classifLista() -->
//<!-- Parâmetros : Função sem parametros -->
//<!-- Retorno : nao tem retorno -->
//<!-- Objetivo : Irá classificar a lista em ordem Crescente. -->
//<!--------------------------------------------------------------------------->
//bool classifLista() {
void bubblesort (int v[], int i){
// Classificação da lista.
int aux= 0;
pCurrent = pFirst;
while (pCurrent != NULL){
pCurrent -> pData = v[1]= v[i+1];
v[i+1]= aux;
// v[1]= v[i+1];
//v[i+1]= aux;
}
}
void bubble (int v[], int qtd){
int i;
int trocou;
do{
qtd--;
trocou= 0;
while (pCurrent != NULL){
for (pCurrent ->pData i= 0; i< qtd; i++){
if (pCurrent ->pData= v[1] > v[i+1]){
bubblesort (v, i);
trocou= 1;
}
} while (trocou){
}
}
getchar();
getchar();
// Finaliza a função retornando "A quantidade de ocorrências preenchidas".
printf(" \n Classificação Efetivada.");
return true;
//
}
//<!--------------------------------------------------------------------------->
//<!-- Função : bool insetClassif() -->
//<!-- Parâmetros : Função com parâmetros -->
//<!-- Retorno : return tamanho da lista -->
//<!-- Objetivo : Insere nós na lista. -->
//<!--------------------------------------------------------------------------->
// Insere nós na lista.
#define ELEMENTS 6
void insertion_sort(int x[],int length){
int chave,i;
for(pCurrent ->pData= int j=1;j<length;j++){
chave=x[j];
i=j-1;
while(pCurrent ->pData= x[i]>chave && i>=0){
x[i+1]=x[i];
i--;
}
pCurrent ->pData= x[i+1]=chave;
}
}
int main(){
int A[ELEMENTS]={5,2,4,6,1,3};
int x;
cout<<"Sem ordenadas na lista:"<<endl;
for(x=0;x<ELEMENTS;x++){
cout<<A[x]<<endl;
}
insertion_sort(A,ELEMENTS);
cout<<endl<<"Ordenadas na linha"<<endl;
for(x=0;x<ELEMENTS;x++){
cout<<A[x]<<endl;
}
return 0;
}
getchar();
getchar();
//<!--------------------------------------------------------------------------->
//<!-- Função : bool searchClassif() -->
//<!-- Parâmetros : Função com parâmetros -->
//<!-- Retorno : return tamanho da lista -->
//<!-- Objetivo : Seleciona nós na lista. -->
//<!--------------------------------------------------------------------------->
//Seleção da função Sort
void selectionSort(int *array,int length)
{
int i,j,min,minat;
for(i=0;i<(length-1);i++)
{
minat=i;
min=array[i];
//Seleciona um da lista
for(j=i+1;j<(length);j++)
{
//Ordena em crescente e decrescente
if(min>array[j])
{
//A posição que está o elemento
minat=j;
min=array[j];
}
}
int temp=array[i] ;
array[i]=array[minat];
array[minat]=temp;
getchar();
getchar();
printf ("\n O nó foi selecionado. ");
//<!--------------------------------------------------------------------------->
//<!--------------------------------------------------------------------------->
//<!-- Função : bool removeOnly() -->
//<!-- Parâmetros : Função sem parâmetros -->
//<!-- Retorno : return true ou false -->
//<!-- Objetivo : Remover o único nó da lista encadeada simples. -->
//<!--------------------------------------------------------------------------->
bool removeOnly() {
// Verifica se a lista possui somente um nó ou se está vazia.
if ((pFirst != pEnd) || (pFirst == NULL))
// Finaliza a função retornando "false".
return false;
// Libera as informações do último nó da lista.
free(pEnd->pData);
// Libera o último nó da lista.
free(pEnd);
// Inicializa a lista duplamente encadeada em memória.
inicializeList();
// Informa ao usuário que a função foi executada com sucesso.
printf("\n\tA Lista foi removida com sucesso!");
// Espera o usuário pressionar algum botão do teclado.
getchar();
getchar();
// Finaliza a função retornando "true".
return true;
}
//<!--------------------------------------------------------------------------->
//<!-- Função : bool removeFirst() -->
//<!-- Parâmetros : Função sem parâmetros -->
//<!-- Retorno : return true ou false -->
//<!-- Objetivo : Remover o primeiro nó da lista encadeada simples. -->
//<!--------------------------------------------------------------------------->
bool removeFirst() {
// Verifica se a lista possui somente um nó ou se está vazia.
if ((pFirst == pEnd) || (pFirst == NULL))
// Finaliza a função retornando o valor da função "removeOnly".
return removeOnly();
// O ponteiro de manipulação de nós aponta para o nó "posterior" ao inicio da
// lista.
pCurrent = pFirst->pNext;
// Libera os recursos alocados pela estrutura do tipo "data".
free(pFirst->pData);
// Libera o primeiro nó da lista duplamente encadeada.
free(pFirst);
// O primeiro nó passa a ser o nó posterior da lista.
pFirst = pCurrent;
// Informa ao usuário que a função foi executada com sucesso.
printf("\n\tO dado foi removido com sucesso!");
// Espera o usuário pressionar algum botão do teclado.
getchar();
getchar();
// Finaliza a função retornando "true".
return true;
}
//<!--------------------------------------------------------------------------->
//<!-- Função : bool removeOnly() -->
//<!-- Parâmetros : Função sem parâmetros -->
//<!-- Retorno : return true ou false -->
//<!-- Objetivo : Remover o último nó da lista encadeada simples. -->
//<!--------------------------------------------------------------------------->
bool removeEnd() {
// Verifica se a lista possui somente um nó ou se está vazia.
if ((pFirst == pEnd) || (pEnd == NULL))
// Finaliza a função retornando o valor da função "removeOnly".
return removeOnly();
// Aponta para o primeiro nó da lista.
pCurrent = pFirst;
// Percorre toda a lista em busca do último nó.
while (pCurrent->pNext != pEnd)
pCurrent = pCurrent->pNext;
// O "pEnd" passa a apontar para o penúltimo nó.
pEnd = pCurrent;
// Aponta para o nó que será excluído da lista.
pCurrent = pCurrent->pNext;
// Libera os recursos alocados pela estrutura do tipo "data".
free(pCurrent->pData);
// Libera o último nó da lista duplamente encadeada.
free(pCurrent);
// O último nó aponta para o vazio.
pEnd->pNext = NULL;
// Informa ao usuário que a função foi executada com sucesso.
printf("\n\tO dado foi removido com sucesso!");
// Espera o usuário pressionar algum botão do teclado.
getchar();
getchar();
// Finaliza a função retornando "true".
return true;
}
//<!--------------------------------------------------------------------------->
//<!-- Função : bool printList() -->
//<!-- Parâmetros : Função sem parâmetros -->
//<!-- Retorno : return true ou false -->
//<!-- Objetivo : Imprimir o conteúdo da lista duplamente encadeada. -->
//<!--------------------------------------------------------------------------->
bool printList() {
// Verifica se a lista duplamente encadeada é vazia.
if (pFirst == NULL)
// Finaliza a função retornando "false".
return false;
// Informações passadas para o usuário.
printf("\n\tOs dados na lista sao:");
// Aponta para o inicio da lista.
pCurrent = pFirst;
// Percorre toda a lista duplamente encadeada.
while (pCurrent != NULL) {
// Imprime o valor da estrutura de dados "data".
printf(" %d", pCurrent->pData->number);
// Aponta para o próximo nó da lista.
pCurrent = pCurrent->pNext;
}
// Espera o usuário pressionar algum botão do teclado.
getchar();
getchar();
// Finaliza a função retornando "true".
return true;
}EDIT - Por favor, use as tags [ code ]