Ordenar Registro (Archivo ) – Arbol Binario

/****************************************************
*                                                                            *
*                                                                            *
*                                                                            *
*     * ISRAEL CUEVA HIDALGO.                             *
*                                    *
*                                                                            *
****************************************************/

/*
Se pretende desarrollar un directorio que contenga los datos de Nombre,
Edad, Telefono y Ciudad, y que a su vez nos permita ingresar los datos
por teclado, mostrar los registros ingresados en la pantalla y por último
realizar las mismas consultas pero ordenados por los diferentes campos
que se nombro anteriormente.
*/

#include <stdio.h>
#include <stdlib.h>
#define fichero «registro.txt»
//Declaracion de la estructura tRegistro que tendrá
//los campos del directorio

typedef struct stRegistro
{
char nombre[15];
char edad[4];
char ciudad[13];
char telefono[13];
};

//Estructura Arbol que toma la estructura de un Nodo
typedef struct Arbol
{
struct stRegistro dato;
struct Arbol* izq;
struct Arbol* der;
};
//declaración de metodos
int crearNodo(struct Arbol **nuevo, struct stRegistro valor);
int insertarHoja(struct Arbol * arbol, struct stRegistro valor);
int insertarArbol(struct Arbol **arbol, struct stRegistro valor);
void InOrden(struct Arbol * arbol);
int ordenar();
int anadir();
void Listar();
void Eliminar();
strcmp();

int clave = 0;
//——————
//MÉTODO PRINCIPAL
//——————
main()
{
char opcion[1];
int opcionCampo=0;
do
{
system(«cls»);
printf(«___________________________________\n\n»);
printf(» Estructura Datos – Elige opcion\n»);
printf(«___________________________________\n\n»);
printf(» 1) Insertar registro\n»);
printf(» 2) Mostrar Registro\n»);
printf(» 3) Ordenar por campo\n»);
printf(» 4) Eliminar registro\n»);
printf(» 0) Salir\n»);
printf(«\n\nOpcion: «);
gets(opcion);
if(opcion == 0 )
{
system(«cls»);
printf(«\n\n\n\t* * G R A C I A S * *\n\n\n»);
system(«PAUSE»);
system(«exit»);
}
switch (atoi(opcion))
{
case 1:
anadir();
break;
case 2:
system(«cls»);
printf(«____________________________________________\n\n»);
printf(» REGISTRO\n»);
printf(«____________________________________________\n\n»);
printf(» Nombre Edad Ciudad Telefono \n\n»);
//while(fread(®, sizeof(struct stRegistro), 1, fichero2))
//Listar(®);
Listar();
system(«PAUSE»);
break;
case 3:// Ordenar por campo
do
{
system(«cls»);
printf(«________________________\n\n»);
printf(» 3) Ordenar por campo\n»);
printf(«_________________________\n\n»);
printf(«\n 1) Ordenar por nombre\n»);
printf(» 2) Ordenar por edad\n»);
printf(» 3) Ordenar por ciudad\n»);
printf(» 4) Ordenar por telefono\n»);
printf(«\nOpcion: «);
scanf(«%d»,&opcionCampo);

