Array
(
)

Problemas ordenação!!!

Rafaman
   - 02 nov 2006

Alguém poderia me ajudar dando uma olhada no meu codigo...

Estou precisando de fazer um programa que ordene uma lista duplamente encadeada: usando, Quick, merge, bolha, seleção e inserção.

1-No bolha ele não gera o txt, pra falar a verdade ele nunca executa as ultimas linhas;

2-O seleção tá ordenando beleza;

3-O inserção tem algum problema mas estou a procura sem problemas;

4- o merge já fiz refiz e tô batalhando em cima dele e nada sempre agarro.


5- O quick... sem comentários, não consegui implementar usando lista até agora, sempre da erro.

Nota: Minha lista é duplamente encadeada, será que na hora de criar a lista e inserir tá faltando alguma coisa? pois o meu merge tá perfeito... Ao compilar faça um arquivo txt com algumas linhas de palavras para ver os resultados...


//--------------------------------------------------------------------

#include<iostream.h>
include<conio.h>
include<stdio.h>
include <string>
include <fstream.h>
include <time.h>

//----------------------------------------------------------------------

typedef struct Nodo* Apontador;
typedef string TipoElemento;
//-----------------------------------------------------------------

struct Nodo {
TipoElemento elemento;
Apontador prox;
Apontador antes;
};
//-----------------------------------------------------------------

class TipoLista {
private:
Apontador z; //aponta pra cauda da lista
Apontador cabeca;
Apontador primeiro;
Apontador ultimo;
unsigned int tamanho; // número de elementos da Lista

public:

void fazListaVazia();
void insereNoUltimo(TipoElemento x );
int obterTamanho();
void imprime();
void selecao();
void insercao();
void bolha();
void quick();
void particao(unsigned int esq, unsigned int dir, unsigned int& i, unsigned int& j);
void ordena(unsigned int esq, unsigned int dir);
void merge();
Apontador mergeSort(Apontador primeiro);
Apontador intercala(Apontador p1, Apontador p2);



}; // fim classe TipoLista

void Tipoream.h>
#include <time.h>

//----------------------------------------------------------------------

typedef struct Nod----------

typedef struct Nodo* Apontador;
typedef string TipoElemento;
//-----------------------------------------------------------------

struct Nodo {
TipoElemento elemento;
Apontador prox;
Apontador antes;
};
//-----------------------------------------------------------------

class TipoLista {
private:
Apontador z; //aponta pra cauda da lista
Apontador cabeca;
Apontador primeiro;
Apontador ultimo;
unsigned int tamanho; // número de elementos da Lista

public:

void fazListaVazia();
void insereNoUltimo(TipoElemento x );
int obterTamanho();
void imprime();
void selecao();
void insercao();
void bolha();
void quick();
void particao(unsigned int esq, unsigned int dir, unsigned int& i, unsigned int& j);
void ordena(unsigned int esq, unsigned int dir);
void merge();
Apontador mergeSort(Apontador primeiro);
Apontador intercala(Apontador p1, Apontador p2);



}; // fim classe TipoLista

void Tipoream.h>
#include <time.h>

//----------------------------------------------------------------------

typedef struct Nodo* Apontador;
typedef string TipoElemento;
//-----------------------------------------------------------------

struct Nodo {
TipoElemento elemento;
Apontador prox;
Apontador antes;
};
//-----------------------------------------------------------------

class TipoLista {
private:
Apontador z; //aponta pra cauda da lista
Apontador cabeca;
Apontador primeiro;
Apontador ultimo;
unsigned int tamanho; // número de elementos da Lista

public:

void fazListaVazia();
void insereNoUltimo(TipoElemento x );
int obterTamanho();
void imprime();
void selecao();
void insercao();
void bolha();
void quick();
void particao(unsigned int esq, unsigned int dir, unsigned int& i, unsigned int& j);
void ordena(unsigned int esq, unsigned int dir);
void merge();
Apontador mergeSort(Apontador primeiro);
Apontador intercala(Apontador p1, Apontador p2);



}; // fim classe TipoLista

