Ayuda con este codigo porfavor es urgente!!

nabuconodonosor
26 de Noviembre del 2009
Buenas espero puedan ayudarme

nabuconodonosor
26 de Noviembre del 2009
Necesito ayuda con este codigo..!! necesito ordenar nombres y apellidos primero apellidos y luego si hay aoellidos iguales por nombre... el burbuja me lo hace pero el Quicksort no lo hace.. solo ordena los apellidos spero puedan ayudarme!!! =( aki les dejo el cogio.. >>>>


/*Proyecto >>> Metodos de ordenamiento
Equipo # 2
>>Realiza un programa que de la siguiente estructura ordene primero por apellido,
luego por nombre mediante Burbuja, heapsort y quicksort,
todos por orden ascendente, también se debe tomar en cuenta que todos los
nombres y apellidos deben tener la primera letra mayúscula.
a. NOTA: NO DEBE HABER APELLIDOS Y NOMBRES REPETIDOS.*/

#include <iostream>
#include <cstring>
#include <conio.h>

using namespace std;

//Estructura para los Datos
struct datospersonales
{
unsigned int edad;
char nombre[20];
char apellido[20];
}persona[100];

///Variables Globales////
//_______________________________________________________
bool lleno=false;
bool mayuscula=false;
int n,indice=0;
char nombre[20];
char apellido[20];


//Mostrar el Arreglo completo
//_______________________________________________________________________________
void visualizar()
{
system("cls");
cout<<" <<<<<<<<<Ordenamiento>>>>>>>>>>> "<<endl<<endl<<endl;

cout<<"Lista de Personas Registradas...."<<endl<<endl;
cout<<"En este Momento existen "<<indice<<" personas registradas"<<endl<<endl;

cout<<" -------------------------------------------------- "<<endl;
cout<<"| Apellido | Nombre | Edad | "<<endl;
cout<<" -------------------------------------------------- "<<endl;

for (int n=0;n<indice;n++)
cout<<persona[n].apellido<<"t"<<"t"<<persona[n].nombre<<"t"<<"t"<<"t"<<persona[n].edad<<endl;

cout<<endl<<"Presione una tecla para continuar.....";
getch();
}
//__________________________________________________________________________________
void Agregar_persona()
{
/*system("cls");
cout<<" <<<<<<<<<Ordenamiento>>>>>>>>>>> "<<endl<<endl<<endl;

//copiamos directamente el nombre y el apellido
strcpy(persona[indice].nombre,nombre);
strcpy(persona[indice].apellido,apellido);

cout<<"Introduzca la edad de "<<nombre<<" "<<apellido<<": "<<endl;
cin>>persona[indice].edad;

lleno=true; //decimos q el arreglo ya tiene al menos un registro
indice++;//incrementamos el indice o numero de persona registradas*/

strcpy(persona[0].nombre,"Maria");
strcpy(persona[0].apellido,"Lopez");
persona[0].edad=23;

strcpy(persona[1].nombre,"Jose");
strcpy(persona[1].apellido,"Perez");
persona[1].edad=45;

strcpy(persona[2].nombre,"Claudia");
strcpy(persona[2].apellido,"Medina");
persona[2].edad=67;

strcpy(persona[3].nombre,"Teresa");
strcpy(persona[3].apellido,"Lopez");
persona[3].edad=68;

strcpy(persona[4].nombre,"Samuel");
strcpy(persona[4].apellido,"Medina");
persona[4].edad=34;

strcpy(persona[5].nombre,"Zoila");
strcpy(persona[5].apellido,"Mesa");
persona[5].edad=22;

indice=6;
lleno=true;

cout<<endl<<"Los datos han sido almacenados satisfactoriamente....";
getch();
}

//Buscamos si existe el registro, si no existe agrega los demas datos
//___________________________________________________________________
void validar_existencia()
{
/* bool existe=false;

if (mayuscula==true)
{
for(int i=0;i<indice;i++)
if ((strcmp(nombre,persona[i].nombre)==0)&&(strcmp(apellido,persona[i].apellido)==0))
{
cout<<endl<<"ATENCION: "<<nombre<<" "<<apellido<<" ya esta registrado...";
getch();
existe=true;
}
if (existe==false)*/
Agregar_persona();
// }
}

/*Aqui perdimos los datos (nombre y apellido) para luego validar su
primera letra comienza en mayuscula*/
void pedir_datos()
{
/* char incialnombre;
char inicialape;

system("cls");
cout<<" <<<<<<<<<Ordenamiento>>>>>>>>>>> "<<endl<<endl<<endl;
cout<<"Introduzca el Nombre: "<<endl;
cin>>nombre;
incialnombre=nombre[0];
nombre[0]=toupper(incialnombre);
cout<<endl<<"Introduzca el Apellido de "<<nombre<<": "<<endl;
cin>>apellido;
inicialape=apellido[0];
apellido[0]=toupper(inicialape);
mayuscula=true;*/

validar_existencia();
}

//Metodo de Ordenamiento Burbuja...!!!!//////////
//_________________________________________________________
void Burbuja()
{
int i,n=0;
char auxnombre[20];
char auxapellido[20];
unsigned int auxedad=0;

visualizar();

//Primero Ordenamos los Apellidos______________________________________
for (i=0;i<indice;i++)
for(int j=(i+1);j<indice;j++)
if((strcmp(persona[i].apellido,persona[j].apellido))>=0)
{
strcpy(auxnombre,persona[i].nombre);
strcpy(auxapellido,persona[i].apellido);
auxedad=persona[i].edad;
strcpy(persona[i].nombre,persona[j].nombre);
strcpy(persona[j].nombre,auxnombre);
strcpy(persona[i].apellido,persona[j].apellido);
strcpy(persona[j].apellido,auxapellido);
persona[i].edad=persona[j].edad;
persona[j].edad=auxedad;
visualizar();
n++;
}
visualizar();

//Ahora por Nombre___________________________
for (i=0;i<indice;i++)
for(int j=(i+1);j<indice;j++)
if(((strcmp(persona[i].nombre,persona[j].nombre))>=0) && ((strcmp(persona[i].apellido,persona[j].apellido))>=0))
{
strcpy(auxnombre,persona[i].nombre);
auxedad=persona[i].edad;
strcpy(persona[i].nombre,persona[j].nombre);
strcpy(persona[j].nombre,auxnombre);
persona[i].edad=persona[j].edad;
persona[j].edad=auxedad;
visualizar();
n++;
}
visualizar();

cout<<endl<<endl<<" Lista Ordenada en "<<n<<" intercambios...";
getch();
}

//Metodo de ordenamiento heap o por monticulos!
//__________________________________________________________________________________
void Heapsort(int n)
{
//falta este
}

int dividir (int inicio, int fin)
{
int izq,der;
char indice3[20];
char auxnombre[20];
char auxapellido[20];
unsigned int auxedad=0;

izq=inicio;
der=fin;

visualizar();

strcpy(indice3,persona[inicio].nombre);

//por Apellido
strcpy(indice3,persona[inicio].apellido);
izq = inicio;
der = fin;
visualizar();
//Mientras no se crucen los índices
while (izq < der)
{
while (strcmp(persona[der].apellido,indice3)>0) der--;
while ((izq < der) && (strcmp(persona[izq].apellido,indice3)<=0)) izq++;
// Si todavia no se cruzan los indices seguimos intercambiando
if(izq < der)
{
strcpy(auxnombre,persona[izq].nombre);
strcpy(auxapellido,persona[izq].apellido);
auxedad=persona[izq].edad;
strcpy(persona[izq].nombre,persona[der].nombre);
strcpy(persona[der].nombre,auxnombre);
strcpy(persona[izq].apellido,persona[der].apellido);
strcpy(persona[der].apellido,auxapellido);
persona[izq].edad=persona[der].edad;
persona[der].edad=auxedad;
}
}
strcpy(auxnombre,persona[der].nombre);
strcpy(auxapellido,persona[der].apellido);
auxedad=persona[der].edad;
strcpy(persona[der].nombre,persona[inicio].nombre);
strcpy(persona[inicio].nombre,auxnombre);
strcpy(persona[der].apellido,persona[inicio].apellido);
strcpy(persona[inicio].apellido,auxapellido);
persona[der].edad=persona[inicio].edad;
persona[inicio].edad=auxedad;
visualizar();
n++;
return der;

//por nombre
strcpy(indice3,persona[inicio].nombre);
izq = inicio;
der = fin;
visualizar();
//Mientras no se crucen los índices
while (izq < der)
{
while (strcmp(persona[der].nombre,indice3)>0) der--;
while ((izq < der) && (strcmp(persona[izq].nombre,indice3)<=0)) izq++;
// Si todavia no se cruzan los indices seguimos intercambiando
if(izq < der)
{
strcpy(auxnombre,persona[izq].nombre);
strcpy(auxapellido,persona[izq].apellido);
auxedad=persona[izq].edad;
strcpy(persona[izq].nombre,persona[der].nombre);
strcpy(persona[der].nombre,auxnombre);
strcpy(persona[izq].apellido,persona[der].apellido);
strcpy(persona[der].apellido,auxapellido);
persona[izq].edad=persona[der].edad;
persona[der].edad=auxedad;
}
}
strcpy(auxnombre,persona[der].nombre);
strcpy(auxapellido,persona[der].apellido);
auxedad=persona[der].edad;
strcpy(persona[der].nombre,persona[inicio].nombre);
strcpy(persona[inicio].nombre,auxnombre);
strcpy(persona[der].apellido,persona[inicio].apellido);
strcpy(persona[inicio].apellido,auxapellido);
persona[der].edad=persona[inicio].edad;
persona[inicio].edad=auxedad;
visualizar();
n++;
return der;

visualizar();

}

//Ordenamiento Rapido recursividad////
void Quicksort(int inicio, int fin)
{
int indice2=0;
visualizar();
if(inicio < fin)
{
visualizar();
indice2 = dividir(inicio, fin );//Aqui llamamos a la funcion q esta arriba
Quicksort(inicio, indice2 - 1 );// menores
Quicksort(indice2 + 1, fin );//mayores
}
}


//Escoger el tipo de ornamiento
void tipo_ordenamiento()
{
char opcion3;

do
{
system("cls");
cout<<" <<<<<<<<<Ordenamiento>>>>>>>>>>> "<<endl<<endl<<endl;
cout<<" 1. Quicksort "<<endl;
cout<<" 2. Heapsort "<<endl;
cout<<" 3. Burbuja "<<endl;
cout<<" 4. Atras "<<endl<<endl;
cout<<" >>Escoge una opcion: ";
opcion3=getch();

switch(opcion3)
{
case '1': Quicksort(0,indice-1);
visualizar();
cout<<endl<<endl<<" Lista Ordenada en "<<n<<" intercambios...";
getch();
n=0;
break;
case '2': Heapsort(indice); break;
case '3': Burbuja(); break;
}
}while (opcion3!='4');

}

void main()
{
char opcion;

do
{
system("cls");
cout<<" <<<<<<<<<Ordenamiento>>>>>>>>>>> "<<endl<<endl<<endl;
cout<<" 1. Agregar Persona "<<endl;
cout<<" 2. Ver Lista "<<endl;
cout<<" 3. Ordenar "<<endl;
cout<<" 4. Salir "<<endl<<endl;
cout<<" >>Escoge una opcion: ";
opcion=getch();

switch(opcion)
{
case '1': pedir_datos(); break;
case '2': visualizar();break;
case '3': if(lleno==false)
cout<<endl<<endl<<" ATENCION: Debe llenar la estructura primero!"<<endl;
cin.get();
if(lleno==true)
tipo_ordenamiento();
break;
}
}while (opcion!='4');
}