if(opcionCampo == 1)
{
clave = 1;
system(«cls»);
printf(«\n\n\n\t\tCAMPO ORDENADO POR NOMBRE\n\n\n»);
system(«PAUSE»);
system(«cls»);
printf(«____________________________________________\n\n»);
printf(» REGISTRO\n»);
printf(«____________________________________________\n\n»);
printf(» Nombre Edad Ciudad Telefono \n\n»);
ordenar();
printf(«\n»);
system(«PAUSE»);
opcionCampo=-1;
main();
}
if(opcionCampo == 2)
{
clave = 2;
system(«cls»);
printf(«\n\n\n\t\tCAMPO ORDENADO POR EDAD\n\n\n»);
system(«PAUSE»);
system(«cls»);
printf(«____________________________________________\n\n»);
printf(» REGISTRO\n»);
printf(«____________________________________________\n\n»);
printf(» Nombre Edad Ciudad Telefono \n\n»);
ordenar();
printf(«\n»);
system(«PAUSE»);
opcionCampo=-1;
main();
}
if(opcionCampo == 3)
{
clave = 3;
system(«cls»);
printf(«\n\n\n\t\tCAMPO ORDENADO POR CIUDAD\n\n\n»);
system(«PAUSE»);
system(«cls»);
printf(«____________________________________________\n\n»);
printf(» REGISTRO\n»);
printf(«____________________________________________\n\n»);
printf(» Nombre Edad Ciudad Telefono \n\n»);
ordenar();
printf(«\n»);
system(«PAUSE»);
opcionCampo=-1;
main();
}
if(opcionCampo == 4)
{
clave = 4;
system(«cls»);
printf(«\n\n\n\t\tCAMPO ORDENADO POR TELEFONO\n\n\n»);
system(«PAUSE»);
system(«cls»);
printf(«____________________________________________\n\n»);
printf(» REGISTRO\n»);
printf(«____________________________________________\n\n»);
printf(» Nombre Edad Ciudad Telefono \n\n»);
ordenar();
printf(«\n»);
system(«PAUSE»);
opcionCampo=-1;
main();
}

}while (opcionCampo != -1);
break;
case 4:
system(«cls»);
Eliminar();
printf(«\n\n\n\t\tREGISTRO ELIMINADO\n\n\n»);
system(«PAUSE»);
break;
}
}while(atoi(opcion) != 0);
return 0;

}
//FIN DEL MÉTODO PRINCIPAL
//—————————————————————————–
// * Crea el nuevo nodo con el valor que se desea, en el caso de que no exista
//—————————————————————————–

int crearNodo(struct Arbol **nuevo, struct stRegistro valor)//nodo raiz
{
int correcto = 0;
//Reservamos espacio en memoria y lo asignamos al puntero de estrucura Nodo
*nuevo = (struct Arbol *) malloc(sizeof(struct Arbol));
//Si (*nuevo) en este caso es diferente de NULL
if ((*nuevo) != NULL)
{
(*nuevo)->dato = valor;
(*nuevo)->izq = NULL;
(*nuevo)->der = NULL;
correcto = 1;
}

return correcto;
}