void TipoLista::fazListaVazia(){
z=new Nodo;
cabeca = new Nodo;
cabeca->prox = z;
cabeca->antes = NULL;
primeiro = cabeca;
ultimoo* Apontador;
typedef string TipoElemento;
//-----------------------------------------------------------------

struct Nodo {
TipoElemento elemento;
Apontador prox;
Apontador antes;
};
//-----------------------------------------------------------------

class TipoLista {
private:
Apontador z; //aponta pra cauda da lista
Apontador cabeca;
Apontador primeiro;
Apontador ultimo;
unsigned int tamanho; // número de elementos da Lista

public:

void fazListaVazia();
void insereNoUltimo(TipoElemento x );
int obterTamanho();
void imprime();
void selecao();
void insercao();
void bolha();
void quick();
void particao(unsigned int esq, unsigned int dir, unsigned int& i, unsigned int& j);
void ordena(unsigned int esq, unsigned int dir);
void merge();
Apontador mergeSort(Apontador primeiro);
Apontador intercala(Apontador p1, Apontador p2);



}; // fim classe TipoLista

void TipoLista::fazListaVazia(){
z=new Nodo;
cabeca = new Nodo;
cabeca->prox = z;
cabeca->antes = NULL;
primeiro = cabeca;
ultimo = primeiro;
z->prox = z;
tamanho = 0;
}

void TipoLista::insereNoUltimo(TipoElemento x ) { //insere o elemento x na última posição

Apontador aux;
aux = new Nodo;// aloca
aux->elemento = x;// insere elemento no nodo criado
ultimo->prox = aux;// insere o nodo na lista
aux->antes = ultimo; // aponta o auxiliar para o ultimo nodo
tamanho = tamanho + 1;// atualiza
ultimo = ultimo->prox;
ultimo->prox = z;
primeiro = cabeca->prox;
// garante que primeiro aponta corretamente quando
} // o primeiro elemento é inserido na lista


int TipoLista::obterTamanho(){
return tamanho;
}

void TipoLista::imprime(){
Apontador aux;
for (aux = cabeca->prox; aux != z; aux = aux->prox)
cout<<´\n´ << aux->elemento;
}

void TipoLista::selecao(){
Apontador aux, aux2¬2Lista::fazListaVazia(){
z=new Nodo;
cabeca = new Nodo;
cabeca->prox = z;
cabeca->antes = NULL;
primeiro = cabeca;
ultimo = primeiro;
z->prox = = primeiro;
z->prox = z;
tamanho = 0;
}

void TipoLista::insereNoUltimo(TipoElemento x ) { //insere o elemento x na última posição

Apontador aux;
aux = new Nodo;// aloca
aux->elemento = x;// insere elemento no nodo criado
ultimo->prox = aux;// insere o nodo na lista
aux->antes = ultimo; // aponta o auxiliar para o ultimo nodo
tamanho = tamanho + 1;// atualiza
ultimo = ultimo->prox;
ultimo->prox = z;
primeiro = cabeca->prox;
// garante que primeiro aponta corretamente quando
} // o primeiro elemento é inserido na lista


int TipoLista::obterTamanho(){
return tamanho;
}

void TipoLista::imprime(){
Apontador aux;
for (aux = cabeca->prox; aux != z; aux = aux->prox)
cout<<´\n´ << aux->elemento;
}

void TipoLista::selecao(){
Apontador aux, aux2¬2Lista::fazListaVazia(){
z=new Nodo;
cabeca = new Nodo;
cabeca->prox = z;
cabeca->antes = NULL;
primeiro = cabeca;
ultimo = primeiro;
z->prox = z;
tamanho = 0;
}

void TipoLista::insereNoUltimo(TipoElemento x ) { //insere o elemento x na última posição

Apontador aux;
aux = new Nodo;// aloca
aux->elemento = x;// insere elemento no nodo criado
ultimo->prox = aux;// insere o nodo na lista
aux->antes = ultimo; // aponta o auxiliar para o ultimo nodo
tamanho = tamanho + 1;// atualiza
ultimo = ultimo->prox;
ultimo->prox = z;
primeiro = cabeca->prox;
// garante que primeiro aponta corretamente quando
} // o primeiro elemento é inserido na lista


int TipoLista::obterTamanho(){
return tamanho;
}

void TipoLista::imprime(){
Apontador aux;
for (aux = cabeca->prox; aux != z; aux = aux->prox)
cout<<´\n´ << aux->elemento;
}

void TipoLista::selecao(){
Apontador aux, aux2, aux3;
string temp;
aux = primeiro;
aux2 = aux;
aux3 = aux;

while (aux != z){
while (aux3 != z){
if (strcmpi (aux3->elemento.begin(),aux2->elemento.begin¬z;
tamanho = 0;
}

void TipoLista::insereNoUltimo(TipoElemento x ) { //insere o elemento x na última posição

Apontador aux;
aux = new Nodo;// aloca
aux->elemento = x;// insere elemento no nodo criado
ultimo->prox = aux;// insere o nodo na lista
aux->antes = ultimo; // aponta o auxiliar para o ultimo nodo
tamanho = tamanho + 1;// atualiza
ultimo = ultimo->prox;
ultimo->prox = z;
primeiro = cabeca->prox;
// garante que primeiro aponta corretamente quando
} // o primeiro elemento é inserido na lista


int TipoLista::obterTamanho(){
return tamanho;
}

void TipoLista::imprime(){
Apontador aux;
for (aux = cabeca->prox; aux != z; aux = aux->prox)
cout<<´\n´ << aux->elemento;
}

void TipoLista::selecao(){
Apontador aux, aux2, aux3;
string temp;
aux = primeiro;
aux2 = aux;
aux3 = aux;

while (aux != z){
while (aux3 != z){
if (strcmpi (aux3->elemento.begin(),aux2->elemento.begin())<0)
aux2 = aux3;
aux3 = aux3->prox;
}

temp = aux2->elemento;
aux2->elemento = aux->elemento;
aux->elemento = temp;
aux = aux->prox;
aux3 = aux;
aux2 = aux;
}

ofstream oSelecao(´Selecao.txt´); //abre o arquivo
for (aux = cabeca->prox; aux != z; aux = aux->prox){
oSelecao << aux->elemento << ´\n´;
}

}

void TipoLista::insercao(){
Apontador aux, aux2;
string daVez;
aux=primeiro->prox;

while(aux!=z){

daVez=aux->elemento;
primeiro->elemento=daVez;
aux2=aux->antes;

while(strcmpi(aux2->elemento.begin(),daVez.begin())>0){
aux2->prox->elemento = aux2->elemento;
aux2=aux2->antes;
}
aux3;
string temp;
aux = primeiro;
aux2 = aux;
aux3 = aux;

while (aux != z){
while (aux3 != z){
if (strcmpi (aux3->elemento.begin(),aux2->elemento.begin())<0)
aux2 =28))<0)
aux2 = aux3;
aux3 = aux3->prox;
}

temp = aux2->elemento;
aux2->elemento = aux->elemento;
aux->elemento = temp;
aux = aux->prox;
aux3 = aux;
aux2 = aux;
}

ofstream oSelecao(´Selecao.txt´); //abre o arquivo
for (aux = cabeca->prox; aux != z; aux = aux->prox){
oSelecao << aux->elemento << ´\n´;
}

}

void TipoLista::insercao(){
Apontador aux, aux2;
string daVez;
aux=primeiro->prox;

while(aux!=z){

daVez=aux->elemento;
primeiro->elemento=daVez;
aux2=aux->antes;

while(strcmpi(aux2->elemento.begin(),daVez.begin())>0){
aux2->prox->elemento = aux2->elemento;
aux2=aux2->antes;
}
aux3;
string temp;
aux = primeiro;
aux2 = aux;
aux3 = aux;

while (aux != z){
while (aux3 != z){
if (strcmpi (aux3->elemento.begin(),aux2->elemento.begin())<0)
aux2 = aux3;
aux3 = aux3->prox;
}

temp = aux2->elemento;
aux2->elemento = aux->elemento;
aux->elemento = temp;
aux = aux->prox;
aux3 = aux;
aux2 = aux;
}

ofstream oSelecao(´Selecao.txt´); //abre o arquivo
for (aux = cabeca->prox; aux != z; aux = aux->prox){
oSelecao << aux->elemento << ´\n´;
}

}

void TipoLista::insercao(){
Apontador aux, aux2;
string daVez;
aux=primeiro->prox;

while(aux!=z){

daVez=aux->elemento;
primeiro->elemento=daVez;
aux2=aux->antes;

while(strcmpi(aux2->elemento.begin(),daVez.begin())>0){
aux2->prox->elemento = aux2->elemento;
aux2=aux2->antes;
}

aux2->prox->elemento=daVez;
aux=aux->prox;

}

ofstream oInsercao(´Insercao.txt´); //abre o arquivo
for (aux = cabeca->prox; aux != z; aux = aux->prox){
oInsercao << aux->elemento << ´\n´;
}
}

vo aux3;
aux3 = aux3->prox;
}

temp = aux2->elemento;
aux2->elemento = aux->elemento;
aux->elemento = temp;
aux = aux->prox;
aux3 = aux;
aux2 = aux;
}

ofstream oSelecao(´Selecao.txt´); //abre o arquivo
for (aux = cabeca->prox; aux != z; aux = aux->prox){
oSelecao << aux->elemento << ´\n´;
}

}

void TipoLista::insercao(){
Apontador aux, aux2;
string daVez;
aux=primeiro->prox;

while(aux!=z){

daVez=aux->elemento;
primeiro->elemento=daVez;
aux2=aux->antes;

while(strcmpi(aux2->elemento.begin(),daVez.begin())>0){
aux2->prox->elemento = aux2->elemento;
aux2=aux2->antes;
}

aux2->prox->elemento=daVez;
aux=aux->prox;

}

ofstream oInsercao(´Insercao.txt´); //abre o arquivo
for (aux = cabeca->prox; aux != z; aux = aux->prox){
oInsercao << aux->elemento << ´\n´;
}
}

void TipoLista::bolha(){
int i,j;
Apontador aux, aux2;
string temp;
bool troca;
i=tamanho;

while (i>0){
troca=0;
aux2=primeiro;
j=0;
while (j<i){
if (aux2->prox!=z){
if (strcmpi (aux2->elemento.begin(), aux2->prox->elemento.begin())>0){
temp = aux2->elemento;
aux2->elemento=aux2->prox->elemento;
aux2->prox->elemento=temp;
troca=1;
}
}
aux2=aux2->prox;
j++;
}
if (!troca) return;
i--;
}

ofstream oBolha(´Bolha.txt´); //abre o arquivo
aux = primeiro;
while (aux != z){
oBolha << aux->elemento << ´\n´;
aux = aux->prox;
}

}


aux2->prox->elemento=daVez;
aux=aux->prox;

}

ofstream oInsercao(´Insercao.txt´); //abre o arquivo
for (aux = cabeca->prox; aux != z; aux = aux->prox){
oInsercao << aux->elemento << ´\n´;
}
}

void TipoLista::bolha(){
iid TipoLista::bolha(){
int i,j;
Apontador aux, aux2;
string temp;
bool troca;
i=tamanho;

while (i>0){
troca=0;
aux2=primeiro;
j=0;
while (j<i){
if (aux2->prox!=z){
if (strcmpi (aux2->elemento.begin(), aux2->prox->elemento.begin())>0){
temp = aux2->elemento;
aux2->elemento=aux2->prox->elemento;
aux2->prox->elemento=temp;
troca=1;
}
}
aux2=aux2->prox;
j++;
}
if (!troca) return;
i--;
}

ofstream oBolha(´Bolha.txt´); //abre o arquivo
aux = primeiro;
while (aux != z){
oBolha << aux->elemento << ´\n´;
aux = aux->prox;
}

}


aux2->prox->elemento=daVez;
aux=aux->prox;

}

ofstream oInsercao(´Insercao.txt´); //abre o arquivo
for (aux = cabeca->prox; aux != z; aux = aux->prox){
oInsercao << aux->elemento << ´\n´;
}
}