//——————————————————————
/**
* Inserto el nuevo nodo como una hoja del árbol, y sirve para ordenar como
* se requiera de acuerdo al campo desaado
*/
//——————————————————————
int insertarHoja(struct Arbol * arbol, struct stRegistro valor)
{
struct Arbol * nuevo;
int correcto = 0;
if(clave ==1 )
{
//La funcion strcmp: Compara la cadena apuntada por *valor.nombre*, con la cadena
//apuntada por *arbol->dato.nombre*. Esta función retorna un entero mayor, igual o
//que cero.

//Si el valor devuelto por la función strcmp es menor que cero entro
if (strcmp(valor.nombre, arbol->dato.nombre) < 0)
{
//Si el a lo que apunta el puntero izquierdo es diferente de NULL
if (arbol->izq != NULL)
{
//Se cunple una función recursiva y se retornará el valor de correcto
//Este puede ser 1 – 0
correcto = insertarHoja(arbol->izq, valor);
}
//Caso contrario
else
{
//Si El dato es == NULL indica que no tiene una estructura de Nodo
//En este caso se indica al método crear_que lo cree
if (crearNodo(&nuevo, valor))
{
//nuevo(De estructura Nodo(Nodo)
arbol->izq = nuevo;
correcto = 1;
}
}
}
//Caso contrario: Si el valor devuelto por la función strcmp es
// mayor o igual que cero entro
else
{
//Voy por la rama derecha considerada como siguinte
//Si rama siguinte es diferente de null
if (arbol->der != NULL)
{
//recursividad, para insertar un nuevo nodo como hoja
correcto = insertarHoja(arbol->der, valor);
}
//Si es null
else
{
//Creo un nuevo nodo con estructura de Nodo
if (crearNodo(&nuevo, valor))
{
arbol->der = nuevo;
correcto = 1;
}
}
}
}

//si clave es igual a 2, aplicaremos el mismo procedimiento izquierdo
//con clave 0 a 1, simplemente va a variar en la funcion strcmp los
//parametros de comparación
//se repitira el mismo procedimiento para clave = 3 y 4. Cambiando
//únicamente el valor de busqueda.
if(clave ==2 )
{
if (strcmp(valor.edad, arbol->dato.edad) < 0)
{
if (arbol->izq != NULL)
{
correcto = insertarHoja(arbol->izq, valor);
}
else
{
if (crearNodo(&nuevo, valor))
{
arbol->izq = nuevo;
correcto = 1;
}
}
}
else
{
if (arbol->der != NULL)
{
correcto = insertarHoja(arbol->der, valor);
}
else
{
if (crearNodo(&nuevo, valor))
{
arbol->der = nuevo;
correcto = 1;
}
}
}
}

if(clave ==3 )
{
if (strcmp(valor.ciudad, arbol->dato.ciudad) < 0)
{
if (arbol->izq != NULL)
{
correcto = insertarHoja(arbol->izq, valor);
}
else
{
if (crearNodo(&nuevo, valor))
{
arbol->izq = nuevo;
correcto = 1;
}
}
}
else
{
if (arbol->der != NULL)
{
correcto = insertarHoja(arbol->der, valor);
}
else
{
if (crearNodo(&nuevo, valor))
{
arbol->der = nuevo;
correcto = 1;
}
}
}
}

if(clave ==4 )
{
if (strcmp(valor.telefono, arbol->dato.telefono) < 0)
{
if (arbol->izq != NULL)
{
correcto = insertarHoja(arbol->izq, valor);
}
else
{
if (crearNodo(&nuevo, valor))
{
arbol->izq = nuevo;
correcto = 1;
}
}
}
else
{
if (arbol->der != NULL)
{
correcto = insertarHoja(arbol->der, valor);
}
else
{
if (crearNodo(&nuevo, valor))
{
arbol->der = nuevo;
correcto = 1;
}
}
}
}

return correcto;
}

//——————————————————————-
/*
* Miro si el árbol está vacío o con nodos
*/
//——————————————————————-
int insertarArbol(struct Arbol **arbol, struct stRegistro valor)
{
struct Arbol* nuevo;
int correcto = 0;
//Los punteros son NULL
if (*arbol == NULL)
{
//Si son nulos
if (crearNodo(&nuevo, valor))
{
*arbol = nuevo;
correcto = 1;
}
}
else
{
correcto = insertarHoja(*arbol, valor);
}

return correcto;
}

//——————————————————————

/**
* Muestro el contenido del árbol mostrándolo en inorden
*/
//——————————————————————
void InOrden(struct Arbol * arbol)
{
//compruebo que la raiz sea diferente que NULL
if (arbol != NULL)
{
//Recorremos el árbol izquierdo, incluyendo su raiz
InOrden(arbol->izq);
//Presento con la estructura que aqui se expone
printf(» %s \t%s\t%s\t %s\n», arbol->dato.nombre, arbol->dato.edad
,arbol->dato.ciudad,arbol->dato.telefono);
//Recorro el árbol derecho
InOrden(arbol->der);

//estos son métodos recursivos donde si no se encuentra un nodo se salta al
//derecho en este caso a la rama derecha (derecho)
}
}
//——————————————————————-
/**
* Recojo cada registro y lo incluyo en el árbol
*/
//——————————————————————-

int ordenar()
{
FILE *f;
struct stRegistro r;
struct Arbol* arbol = NULL;
int correcto = 0;

//Abrimos el fichero en modo lectura y le asignamos la
//la posicion al de memoria a puntero Tipo FILE f
//si f es distinto de NULL
if ((f = fopen(fichero, «r»)) != NULL)
{
//Leemos el archivo con la posicion de memoria de Campos(Datos)
//al igualemte indicamos su tamaño con la funcion sizeof y le indicamos el
//archivo de donde queremos leer
while (fread(&r, sizeof(r), 1, f))
{
//Comparo las dos cadenas que tenemos con nombre
if (strcmp(r.nombre, «*») != 0)
{
//Si es diferente de cero el valor devuelto
insertarArbol(&arbol, r);
}
}
//Cerramos el archivo para volver a ser utilizado
fclose(f);

InOrden(arbol);

correcto = 1;
}

return correcto;
}

//——————————————————————–
/*
Añado registros al fichero
*/
//——————————————————————–
int anadir()
{
FILE *f;
//FILE *f2;//
struct stRegistro r;
int correcto = 0;

if ((f = fopen(fichero, «a»)) != NULL)
{
//f2 = fopen(fichero2, «a»);
system(«cls»);
printf(«_________________________________\n\n»);
printf(» Ingresa datos del registro\n»);
printf(«_________________________________\n\n»);
printf(«Nombre: «);
gets(r.nombre);
//fgets(reg->nombre, 15, stdin);
printf(«Edad : «);
gets(r.edad);
printf(«Ciudad: «);
gets(r.ciudad);
printf(«Telef : «);
gets(r.telefono);
//Escribimos el archivo
fwrite(&r, sizeof(r), 1, f);
//fwrite(&r, sizeof(r),1,f2);
//fclose(f2);
fclose(f);
correcto = 1;
}

return correcto;
}

void Listar()
{
FILE *f3;
struct stRegistro reg;

if ((f3 = fopen(fichero, «r»)) != NULL)
{
while (fread(®, sizeof(reg), 1, f3))
{
printf(» %s \t%s\t%s\t %s\n», reg.nombre, reg.edad
,reg.ciudad,reg.telefono);
}
fclose(f3);
}
printf(«\n»);
}

void Eliminar()
{
FILE *f4;

if ((f4 = fopen(fichero, «w»)) != NULL)
{
fclose(f4);
}
printf(«\n»);
}

Triangulo Pascal (Matriz)

/**
*
* @author ISRAEL CUEVA
*
*/

#include <stdio.h>
int nivel,columna,fila,medio,k,j,i;
fila=0;
columna=0;
medio=0;
int arreglo[20][20];

main()
{
printf(«Ingrese el nivel»);
scanf(«%d»,&nivel);
columna=(nivel*2)-1;
medio=(columna/2);
for(i=0;i<nivel;i++){
for(j=0;j<columna;j++){
arreglo[i][j]=0;
}
}

arreglo[fila][medio]=1;

while(fila<=(nivel-1)){
fila++;
medio=medio-1;
k=medio;
while(k<=columna){
if(k==0){
arreglo[fila][k]=1;
}else{
if(k==columna){
arreglo[fila][k]=arreglo[fila-1][k-1];
}else{
arreglo[fila][k]=arreglo[fila-1][k-1]+arreglo[fila-1][k+1];
}
}
k=k+2;
}

}

for(fila=0;fila<nivel;fila++){
for(j=0;j<columna;j++){
if(arreglo[fila][j]!=0){
printf(«%d\t», arreglo[fila][j]);
}else{
printf(«\t»);
}
}
printf(«\n»);
}
system(«PAUSE»);
}

Sumandos de un número

/**
*
* @author ISRAEL CUEVA
*
*/

#include <stdio.h>

int a[50];
int x, s1, y, aux, s2,n;