void TipoLista::bolha(){
int i,j;
Apontador aux, aux2;
string temp;
bool troca;
i=tamanho;

while (i>0){
troca=0;
aux2=primeiro;
j=0;
while (j<i){
if (aux2->prox!=z){
if (strcmpi (aux2->elemento.begin(), aux2->prox->elemento.begin())>0){
temp = aux2->elemento;
aux2->elemento=aux2->prox->elemento;
aux2->prox->elemento=temp;
troca=1;
}
}
aux2=aux2->prox;
j++;
}
if (!troca) return;
i--;
}

ofstream oBolha(´Bolha.txt´); //abre o arquivo
aux = primeiro;
while (aux != z){
oBolha << aux->elemento << ´\n´;
aux = aux->prox;
}

}


void TipoLista::ordena(unsigned int esq, unsigned int dir){

}
void TipoLista::quick(){

}

void TipoLista::particao(unsigned int esq, unsigned int dir, unsigned int& i, unsigned int& j){

}

//-----------------------------------------------------------------------------

void TipoLista::merge()
{nt i,j;
Apontador aux, aux2;
string temp;
bool troca;
i=tamanho;

while (i>0){
troca=0;
aux2=primeiro;
j=0;
while (j<i){
if (aux2->prox!=z){
if (strcmpi (aux2->elemento.begin(), aux2->prox->elemento.begin())>0){
temp = aux2->elemento;
aux2->elemento=aux2->prox->elemento;
aux2->prox->elemento=temp;
troca=1;
}
}
aux2=aux2->prox;
j++;
}
if (!troca) return;
i--;
}

ofstream oBolha(´Bolha.txt´); //abre o arquivo
aux = primeiro;
while (aux != z){
oBolha << aux->elemento << ´\n´;
aux = aux->prox;
}

}