main() {
printf(«Ingrese el numero: «);
scanf(«%d», &n);
a[0] = n;
for(x=1; x<n; x++)
a[x] = 0;

while(a[0] > 1) {
x = n-1;
s1 = 0;
do { x–;
s1 = s1 + a[x];
} while(a[x] <= 1);
a[x] = a[x]-1;
aux = a[x];
s2 = a[x];
y = x + 1;

while(y < n)
if((s2 + aux) > s1)
aux = aux – 1;
else { a[y] = aux;
s2 = s2 + aux;
y++; }
for(x=0; x<n; x++)
if (a[x] != 0)
printf(«%d, «, a[x]);
printf(«\n»);
}
system(«PAUSE»);
}

Arreglo-Operaciones

/**
*
* @author ISRAEL CUEVA
*/

/*
programa para crear un arreglo de n elementos y presentarlo ;
luego presentarlo ordenado; luego insertar un elemento
cualquiera de una posición ingerasa por el usuario, presentarlo en
desorden y luego en orden
*/

#include <iostream.h>
#include <stdlib.h>
#include <stdio.h>

int arreglo[20];
int numeroElementos;
int elemento;
int i,j,aux;
//int n,
/* n=10(numeroElementos);
Lo puse más abajo
*/
//variable para el índice u el nuevo elemento
int indice,nuevoElemento;

int main () {

// pedir por teclado el número de elementos.
cout<<«Ingersa el numero de elementos: «;
cin>>numeroElementos;

//escribir los elementos del arreglo
for(int i=0;i<numeroElementos;i++){
cout<<«Ingresa elemento: «;
cin>>elemento;
arreglo[i]=elemento;
}

//Presentar los elementos del arreglo en el orden como fueron escritos
cout<<«\nLos elementos del arreglo en desorden son: \n»;
for(int i=0;i<numeroElementos;i++){
cout<<arreglo[i]<<» «;
}

//Proceso para ordenar el arreglo
//n=numeroElementos;
for(int i=1;i<numeroElementos;i++){
j=i;
aux=arreglo[i];
while(j>0 && aux<arreglo[j-1]){
arreglo[j] = arreglo[j-1];
j = j-1;
}
arreglo[j] = aux;
}

//Presentar los elementos del arreglo pero en orden
cout<<«\nEl arreglo ordenado es: \n»;
for(int i=0;i<numeroElementos;i++){
cout<<arreglo[i]<<» «;
}

/* Pedir por teclado que se ingrese un índice y un elemnto a ingresar en
dicho índice */
cout<<«\n\nIngresa un elemento para reemplazarlo: «;
cin>>nuevoElemento;
cout<<«\nIngresa un indice para colocar el «<<nuevoElemento<<» : «;
cin>>indice;

// cambiar el elemento dado en su respectivo índice y presentarlo.
for(int i=0;i<numeroElementos;i++){
if(i==indice){
arreglo[i]=nuevoElemento;
}
cout<<arreglo[i]<<» «;
}
//Ordenar el arrglo nuevamente y presentarlo
for(int i=1;i<numeroElementos;i++){
j=i;
aux=arreglo[i];
while(j>0 && aux<arreglo[j-1]){
arreglo[j] = arreglo[j-1];
j = j-1;
}
arreglo[j] = aux;
}

cout<<«\nLos elementos del arreglo en desorden son: \n»;
for(int i=0;i<numeroElementos;i++){
cout<<arreglo[i]<<» «;
}

system («PAUSE»);
return 0;
}

Ordenar arreglo

/**
*
* @author ISRAEL CUEVA
*/

#include <stdio.h>
int arreglo[] = {10,9,8,7,6,5,4,3,2,1};
int i, j, n, aux;

main() {

n = 10;
for(i=1; i<n; i++) {
j = i;
aux = arreglo[i];
while(j>0 && aux<arreglo[j-1]) {
arreglo[j] = arreglo[j-1];
j=j-1;
}
arreglo[j] = aux;
}
printf(«\n\nLos elementos ordenados del arreglo son: \n»);
for(i=0; i<n; i++) {
printf(«Elemento [%d]: %d\n», i, arreglo[i]);
}
system(«PAUSE»);
return 0;

}

Validar Cédula

/*
*Programa cédula
*@autor Israel Cueva
*/

#include <iostream.h>
#include <stdlib.h>

int arreglo[10];
int digito;
int sumaDigitos=0;
int numeroRestar=0;
int elementoFinal=0;

int main(){

cout<<«Ingresa el numero de cedula: \n\n»;
for(int i=0;i<10;i++){
cout<<«Ingresa digito: «;
cin>>digito;
arreglo[i]=digito;
}

for(int i=0;i<9;i++){
if(i==0){
arreglo[i]=arreglo[i]*2;
if(arreglo[i]>=10){
arreglo[i]=arreglo[i]-9;
}
}
if( (i%2==0) && (i != 0) ){
arreglo[i]=arreglo[i]*2;
if(arreglo[i]>=10){
arreglo[i]=arreglo[i]-9;
}
}
if( (i%2 != 0) && (i!=0) ){
arreglo[i]=arreglo[i]*1;
if(arreglo[i]>=10){
arreglo[i]=arreglo[i]-9;
}
}

}

cout<<«\nEl numero de cedula multiplicado es: \n»;
for(int i=0;i<9;i++){
cout<<arreglo[i]<<» «;
}

for(int i=0;i<9;i++){
sumaDigitos=sumaDigitos+arreglo[i];
}
cout<<«\nSuma de los 9 primeros digitos multiplicados por 2 y 1 de la cedula: \n»;
cout<<sumaDigitos;

if(sumaDigitos >=20 && sumaDigitos<=29){
numeroRestar=30-sumaDigitos;
}
if(sumaDigitos >=10 && sumaDigitos<=19){
numeroRestar=20-sumaDigitos;
}
if(sumaDigitos >=30 && sumaDigitos<=39){
numeroRestar=40-sumaDigitos;
}

cout<<«\n Comprobacion:\n»;
elementoFinal=arreglo[9];
if(numeroRestar == elementoFinal){
cout<<«Tu cedula es correcta\n»;
}
if(numeroRestar != elementoFinal){
cout<<«Tu cedula es incorrecta\n»;
}

system(«PAUSE»);
return 0;
}

Mayor y menor – Matriz

/**
*
* @author ISRAEL CUEVA
*/
#include <iostream.h>
#include <stdlib.h>
#include <stdio.h>

void MayorMenor (int matriz[20][20],int nivel);
int matriz[20][20];

main(){

//int matriz[10][10];
int i=0,j=0;
int elemento = 0;

int nivel=0;
printf(«Ingresa el nivel de la matriz: «);
scanf(«%d»,&nivel);

//ingresar elementos
printf(«\n»);
for(i=0;i<nivel;i++){
for(j=0;j<nivel;j++){
printf(«Ingesa elemento[%d][%d]: «,i,j);
scanf(«%d»,&elemento);
matriz[i][j] = elemento;
}
}

//presentar elementos
printf(«\nMatriz ingresada fue: \n»);
for(i=0;i<nivel;i++){
for(j=0;j<nivel;j++){
printf(«%d\t»,matriz[i][j]);
}
printf(«\n»);
}
//Presentar mayor y menor
MayorMenor(matriz,nivel);

system(«PAUSE»);
return 0;
}

void MayorMenor (int matriz[20][20],int nivel)
{
int i = 0,j = 0;
int mayor = matriz[0][0];
int menor = matriz[0][0];
int elemento = 0;

for(i=0;i<nivel;i++){
for(j=0;j<nivel;j++){
elemento = matriz[i][j];
if(elemento>mayor)
{
mayor=elemento;
}
if(elemento<menor)
{
menor=elemento;
}
}
}

printf(«\nElemnto mayor: %d»,mayor);
printf(«\nElemnto menor: %d\n\n»,menor);
}