void TipoLista::ordena(unsigned int esq, unsigned int dir){

}
void TipoLista::quick(){

}

void TipoLista::particao(unsigned int esq, unsigned int dir, unsigned int& i, unsigned int& j){

}

//-----------------------------------------------------------------------------

void TipoLista::merge()
{
Apontador aux;
primeiro = mergeSort (primeiro);
cabeca->prox = primeiro;
ultimo = primeiro;
while (ultimo->prox != z)
{
ultimo = ultimo->prox;
}

ofstream oMerge(´Merge.txt´); //abre o arquivo
aux = primeiro;
while (aux != z){
oMerge << aux->elemento << ´\n´;
aux = aux->prox;
}
}
//-----------------------------------------------------------------------------

Apontador TipoLista::intercala( Apontador p1, Apontador p2)
{
Apontador pf; // aponta para a lista final ordenada
pf = z;// z aponta para o nodo cauda da lista e
do
{
if ( strcmpi(p1->elemento.begin(),p2->elemento.begin())<=0)
{
D
void TipoLista::ordena(unsigned int esq, unsigned int dir){

}
void TipoLista::quick(){

}

void TipoLista::particao(unsigned int esq, unsigned int dir, unsigned int& i, unsigned int& j){

}

//-----------------------------------------------------------------------------

void TipoLista::merge()
{
Apontador aux;
p
Apontador aux;
primeiro = mergeSort (primeiro);
cabeca->prox = primeiro;
ultimo = primeiro;
while (ultimo->prox != z)
{
ultimo = ultimo->prox;
}

ofstream oMerge(´Merge.txt´); //abre o arquivo
aux = primeiro;
while (aux != z){
oMerge << aux->elemento << ´\n´;
aux = aux->prox;
}
}
//-----------------------------------------------------------------------------

Apontador TipoLista::intercala( Apontador p1, Apontador p2)
{
Apontador pf; // aponta para a lista final ordenada
pf = z;// z aponta para o nodo cauda da lista e
do
{
if ( strcmpi(p1->elemento.begin(),p2->elemento.begin())<=0)
{
D
void TipoLista::ordena(unsigned int esq, unsigned int dir){

}
void TipoLista::quick(){

}

void TipoLista::particao(unsigned int esq, unsigned int dir, unsigned int& i, unsigned int& j){

}

//-----------------------------------------------------------------------------

void TipoLista::merge()
{
Apontador aux;
primeiro = mergeSort (primeiro);
cabeca->prox = primeiro;
ultimo = primeiro;
while (ultimo->prox != z)
{
ultimo = ultimo->prox;
}

ofstream oMerge(´Merge.txt´); //abre o arquivo
aux = primeiro;
while (aux != z){
oMerge << aux->elemento << ´\n´;
aux = aux->prox;
}
}
//-----------------------------------------------------------------------------

Apontador TipoLista::intercala( Apontador p1, Apontador p2)
{
Apontador pf; // aponta para a lista final ordenada
pf = z;// z aponta para o nodo cauda da lista e
do
{
if ( strcmpi(p1->elemento.begin(),p2->elemento.begin())<=0)
{
pf->prox = p1;
pf = p1;
p1 = p1->prox;
}
else
{
pf->prox = p2;
pf = p2;
p2 = p2->prox;
}
}
while (pf != z);

pf = z->prox;
z->prox = z;

return pf;
}
//---------------------------------------------------------------------------rimeiro = mergeSort (primeiro);
cabeca->prox = primeiro;
ultimo = primeiro;
while (ultimo->prox != z)
{
ultimo = ultimo->prox;
}

ofstream oMerge(´Merge.txt´); //abre o arquivo
aux = primeiro;
while (aux != z){
oMerge << aux->elemento << ´\n´;
aux = aux->prox;
}
}
//-----------------------------------------------------------------------------

Apontador TipoLista::intercala( Apontador p1, Apontador p2)
{
Apontador pf; // aponta para a lista final ordenada
pf = z;// z aponta para o nodo cauda da lista e
do
{
if ( strcmpi(p1->elemento.begin(),p2->elemento.begin())<=0)
{
pf->prox = p1;
pf = p1;
p1 = p1->prox;
}
else
{
pf->prox = p2;
pf = p2;
p2 = p2->prox;
}
}
while (pf != z);

pf = z->prox;
z->prox = z;

return pf;
}
//-----------------------------------------------------------------------------

Apontador TipoLista::mergeSort( Apontador primeiro )
{
Apontador esq, dir;

if ( primeiro->prox == z ){ // alcançou o fim da lista: termina

return primeiro;
}
else
{
esq = primeiro;
dir = primeiro->prox;
dir = dir->prox;
dir = dir->prox;


while ( dir != z )
{
primeiro = primeiro->prox;
dir = dir->prox;
dir = dir->prox;
}
dir = primeiro->prox;
primeiro->prox = z;
return intercala( mergeSort(esq), mergeSort(dir) );
}
}

//------------------------------------------ pf->prox = p1;
pf = p1;
p1 = p1->prox;
}
else
{
pf->prox = p2;
pf = p2;
p2 = p2->prox;
}
}
while (pf != z);

pf = z->prox;
z->prox = z;

return pf;
}
//-----------------------------------------------------------------------------

Apontador TipoLista::m--

Apontador TipoLista::mergeSort( Apontador primeiro )
{
Apontador esq, dir;

if ( primeiro->prox == z ){ // alcançou o fim da lista: termina

return primeiro;
}
else
{
esq = primeiro;
dir = primeiro->prox;
dir = dir->prox;
dir = dir->prox;


while ( dir != z )
{
primeiro = primeiro->prox;
dir = dir->prox;
dir = dir->prox;
}
dir = primeiro->prox;
primeiro->prox = z;
return intercala( mergeSort(esq), mergeSort(dir) );
}
}

//------------------------------------------ pf->prox = p1;
pf = p1;
p1 = p1->prox;
}
else
{
pf->prox = p2;
pf = p2;
p2 = p2->prox;
}
}
while (pf != z);

pf = z->prox;
z->prox = z;

return pf;
}
//-----------------------------------------------------------------------------

Apontador TipoLista::mergeSort( Apontador primeiro )
{
Apontador esq, dir;

if ( primeiro->prox == z ){ // alcançou o fim da lista: termina

return primeiro;
}
else
{
esq = primeiro;
dir = primeiro->prox;
dir = dir->prox;
dir = dir->prox;


while ( dir != z )
{
primeiro = primeiro->prox;
dir = dir->prox;
dir = dir->prox;
}
dir = primeiro->prox;
primeiro->prox = z;
return intercala( mergeSort(esq), mergeSort(dir) );
}
}

//------------------------------------------------------------------------------


void main(){

TipoLista lista1;
lista1.fazListaVazia();

char buffer[1000];

ifstream fin(´teste.txt´);

while (fin.getline(buffer, 1000)) {
lista1.insereNoUltimo(buffer);
}

clock_t cl = clock();

//para testar cada um é so tirar o ´//´ da frente da linha de ordenação:

//lista1.bolha(); //OK
//lista1.insercao.rgeSort( Apontador primeiro )
{
Apontador esq, dir;

if ( primeiro->prox == z ){ // alcançou o fim da lista: termina

return primeiro;
}
else
{
esq = primeiro;
dir = primeiro->prox;
dir = dir->prox;
dir = dir->prox;


while ( dir != z )
{
primeiro = primeiro->prox;
dir = dir->prox;
dir = dir->prox;
}
dir = primeiro->prox;
primeiro->prox = z;
return intercala( mergeSort(esq), mergeSort(dir) );
}
}

//------------------------------------------------------------------------------


void main(){

TipoLista lista1;
lista1.fazListaVazia();

char buffer[1000];

ifstream fin(´teste.txt´);

while (fin.getline(buffer, 1000)) {
lista1.insereNoUltimo(buffer);
}

clock_t cl = clock();

//para testar cada um é so tirar o ´//´ da frente da linha de ordenação:

//lista1.bolha(); //OK
//lista1.insercao();
//lista1.selecao(); //OK
//lista1.quick();
//lista1.merge();

lista1.imprime();


cout<<´\nLevou ´<<((double)(clock()-cl))/CLK_TCK<<´ segundos\n´;
cout<<´\nPara Ordenar ´<<lista1.obterTamanho()<<´ elementos\n´;


getch();
}