Mensajes

hola a todos bueno quiero incursionar en el visual basic 10 , estado trabajando muxo tiempo con el devcpp y digamos q eso casi no es nada eh dejado trabajos interesantes en programacion C++ , pero en fin haber si alguien me puede orientar para incursionar y conocer todos los comandos en visual basic 10

 Arbol Binario Balanceado implementado con el pseudocodigo del libro de Estructura de Datos de Osvaldo Cairo. Les recomiendo ese libro .
Es interesante este algoritmo para los ordenamientos en arboles y busquedas.


ATTE : ANTON RAMIREZ , LEONARDO VLADIMIR  (ALUMNO UNI)

Código [Seleccionar] Expandir

using namespace std;

struct NODO
{
  NODO *izq;
int       info;
NODO *der;
int FE;
};

void InsercionBalanceado(NODO **nodocabeza, bool *BO, int infor);
void Busqueda(NODO *nodo,int infor);
void Preorden(NODO *);
void Inorden(NODO *);
void Postorden(NODO *);
void Restructura1(NODO **nodocabeza, bool *BO);
void Restructura2(NODO **nodocabeza, bool *BO);
void Borra(NODO **aux1, NODO **otro1, bool *BO);
void EliminacionBalanceado(NODO **nodocabeza, bool *BO, int infor);
int Menu();

int main()
{
  int Opcion;
  int elemento;
  NODO *borrado, *raiz;
  raiz=NULL;
  system("cls");
  Opcion = Menu();
  bool inicio;
  while (Opcion)
  {
     system("cls");
switch(Opcion)
     {
        case 1:
           cout<<"\nRUTINA DE INSERCION\n\n";
           cout<<"\nIngrese elemento a insertar: ";
           cin>>elemento;
           inicio=false;
           InsercionBalanceado(&raiz, &inicio, elemento);
           break;

        case 2:
cout<<"\nRUTINA DE BUSQUEDA\n\n";
           cout<<"\nIngrese elemento a buscar: ";
           cin>>elemento;
           Busqueda(raiz, elemento);
           break;
        case 3:
           printf("\nRECORRIDO PREORDEN\n\n");
           printf("\nEl arbol es: \n\n");
        Preorden(raiz);
           printf("\n\n");
           system("pause");
           break;
        case 4:
           printf("\nRECORRIDO INORDEN\n\n");
           printf("\nEl arbol es: \n\n");
Inorden(raiz);
printf("\n\n");
           system("pause");
           break;
        case 5:
           printf("\nRECORRIDO POSTORDEN\n\n");
           printf("\nEl arbol es: \n\n");
           Postorden(raiz);
           printf("\n\n");
           system("pause");
           break;
      case 6:
cout<<"\nRUTINA DE ELIMINACION\n\n";
           cout<<"\nIngrese elemento a eliminar: ";
           cin>>elemento;
           inicio=false;
           EliminacionBalanceado(&raiz, &inicio, elemento);
           break;
        case  0: exit(0);
     }
     Opcion = Menu();
  }
  system("pause");
  return(0);
}
int Menu()
{
  int Op;
  do{
     system("cls");
     cout<<"\n\n\t    ARBOL  BINARIO BALANCEADO \n\n";
     cout<<"\t1) Insertar\n";
cout<<"\t2) Buscar\n";
cout<<"\t3) PreOrden\n";
cout<<"\t4) InOrden\n";
cout<<"\t5) PostOrden\n";
cout<<"\t6) Eliminacion\n";
cout<<"\t0) Salir\n\n";
     printf("Digite su opcion ---> ");
     cin>>Op;
  }while(Op<0 || Op>7);
  return (Op);
}

void InsercionBalanceado(NODO **nodocabeza, bool *BO, int infor)
{
NODO *nodo, *nodo1, *nodo2;
  nodo=*nodocabeza;
  if(nodo!=NULL)
{
if( infor < nodo->info )
{
InsercionBalanceado(&(nodo->izq),BO,infor);
if( *BO == true )
{
switch(nodo->FE)
{
case 1: nodo->FE=0;
*BO=false;
break;
case 0: nodo->FE=-1;
break;
case -1: nodo1=nodo->izq;//reestructuracion del arbol
if (nodo1->FE<=0)
{ //Rotacion II
nodo->izq=nodo1->der;
nodo1->der=nodo;
nodo->FE=0;
nodo=nodo1;
}
else
{ //Rotacion ID
nodo2=nodo1->der;
nodo->izq=nodo2->der;
nodo2->der=nodo;
nodo1->der=nodo2->izq;
nodo2->izq=nodo1;

if (nodo2->FE==-1)
nodo->FE=1;
else
nodo->FE=0;

if (nodo2->FE==1)
nodo1->FE=-1;
else
nodo1->FE=0;
nodo=nodo2;
}
nodo->FE=0;
*BO=false;
break;
}
}
}
else
{
if( infor > nodo->info )
{
InsercionBalanceado(&(nodo->der),BO,infor);
if( *BO == true )
{
switch(nodo->FE)
{
case -1: nodo->FE=0;
*BO=false;
break;
case 0: nodo->FE=1;
break;
case 1: nodo1=nodo->der;//reestructuracion del arbol
if (nodo1->FE>=0)
{ //Rotacion DD
nodo->der=nodo1->izq;
nodo1->izq=nodo;
nodo->FE=0;
nodo=nodo1;
}
else
{ //Rotacion DI
nodo2=nodo1->izq;
nodo->der=nodo2->izq;
nodo2->izq=nodo;
nodo1->izq=nodo2->der;
nodo2->der=nodo1;

if (nodo2->FE==1)
nodo->FE=-1;
else
nodo->FE=0;

if (nodo2->FE==-1)
nodo1->FE=1;
else
nodo1->FE=0;

nodo=nodo2;
}
nodo->FE=0;
*BO=false;
break;
}
}
}
else
{
cout<<"\nEl nodo ya se encuentra en el arbol\n"<<endl;
system("pause");
}
}
}
else
{
//NODO *otro;
     nodo = new(NODO);
     nodo->izq=NULL;
     nodo->der=NULL;
     nodo->info=infor;
     nodo->FE=0;
     *BO=true;
}
  *nodocabeza=nodo;
}

void Busqueda(NODO *nodo,int infor)
{
if(nodo!=NULL)
{
if( infor < nodo->info )
{
Busqueda(nodo->izq,infor);
}
else
{
if( infor > nodo->info )
{
Busqueda(nodo->der,infor);
}
else
{
cout<<"\nEl nodo SI se encuentra en el arbol\n"<<endl;
system("pause");
}
}
}
else
{
cout<<"\nEl nodo NO se encuentra en el arbol\n"<<endl;
system("pause");
}
}

void Preorden(NODO *nodo)
{
if (nodo!=NULL)
{
cout<<nodo->info<<"\t";
Preorden(nodo->izq);
Preorden(nodo->der);
}
}

void Inorden(NODO *nodo)
{
if (nodo!=NULL)
{
Inorden(nodo->izq);
cout<<nodo->info<<"\t";
Inorden(nodo->der);
}
}

void Postorden(NODO *nodo)
{
if (nodo!=NULL)
{
Postorden(nodo->izq);
Postorden(nodo->der);
cout<<nodo->info<<"\t";
}
}

/*void Eliminacion(NODO **nodocabeza, int infor)
{
NODO *nodo, *otro, *aux, *aux1;
  nodo=*nodocabeza;
  if(nodo!=NULL)
{
if( infor < nodo->info )
{
Eliminacion(&(nodo->izq),infor);
}
else
{
if( infor > nodo->info )
{
Eliminacion(&(nodo->der),infor);
}
else
{
otro=nodo;
if (otro->der==NULL)
{
nodo=otro->izq;
}
else
{
if (otro->izq==NULL)
{
nodo=otro->der;
}
else
{
aux=otro->izq;
aux1=aux;
while(aux->der!=NULL)
{
aux1=aux;
aux=aux->der;
}
otro->info=aux->info;
otro=aux;
aux1->der=aux->izq;
}
}
}
}
delete(otro);
}
else
{
cout<<"\nEl nodo NO se encuentra en el arbol\n"<<endl;
system("pause");
}
*nodocabeza=nodo;
}
*/
void Restructura1(NODO **nodocabeza, bool *BO)
{
NODO *nodo, *nodo1, *nodo2;
  nodo=*nodocabeza;
  if ( *BO==true )
  {
switch(nodo->FE){
case -1: nodo->FE=0;
break;
case 0: nodo->FE=1;
*BO=false;
break;
case 1: //reestructuracion del arbol
nodo1=nodo->der;
if(nodo1->FE>=0){ //rotacion DD
nodo->der=nodo1->izq;
nodo1->izq=nodo;
switch (nodo1->FE){
case 0: nodo->FE=1;
nodo1->FE=-1;
*BO=false;
break;
case 1: nodo->FE=0;
nodo1->FE=0;
*BO=false;
break;
}
nodo=nodo1;
}
else
{ //Rotacion DI
nodo2=nodo1->izq;
nodo->der=nodo2->izq;
nodo2->izq=nodo;
nodo1->izq=nodo2->der;
nodo2->der=nodo1;

if (nodo2->FE==1)
nodo->FE=-1;
else
nodo->FE=0;

if (nodo2->FE==-1)
nodo1->FE=1;
else
nodo1->FE=0;

nodo=nodo2;
nodo2->FE=0;
}
break;
}
}
  *nodocabeza=nodo;
}

void Restructura2(NODO **nodocabeza, bool *BO)
{
NODO *nodo, *nodo1, *nodo2;
  nodo=*nodocabeza;
  if ( *BO==true )
  {
switch(nodo->FE)
{
case 1: nodo->FE=0;
break;
case 0: nodo->FE=-1;
*BO=false;
break;
case -1: //reestructuracion del arbol
nodo1=nodo->izq;
if(nodo1->FE<=0)
{ //rotacion II
nodo->izq=nodo1->der;
nodo1->der=nodo;
switch (nodo1->FE)
{
case 0: nodo->FE=-1;
nodo1->FE=1;
*BO=false;
break;
case -1: nodo->FE=0;
nodo1->FE=0;
*BO=false;
break;
}
nodo=nodo1;
}
else
{ //Rotacion ID
nodo2=nodo1->der;
nodo->izq=nodo2->der;
nodo2->der=nodo;
nodo1->der=nodo2->izq;
nodo2->izq=nodo1;

if (nodo2->FE==-1)
nodo->FE=1;
else
nodo->FE=0;

if (nodo2->FE==1)
nodo1->FE=-1;
else
nodo1->FE=0;

nodo=nodo2;
nodo2->FE=0;
}
break;
}
}
  *nodocabeza=nodo;
}

void Borra(NODO **aux1, NODO **otro1, bool *BO)
{
NODO *nodo, *aux, *otro;
  aux=*aux1;
  otro=*otro1;
  if ( aux->der!=NULL )
{
Borra(&(aux->der),&otro,BO);
Restructura2(&aux,BO);
}
else
{
otro->info=aux->info;
aux=aux->izq;
*BO=true;
}
*aux1=aux;
*otro1=otro;
}

void EliminacionBalanceado(NODO **nodocabeza, bool *BO, int infor)
{
NODO *nodo, *otro;
  nodo=*nodocabeza;
  if(nodo!=NULL)
{
if( infor < nodo->info )
{
EliminacionBalanceado(&(nodo->izq),BO,infor);
Restructura1(&nodo,BO);
}
else
{
if( infor > nodo->info )
{
EliminacionBalanceado(&(nodo->der),BO,infor);
Restructura2(&nodo,BO);
}
else
{
otro=nodo;
if (otro->der==NULL)
{
nodo=otro->izq;
*BO=true;
}
else
{
if (otro->izq==NULL)
{
nodo=otro->der;
*BO=true;
}
else
{
Borra(&(otro->izq),&otro,BO);
Restructura1(&nodo,BO);
delete(otro);
}
}
}
}
}
else
{
cout<<"\nEl nodo NO se encuentra en el arbol\n"<<endl;
system("pause");
}
*nodocabeza=nodo;
}[/color]

Algunas operaciones que se les puede implementar aun arbol binario.

Código [Seleccionar] Expandir

using namespace std;

struct NODO{
int dato;
struct NODO *izq;
struct NODO *der;
};

void crearArbol(NODO **cabeza);
void insertar(NODO **cabeza, int elemento);
void inorder(NODO *cabeza), preorder(NODO *cabeza);
void postorder(NODO *cabeza);
NODO *eliminar(NODO *cabeza, int elemento);

int main()
{
   char opcion;
   int elemento;
   NODO *borrado, *raiz;
   clrscr();
   crearArbol(&raiz);
   //raiz=NULL;
   
   for(;;){
      system("cls");
      printf("\tARBOLES BINARIOS DE BUSQUEDA\n\n");
      printf("(0) SALIR\n(1) Insertar\n(2) Eliminar\n(3) Inorder\n(4) Preorder\n(5) Postorder\n");
      printf("\n\tDigite su opcion ---> ");
     
      switch(opcion=getche()){
         case '0':
            exit(0);
         case '1':
            system("cls");
            printf("\nIngrese elemento a insertar: ");
            scanf("%d", &elemento);
            insertar(&raiz, elemento);
            break;
         
         case '2':
            if(raiz==NULL){
               printf("\nNo hay nodos en al arbol\n\n");
               break;
            }
            else{
               printf("\nIngrese dato a eliminar: ");
               scanf("%d", & elemento);
               borrado=eliminar( raiz, elemento);
               if(borrado==NULL)
                  printf("\nDato no encontrado\n\n");
               break;
            }         
         case '3':
            system("cls");
            printf("\nEl arbol es: ");
            inorder(raiz);
            system("pause");
            break;
         case '4':
            system("cls");
            printf("\nEl arbol es: ");
            preorder(raiz);
            break;
         case '5':
            system("cls");
            printf("\nEl arbol es: ");
            postorder(raiz);
            break;
      }
      printf("\n\n");
   }


   system("pause");
   return(0);
}
void crearArbol(NODO **cabeza)
{
   *cabeza=NULL;   
}
void insertar(NODO **cabeza, int elemento)
{

   if(*cabeza==NULL){
      *cabeza= (NODO *) malloc(sizeof(NODO));
     
      if(*cabeza==NULL){
         printf("No hay memoria\n");
         return;
      }     
      (*cabeza)->dato=elemento;
      (*cabeza)->izq=NULL;
      (*cabeza)->der=NULL;
   }
   else
      if(elemento< (*cabeza)->dato)
         insertar(& (*cabeza)->izq, elemento);
      else
         if(elemento> (*cabeza)->dato)
            insertar(& (*cabeza)->der, elemento);
         else
            printf("\nNo puede insertar: valor duplicado\n\n");

}

NODO *eliminar(NODO *cabeza, int elemento)
{
   NODO *p, *p2;
   
   if(elemento==cabeza->dato){
      if(cabeza->izq==cabeza->der){
         free(cabeza);
         return(NULL);
      }
     
      else
         if(cabeza->izq==NULL){
            p=cabeza->der;
            free(cabeza);
            return(p);
         }
     
         else
            if(cabeza->der==NULL){
               p=cabeza->izq;
               free(cabeza);
               return(p);
            }     
            else{
               p2=cabeza->der;
               p=cabeza->der;
               while(p->izq) p=p->izq;
                  p->izq=cabeza->izq;
               free(cabeza);
               return(p2);
            }
   }
   
   if(cabeza->dato<elemento)
      cabeza->der=eliminar(cabeza->der, elemento);
   else
      cabeza->izq=eliminar(cabeza->izq, elemento);
   return(cabeza);
}


void inorder(NODO *cabeza)
{
   if(cabeza!=NULL){
      inorder(cabeza->izq);
      printf("%d ",cabeza->dato);
      inorder(cabeza->der);
   }
}

void preorder(NODO *cabeza)
{
   if(cabeza!=NULL){
      printf("%d ", cabeza->dato);
      preorder(cabeza->izq);
      preorder(cabeza->der);
   }
}

void postorder(NODO *cabeza)
{
   if(cabeza!=NULL){
      postorder(cabeza->izq);
      postorder(cabeza->der);
      printf("%d ",cabeza->dato);
   }
}
void salvar(NODO **cabeza, int elemento)
{
   NODO *p, *p2;
   if(elemento==cabeza->dato){
      if(cabeza->izq==cabeza->der){
         free(cabeza);
         return(NULL);
      }
   if (elemento > 0){
      if ()
         moverDrcha(actual, k);
      else
         combina(actual, k);

   else /* Sólo tiene "hermano" derecho */
      if (actual->ramas[1]->cuenta > m/2)
         moverIzqda(actual, 1);
      else
         combina(actual, 1);
}[/color]

Aqui les dejo un programa de generacion de numeros aleatorios y cuya salida me devuelve el mayor de los aleatorios , espero que lo sepan usar , haber si por alli alguien me puede facilitar programas resueltos en C++

ATTE : ANTON RAMIREZ , LEONARDO VLADIMIR  (ALUMNO UNI)

Código [Seleccionar] Expandir

//MACROS
#define randomize (srand(time(0)))
//Retorna un numero aleatorio [0, num-1]
#define random(num) (rand()%(num))
#define TOPE 1000
#define MAX(x,y) ((x)>(y)?(x):(y))

using namespace std;

int main()
{
  int i, n, mx, y;
  randomize;
  mx=random(TOPE);
  printf("Ingrese la cantidad de numeros a mostrar :");
  scanf("%d", &n);
  for(i=0;i<n;){
     y=random(TOPE);
     mx=MAX(mx, y);
     printf("%3d ", y);
     i=i+1;
  }
  printf("\n\nMayor NUMERO : %d ", mx);
  printf("\n\n");
  system("pause");
  return(0);
}[/color][/font]

A continuación se presentan los algoritmos de operaciones con listas. La estructura es:
Para todas las acciones, Cab es un apuntador al primer nodo de la lista
Utilizaremos una notación para usarla en nuestros algoritmos de tal modo que estas sean independientes de cualquier lenguaje de programación.
Si P es un apuntador (puntero) del tipo NODO entonces P.Val hace referencia a la parte valor (información) del nodo apuntado por P de la misma manera P.Sgte hace referencia a la parte dirección siguiente del nodo apuntado por P..
En esta oportunidad implemento una lista dinamica, pero queda de antemano que existe la implementacion de lista estatica , osea usando vectores , haber si alguien lo obtine por alli , o mas aplicaciones de listes simples , hay tambien listas dobles y logicamente la lista circular , en esta oportunidad les dejo operaciones de listas simples.


ATTE : ANTON RAMIREZ , LEONARDO VLADIMIR  (ALUMNO UNI)

Crea una lista enlazada de simple anadiendo nodos de numeros pares al final de la lista.

Código (c) [Seleccionar] Expandir


[li]// Aqui NODO debe ser global porque pude declararse en cualquier parte del programa
struct NODO
{
int Val;
NODO *Sgte;
};

//Crea una lista vacia
void CrearLista (NODO **Cab, NODO **Final);

// Crea una Lista de numeros Pares anadiendo al final de la lista
void CrearLPares(NODO **Cab, NODO **Final);

// Muestra la Lista
void MostrarLPares(NODO *Cab);

// Predicado que devuelve verdad si X es Par y falso en otro caso
bool VrfcaPar(int x);

// Funcion principal
int main()
{
NODO *L1; // Apuntador de tipo NODO para apuntar al primer elemento de la lista
NODO *U1; // Apuntador de tipo NODO para apuntar al ultimo elemento de la lista
//Creamos la lista L1 vacia
CrearLista(&L1, &U1);
// Llenamos la lista L1 con elementos pares
CrearLPares(&L1, &U1);
//Mostramos la lista L1 de pares
MostrarLPares(L1);

system("PAUSE");
return(0);
}

void CrearLista (NODO **Cab, NODO **Final)
{
*Cab=NULL;
*Final=NULL;
}

void CrearLPares(NODO **Cab, NODO **Final)
{
int Num, Ctdor, i;
NODO *P;
Ctdor = 0; i = 1;
//system("CLS");
cout <<"Cuanto numeros pares desea ingresar " ;
cin >>Num;
while(Ctdor < Num)
{
if(VrfcaPar(i))
{
cout<<"Elemento ---> "<<i<<endl;
//P = new NODO; // Que pasa si no hay memoria suficiente ?
P = (NODO*)malloc(sizeof(NODO)); // Que pasa si no hay memoria suficiente ?
if(*Cab == NULL)
{
P->Val = i;
P->Sgte=NULL;
*Cab = P;
*Final =P;
}
else
{
P->Val = i;
P->Sgte=NULL;
(*Final)->Sgte = P;
}
*Final = P;
//(*Final)->Sgte = NULL;
Ctdor = Ctdor + 1;
}
i = i + 1;
}
system("PAUSE");
}


bool VrfcaPar(int x)
{
if(x%2 == 0)
{
return(true);
}
else
{
return(false);
}

}

void MostrarLPares(NODO *Cab)
{
//system("CLS");
// Utilizamos una variable auxiliar para desplazarnos en la lista
NODO *P;
printf("\nlista = < ");
P = Cab;
while(P != NULL)
{
cout<<P->Val<<" ";
P = P->Sgte;
}
cout<<">"<<endl;
system("PAUSE");
}[/color][/li]
[li][/li]
[/list]

Código [Seleccionar] Expandir


// Listas Dobles
using namespace std;

typedef int TD;// crea un sinomino de int

struct NODO
{
TD val;
NODO *ante;
NODO *sgte;
};
void crearLista(NODO **Cabi, NODO **Cabu);// doble apúntador porque *cab es apuntador
void insertarIni(NODO **Cabi,NODO **Cabu, TD dato);
void mostrarNodos(NODO *Cabi);

int main()
{
NODO *ai, *au;
crearLista(&ai, &au);

insertarIni(&ai,&au, 10);
insertarIni(&ai,&au, 20);
insertarIni(&ai,&au, 30);

mostrarNodos(ai);


cout <<("\n\n");
system("pause");
return(0);
}

void crearLista(NODO **Cabi, NODO **Cabu)// doble apúntador porque *cab es apuntador
{
*Cabi=NULL;
*Cabu=NULL;

}

void insertarIni(NODO **Cabi,NODO **Cabu, TD dato)
{
NODO * p;

p=(NODO*)malloc(sizeof(NODO));//MALLOC DEVUELVE LA VARIABLE NO A VOID SINO A NODO

if(p==NULL){// hubo exito en la separacion de memoria
printf("nO HAY espacio en la RAM");
exit(0);
}
else{
p->val=dato;
p->ante=NULL;
p->sgte=NULL;
if(*Cabi==NULL){
*Cabi=p;
*Cabu=p;
}
else{
p->sgte=*Cabi;
(*Cabi)->ante=p;//ya que el * y -> tienen la misma prioridad.
*Cabi=p;
}
}
}
void mostrarNodos(NODO *Cabi)
{
NODO *p;
p=Cabi;
while(p!=NULL){//si pusiera p->sgte!=NULL no mostraria al 10 yaq psgte no existe
cout << p->val<<",";
p=p->sgte;
}
} [/code=c]


Los vectores dinamicos tiene las mismas propiedades que los vectores estaticos lo que varia  es la creación en la cual las dimensiones del mismo son ingresadas en tiempo de ejecucion. Una vez asignadas estas dimensiones ya no se pueden modificar.
En este programa se puede relizar las operaciones de leer,mostrar,ordenar y eliminar un vector dinamico, ademas de las operaciones insertar y eliminar elementos del vector dinamico.
Bueno al realizar este programa tengo una dificultad para el insertar y eliminar dinamicamente , me parecio interesante realizar esto , porque lo logico seria utilizar pilas y colas , pero en fin espero que me puedan apoyar que le falta a mi algoritmo para que no se cuelgue .


ATTE : ANTON RAMIREZ , LEONARDO VLADIMIR  (ALUMNO UNI)

Código [Seleccionar] Expandir

[list]
[li][ftp][/ftp][tt][color=blue]using namespace std;

int Menu();
void Linea();
void LeerVector(int **X, int *dimX);
void MostrarVector(int *X, int dimX);
void InsertarxPosic(int **X, int *dimX, int Pos);
void InsertarxValor(int **X, int *dimX, int Val);
void EliminarxPosic(int **X, int *dimX, int Pos);
void EliminarxValor(int **X, int *dimX, int Val);
void Redimensionar_Aumentar(int *X, int *dimX);
void Redimensionar_Disminuir(int *X, int *dimX);
void Redimensionar1(int *X, int *dimX);
void Redimensionar2(int *X, int *dimX);

int main()
{
  int *A, na, posic, valor, Opcion;
  A = NULL;
  do{
     Opcion = Menu();
     switch(Opcion)
     {
        case 1 : system("cls"); Linea();
              cout<<"\t\tRUTINA DE CREACION\n"; Linea();
              printf("\n");
              LeerVector(&A, &na);
              break;
        case 2 : system("cls"); Linea();
              cout<<"\t      RUTINA DE VIZUALIZACION\n"; Linea();
              printf("\n");
              MostrarVector(A, na);
              printf("\n\n"); system("pause");  
              break;
        case 3 : system("cls"); Linea();
              cout<<"\t    RUTINA INSERTA POR POSICION\n"; Linea();
              printf("\n");
              MostrarVector(A, na);
              if(A!=NULL){
                 cout<<"\n\nIngrese  la  POSICION => ";
                 cin>>posic;
                 posic = posic-1;
                 InsertarxPosic(&A, &na, posic);
              }
              printf("\n\n"); system("pause");
              break;
        case 4 : system("cls"); Linea();
              cout<<"\t    RUTINA ELIMINA POR POSICION\n"; Linea();
              printf("\n");
              MostrarVector(A, na);
              if(A!=NULL){
                 cout<<"\n\nIngrese la POSICION => ";
                 cin>>posic;
                 posic = posic-1;
                 EliminarxPosic(&A, &na, posic);
              }
              printf("\n\n"); system("pause");
              break;
        case 5 : system("cls"); Linea();
              cout<<"\t    RUTINA INSERTA POR VALOR\n"; Linea();
              printf("\n");
              MostrarVector(A, na);
              if(A!=NULL){
                 cout<<"\n\nIngrese el VALOR => ";
                 cin>>valor;
                 InsertarxValor(&A, &na, valor);
              }
              printf("\n\n"); system("pause");
              break;
        case 6 : system("cls"); Linea();
              cout<<"\t    RUTINA ELIMINA POR VALOR\n"; Linea();
              printf("\n");
              MostrarVector(A, na);
              if(A!=NULL){
                 cout<<"\n\nIngrese el VALOR => ";
                 cin>>valor;
                 EliminarxValor(&A, &na, valor);              
              }
              printf("\n\n"); system("pause");
              break;
        case 0 :
              free(A);
              A=NULL;
              exit(1);
     }
  }while(Opcion);
 
 printf("\n");
 system("PAUSE");
 return(0);
}

int Menu()
{
  int op;
  do{
  system("cls");
  printf("\n\t    OPERACIONES CON VECTORES DINAMICOS \n\n");
  printf("\t1.  Crear  \n");
  printf("\t2.  Mostrar \n");
  printf("\t3.  Insertar por Posicion \n");
  printf("\t4.  Eliminar por Posicion \n");
  printf("\t5.  Insertar por Valor \n");
  printf("\t6.  Eliminar por Valor \n");
  printf("\t0.  SALIR \n\n");
  printf("\tDigite su opcion => ");
  scanf("%d",&op);
 }while(op<0 || op>7);
 return(op);
}

void LeerVector(int **X, int *dimX)
{
  int N, i, val;
  printf("Ingrese dimension del vector : ");
  scanf("%d", &N);  
 
  *X=(int*)malloc(N*sizeof(int));
 
  if(*X == NULL)
  {
     printf("Error: No hay memoria suficiente...\n");
     system("pause");
     exit(1);
  }
  else
  {
     printf("\nIngrese los datos del vector ...\n\n");
     for(i=0;i<N;i++)
     {
        printf("X[%d] = ", i + 1);
        scanf("%d", *X+i);
     }
     *dimX=N;
  }
     
}

void MostrarVector(int *X, int dimX)
{
  if(X==NULL){
     printf("El vector esta VACIO ...");
  }
  else{
     printf("\nVECTOR [%d] = ", dimX);
     for(int i=0;i<dimX;i++)
     {
        printf("%4d", *(X+i));
     }
  }
}
 
void InsertarxPosic(int **X, int *dimX, int Pos)
{
  int val;
 
  if(*X == NULL){
     printf("\nEl vector esta VACIO ...\n\n");
  }
  else{
     if(Pos<*dimX && Pos>=0){
        Redimensionar_Aumentar(*X, dimX); //Redimensionar1(*X, dimX);
        for(int i=*dimX; i>Pos; i--){
           *(*X+i) = *(*X+(i-1));
        }
        printf("\n...Valor a Insertar -> "); scanf("%d", &val);
        *(*X+Pos) = val;
        MostrarVector(*X, *dimX);
     }
     else{
        printf("\nError: Posicion fuera de rango ...\n");
     }
  }
}
 

void InsertarxValor(int **X, int *dimX, int Val)
{
  int i, Hallado, Pos;
 
  i=0; Hallado=0;
  if(*X == NULL){
     printf("\nEl vector esta VACIO ...\n\n");
  }
  else{
        while(i<*dimX && !Hallado){
           if(*(*X+i)==Val){
           Hallado = 1;
           Pos = i;
           }
           i = i+1;
        }
  }
  if(Hallado){
     InsertarxPosic(&*X, dimX, Pos);
  }
  else{
     printf("\nError: Valor no encontrado ...\n");
  }
}

void EliminarxPosic(int **X, int *dimX, int Pos)
{  
 
  if(*X == NULL){
     printf("\nEl vector esta VACIO ...\n\n");
  }
  else{
     if(Pos<*dimX && Pos>=0){
        for(int i=Pos; i<*dimX; i++){
           *(*X+i) = *(*X+(i+1));
        }
        Redimensionar_Disminuir(*X, dimX); //Redimensionar2(*X, dimX);    
        MostrarVector(*X, *dimX);
     }
     else{
        printf("\nError: Posicion fuera de rango ...\n");
     }
  }
}

void EliminarxValor(int **X, int *dimX, int Val)
{
  int i, Hallado, Pos;
 
  i=0; Hallado=0;
  if(*X == NULL){
     printf("\nEl vector esta VACIO ...\n\n");
  }
  else{
     while(i<*dimX && !Hallado){
        if(*(*X+i)==Val){
           Hallado = 1;
           Pos = i;
        }
     i = i+1;
     }
  }  
  if(Hallado){
     EliminarxPosic(&*X, dimX, Pos);
  }
  else{
     printf("\nError: Valor no encontrado ...\n");
  }
}
 
void Redimensionar1(int *X, int *dimX)
{
  X = (int *)realloc(X,(*dimX+1)*sizeof(int));
  *dimX=*dimX+1;  
}

void Redimensionar2(int *X, int *dimX)
{
  X = (int *)realloc(X,(*dimX-1)*sizeof(int));  
  *dimX=*dimX-1;
}

void Redimensionar_Aumentar(int *X, int *dimX)
{
  int *A;
  int n=*dimX;
  n = n+1;
  A = (int *)malloc(n*sizeof(int));
  for(int i=0; i<n-1;){
     *(A+i) = *(X+i);
     i = i+1;
  }
  *dimX = n;
  X = A;
}

void Redimensionar_Disminuir(int *X, int *dimX)
{
  int *A;
  int n=*dimX;
  n = n-1;
  A = (int *)malloc(n*sizeof(int));
  for(int i=0; i<n;){
     *(A+i) = *(X+i);
     i = i+1;
  }
  *dimX = n;
  X = A;
}

void Linea()
{
  printf("\t==================================\n");
}[/color][/tt][/li]
[li][/li]
[/list]

Bueno lamento haber ofendido a alguien no quise hacer tareas , en realidad no sabia las reglas del juego ok , tienen razon nada de tareas , vamos hacer futuros ingenieros , para mi lo ideal seria intercambiar informacion no pedir que te hagan la tarea , los algoritmos son para analizar su solucion y una mejora eficaz , bueno ya entendi el mensaje , gracias

[Lh: Utiliza las etiquetas GeShi para poner código.]

No te preocupes amigo aqui tengo la solucion a tu problema claro que el decorado no me dio tiempo , pero eso es facil aqui te dejo el pseudocodigo pongo el using namespace std; porque utilizo el devc-++ bueno espero que te sirva esta con el menu :
ojo el ingreso esta implementado con numeros aleatorios , siempre hay que innovar en programacion , lo ves en opcion de mostrar , hay un insertar por posicion , espero que lo emplees bien , saludos:

Código (c) [Seleccionar] Expandir


#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <time.h>
#define Max 12000
#define TOPE 1000
#define randomize (srand(time(0)))
#define random(num) (rand()%(num))
using namespace std;

int Menu();
void leerVector(int X[Max],int *dimX);
void mostrarVector(int X[Max],int dimX);
void insertarxPosic(int X[Max],int *dimX,int posi,int dato);
void eliminarxPosic(int X[Max],int *dimX,int posi);
void ordenarxBurbuja(int X[Max],int *dimX);
int main()
{
int opcion,A[Max],na;
do{
opcion=Menu();
switch(opcion){
case 1: {
system("cls");
printf("\n*Rutina de lectura*\n\n");
leerVector(A,&na);
system("pause");
system("cls");
break;
}
case 2: {
system("cls");
printf("\n*Mostrando el Vector Generado*\n\n");
mostrarVector(A,na);
printf("\n\n");
system("pause");
system("cls");
break;
}
case 3: {
system("cls");
int d,pos,p;
printf("\n*Insercion de un elemento por posicion*");
cout<<"\n\nIngresar el dato a insertar [0,999] : ";
cin>>d;
cout<<"Ingresar la posicion a insertar : ";
cin>>p;
pos=p-1;
insertarxPosic(A,&na,pos,d);
printf("\n\n");
system("pause");
system("cls");
break;
}
case 4: {
system("cls");
int ps,pp;
printf("\n*Eliminacion de un elemento por posicion*");
cout<<"\n\nIngresar la posicion del dato que desea eliminar: ";
cin>>ps;
eliminarxPosic(A,&na,ps);
printf("\n\n");
system("pause");
system("cls");
break;
case 5: {
system("cls");
printf("\n*Ordenamiento por burbuja*\n\n");
ordenarxBurbuja(A,&na);
printf("\n\n");
system("pause");
system("cls");
break;
}
}
}
}while(opcion != 0);


return(0);
}

int Menu()
{
int op;

printf(" M E N U \n\n");
printf(" 0. Terminar \n");
printf(" 1. LeerVector \n");
printf(" 2. MostrarVector \n");
printf(" 3. InsertarxPosic \n");
printf(" 4. EliminarxPosic \n");
printf(" 5. ORDENARX BURBUJA \n");
do{
printf("Digite su opcion ---> ");
scanf("%d",&op);
}while(op<0 || op>5);
return(op);
}

void leerVector(int X[Max],int *dimX)
{
int n,i,val;
randomize;
printf("Ingrese la dimension de su vector: ");
cin>>n;
if(n<Max){
for(i=0;i<n;){
val=random(TOPE);
X[i]=val;
i=i+1;
}
*dimX=n;
printf("\n...Rutina de Lectura de Numeros Aleatorios Completada...\n\n");
}else{
printf("Dimension fuera de Rango...\n\n");
}
}

void mostrarVector(int X[Max],int dimX)
{
int i,val;
for(i=0;i<dimX;){
val=X[i];
if(i!=0){
if(i%20==0){
printf("\n");
}
}
printf("%3d ",val);
i=i+1;
}
}

void insertarxPosic(int X[Max],int *dimX,int posi,int dato)
{
int i,N;
N=*dimX;
N=N+1;
i=N;
if(i<Max&&posi<N){
while(i>posi){
X[i]=X[i-1];
i=i-1;
}
X[posi]=dato;
*dimX=N;
printf("\n%d INSERTADO en posicion %d\n\n",dato,posi+1);
mostrarVector(X,*dimX);
}else{
printf("Dimension o Posicion fuera de Rango\n");
}
}

void eliminarxPosic(int X[Max],int *dimX,int posi)
{
int i,N;
N=*dimX;
if(posi<N){
printf("\n%d ha sido ELIMINADO de posicion %d\n\n",X[posi-1],posi);
i=posi-1;
while(i<*dimX){
X[i]=X[i+1];
i=i+1;
}
*dimX=*dimX-1;
mostrarVector(X,*dimX);
}else{
if(posi==N){
printf("\n%d ha sido ELIMINADO de posicion %d\n\n",X[posi-1],posi);
*dimX=*dimX-1;
mostrarVector(X,*dimX);
}else{
printf("...Posicion fuera de Rango...");
}
}
}
void ordenarxBurbuja(int X[Max],int *dimX)
{
int i,j,aux,Np=*dimX-1;
long ini,fin;
ini = clock();
for(i=1;i<=Np;i++){
for(j=Np;j>=1;j--){
if(X[j-1]>X[j]){
aux=X[j-1];
X[j-1]=X[j];
X[j]=aux;
}
}
}
mostrarVector(X,*dimX);
fin=clock();
printf("\n\ntiempo de proceso %ld ",fin-ini);
printf("\ntiempo en segundos %f\n\n",(fin-ini)/(float)CLOCKS_PER_SEC);
}
AGRADECER NO CUESTA NADA


Lh: Utiliza las etiquetas GeShi para poner código.

hola a todos gracias por tu consejo Sagrini en realidad quisiera pedirte si me puedes brindar material de como empezar en linux , estoy muy implementado en dev y quiero tocar otras opciones , bueno en esta oportunidad te dejo un code sobre operaciones con files , compilalo con el dev-c++ y presiona F9 si gusta para compilar rapido .

AQUI podras apreciar aparte de las operaciones basicas como insertar registros , eliminar registros , mostrar registros , un actualizar con punteros , metodos de ordenamiento por codigo y por nombre es novedoso estos metodos , tambien hay varias decoraciones implemente algoritmos para capturar cuadros y hora -fecha del sistema este proyecto me costo muxo , quiero compartirlo con ustedes , haber Sagrini si das tu visto bueno a mi proyecto y como dices apoyame para comenzar con Linux , eh echo de todo un poco de todos los temas en dev++ pero ya quiero variar , ok espero tu respuesta y seguir en contacto si gustas seria bueno obtener tu ms para intercambiar informacion bueno me despido espero que puedan apreciar mi proyecto :



ATTE : ANTON RAMIREZ , LEONARDO VLADIMIR  (ALUMNO UNI)

Código (c) [Seleccionar] Expandir

#include <windows.h>//para los message box
#include <iostream>
#include <stdio.h> // Operaciones de archivos
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <ctype.h> // Operaciones toupper/tolower
using namespace std;

struct CLIENTE
{
char Cod[5];
char Nombre[25];
char Direccion[28];
char Tipo;
char tel[10];

};
// Declaracion global de la variable "Registro" de tipo struct CLIENTE
struct CLIENTE Registro;

// Declaracion global de la variable "*F" (apuntador de tipo archivo)
FILE *F;

int MenuCLIENTE();
void IngresarRegCLIENTE(); // Denominado tambien rutina de Altas
void BuscarxCodCLIENTE(); // Denominado tambien rutina de Consultas
void ActualizacionxCodCLIENTE(); // Denominado tambien rutina de Modificaciones
void EliminacionLogicaxCodCLIENTE(); // Denominado tambien rutina de Baja Logica
void EliminacionFisicaxCodCLIENTE(); // Denominado tambien rutina de Baja Fisica
void MostrarRegCLIENTE();
void Encabezado1();
void Raya58();
void Raya60();
int Menu();
void ordenarxcod();
void ordenarxnom();
void cuadro(int i,int j,int k,int l);
int main()
{
int Opcion;
do
{
Opcion = MenuCLIENTE();
switch(Opcion)
{
case 1 : IngresarRegCLIENTE();
break;
case 2 : BuscarxCodCLIENTE();
break;
case 3 : ActualizacionxCodCLIENTE();
break;
case 4 : EliminacionLogicaxCodCLIENTE();
break;
case 5 : EliminacionFisicaxCodCLIENTE();
break;
case 6 : MostrarRegCLIENTE();
break;
case 7 : ordenarxcod();
break;
case 8 : ordenarxnom();
break;
}
}while(Opcion != 0);
system("pause");
MessageBox(NULL, "Adios Gracias Por Usar Este Programa", "Adios =(", MB_ICONINFORMATION | MB_OK | MB_SYSTEMMODAL);
return(0);
}

int MenuCLIENTE()
{
int i;
textbackground(BLUE);
do
{
system("cls");
cuadro(1,1,80,25);
cuadro(28,2,50,4);
textcolor(LIGHTGREEN);
/*cout << "\n\n\r A R C H I V O D E C L I E N T E S";
cout << "\n\n\r Archivos SECUENCIALES en Lenguaje C ";
textcolor(WHITE);
cout << "\n\n\n\r 1.- INGRESAR Registros";
cout << "\n\r 2.- BUSCAR por CODIGO";
cout << "\n\r 3.- ACTUALIZAR Datos por CODIGO";
cout << "\n\r 4.- Eliminacion LOGICA por CODIGO";
cout << "\n\r 5.- Eliminacion FISICA por CODIGO (defragmentar)";
cout << "\n\r 6.- MOSTRAR Registros";
cout << "\n\r 7.- ORDENAR Registro por CODIGO";
cout << "\n\r 8.- ORDENAR Registro por NOMBRE";
textcolor(LIGHTRED);
cout << "\n\r 0.- TERMINAR";*/
textcolor(WHITE);
gotoxy(30,3);
textcolor(LIGHTRED);
printf("ARCHIVO DE CLIENTES");
gotoxy(15,5);printf("0.- TERMINAR");
textcolor(LIGHTGREEN);
gotoxy(15,7);printf("1.- INGRESAR Registros");
gotoxy(15,9);printf("2.- BUSCAR Regsitros por CODIGO");
gotoxy(15,11);printf("3.- ACTUALIZAR Datos por CODIGO");
gotoxy(15,13);printf("4.- ELIMINACION LOGICA por CODIGO");
gotoxy(15,15);printf("5.- ELIMINACION FISICA (Defragmentar)");
gotoxy(15,17);printf("6.- MOSTRAR Registros");
gotoxy(15,19);printf("7.- ORDENAR Registros por CODIGO");
gotoxy(15,21);printf("8.- ORDENAR Registros por NOMBRE");
textcolor(LIGHTRED);
gotoxy(15,23);printf(" Escojer su Opcion---------------------> ");
textcolor(WHITE);
cin >> i;
}while(i<0 || i>8);
return(i);

}

void IngresarRegCLIENTE()
{
char Codigo[15];
system("cls");

cout << "\n\r INGRESAR REGISTROS DE CLIENTES";
// Intenta abrir el archivo CLIENTES.SEC en modo de lectura/escritura
F = fopen("Cliente.Sec","rb+");
if(F == NULL)
{
// Crea el archivo en caso de no existir
F = fopen("Cliente.Sec","wb");
}

cout << "\n\n\n\rCodigo ---------> ";getchar();
//gets(Codigo);
cin>>Codigo;
fread(&Registro,sizeof(Registro),1,F); // Lee el Registro, de tamano=sizeof(Registro) del archivo "F"
// Ciclo mientras no se encuentre el final del archivo
while(!feof(F))
{
if(strcmp(Registro.Cod, Codigo)== 0)
{
cout << "\n\n\n\rRegistro DUPLICADO ...!!!";
fclose(F);
getch();
return;
}
fread(&Registro,sizeof(Registro),1,F);
}

strcpy(Registro.Cod, Codigo);
cout << "\n\rNombre ----------> ";getchar();
gets(Registro.Nombre);
cout << "\n\rDireccion ---------> ";
gets(Registro.Direccion);
cout << "\n\rTelefono/celular ---> ";
gets(Registro.tel);
cout << "\n\rTipo--> ";
cin >> Registro.Tipo;

// Grabar el Registro completo
fwrite(&Registro, sizeof(Registro), 1, F);
fclose(F); // Cierra el archivo

cout << "\n\n\n\rCLIENTE registrado !!!\n";
cout << "\n\r<<< ... PRESIONE ENTER para continuar >>>";
getch();
return;
}

void BuscarxCodCLIENTE()
{
//Numero de producto que desea consultar
char Codigo[15];
system("cls");

cout << "\n\rBUSCAR REGISTROS POR CODIGO DE CLIENTES";
// Intenta abrir el archivo CLIENTES.SEC, en modo de solo lectura
F = fopen("Cliente.Sec","rb");

if(F == NULL)
{
cout << "\n\n\n\rNo existe el archivo !!!\n";
cout << "\n\r<<< ... PRESIONE ENTER para continuar >>>";
getch();
return;
}

cout << "\n\n\n\r Codigo ---------> "; getchar(); gets(Codigo);

// Lee el "Registro", de tamano=sizeof(Registro) del archivo "F"
fread(&Registro, sizeof(Registro), 1, F);

while(!feof(F))
{
if(strcmp(Registro.Cod, Codigo)==0)
{
Encabezado1();
printf("\n%-8s%-25s%-25s%12s %-5c",Registro.Cod,Registro.Nombre,Registro.Direccion, Registro.tel,Registro.Tipo);
Raya60();
getch();
return;
}
fread(&Registro, sizeof(Registro), 1, F);
}
cout << "\n\rNo se encuentra ese registro !!!\n";
fclose(F);
cout << "\n\r<<< ... PRESIONE ENTER para continuar >>>";
getch();
return;
}

void ActualizacionxCodCLIENTE()
{
// Codigo de CLIENTE que desea modificar
char Codigo[15];
int op;
system("cls");

cout << "\n\rACTUALIZAR REGISTROS POR CODIGO DE CLIENTES";
// Intenta abrir el archivo CLIENTES.dat en modo de lectura/escritura
F = fopen("Cliente.Sec","rb+");
if(F == NULL) // Valida la existencia del archivo
{
cout << "\n\n\n\rNo existe el archivo !!!\n";
cout << "\n\r<<< ... PRESIONE ENTER para continuar >>>";
getch();
return;
}

cout << "\n\n\n\rCodigo ---------> "; getchar(); gets(Codigo);
// Lee el "Registro", de tamano=sizeof(Registro) del archivo "F"
fread(&Registro, sizeof(Registro), 1, F);

while(!feof(F))
{
if(strcmp(Registro.Cod, Codigo)==0)
{
Encabezado1();
printf("\n%-8s%-25s%-25s%12s %-5c",Registro.Cod,Registro.Nombre,Registro.Direccion, Registro.tel,Registro.Tipo);
Raya60();
cout << "\n\n\n\r";
system("pause");
do
{
op = Menu();
switch(op)
{
case 1 : system("cls");
textcolor(LIGHTGREEN);
cout << "\n\n\r Actualizacion de Clientes";
textcolor(WHITE);
cout << "\n\n\n\rIngrese nuevo dato";
cout << "\n\rNombre ---------> "; getchar(); gets(Registro.Nombre);
system("cls");
break;
case 2 : system("cls");
textcolor(LIGHTGREEN);
cout << "\n\n\r Actualizacion de Clientes";
textcolor(WHITE);
cout << "\n\n\n\rIngrese nuevo dato";
cout << "\n\rDireccion --------> ";getchar(); gets(Registro.Direccion);
system("cls");
break;
case 3 : system("cls");
textcolor(LIGHTGREEN);
cout << "\n\n\r Actualizacion de Clientes";
textcolor(WHITE);
cout << "\n\n\n\rIngrese nuevo dato";
cout << "\n\rTipo--> "; cin >> Registro.Tipo;
system("cls");
break;

}
}while(op != 0);

/**Es necesario reposicionar el apuntador del archivo al principio del
* registro que desea modificar, ya que al leer un registro, el
* apuntador se posiciona en el registro siguiente
* La funcion ftell(F) devuelve la posicion donde se encuentra el
* apuntador
*/
fseek(F, ftell(F)-sizeof(Registro), SEEK_SET);
// Graba el registro con los nuevos campos
fwrite(&Registro, sizeof(Registro), 1, F);
fclose(F);
cout << "\n\n\n\rRegistro modificado !!!\n";
cout << "\n\r<<< ... PRESIONE ENTER para continuar >>>";
getch();
return;
}
fread(&Registro, sizeof(Registro), 1, F);
}
cout << "\n\rNo se encuentra ese registro !!!\n";
fclose(F);
cout << "\n\r<<< ... PRESIONE ENTER para continuar >>>";
getch();
return;
}

void EliminacionLogicaxCodCLIENTE()
{
//numero de codigo que desea eliminar
char Codigo[15], op;
system("cls");

cout << "\n\rELIMINACION LOGICA DE REGISTROS DE CLIENTES";
F = fopen("Cliente.Sec","rb+");
if(F == NULL) // Checa la existencia del archivo
{
cout << "\n\n\n\rNo existe el archivo !!!\n";
cout << "\n\r<<< ... PRESIONE ENTER para continuar >>>";
getch();
return;
}

cout << "\n\n\n\rCodigo --------> "; getchar(); gets(Codigo);

fread(&Registro, sizeof(Registro), 1, F);
while(!feof(F))
{
if(strcmp(Registro.Cod, Codigo)==0)
{
Encabezado1();
printf("\n%-8s%-25s%-25s%12s %-5c",Registro.Cod,Registro.Nombre,Registro.Direccion, Registro.tel,Registro.Tipo);
Raya60();

strcpy(Registro.Cod, "----");
strcpy(Registro.Nombre, "----");
strcpy(Registro.Direccion, "----");
Registro.Tipo = '0';
do {
cout << "\n\n\r¿... SEGURO que desea BORRARLO ...? [S/N] ---> ";
cin>>op;
op=toupper(op);
}while(op!='S' && op!='N');

if(op == 'S')
{
/** Es necesario reposicionar el apuntador del archivo al principio del
* registro que desea modificar, ya que al leer un registro, el
* apuntador se posiciona en el registro siguiente
* La funcion ftell(F) devuelve la posicion donde se encuentra el
* apuntador
*/
fseek(F, ftell(F)-sizeof(Registro), SEEK_SET);
fwrite(&Registro, sizeof(Registro), 1, F);
cout << "\n\n\n\rRegistro eliminado !!!\n";
}
fclose(F);
cout << "\n\r<<< ... PRESIONE ENTER para continuar >>>";
getch();
return;
}
fread(&Registro, sizeof(Registro), 1, F);
}
cout << "\n\rNo se encuentra ese registro !!!\n";
fclose(F); // Cierra el archivo
cout << "\n\r<<< ... PRESIONE ENTER para continuar >>>";
getch();
return;
}

void EliminacionFisicaxCodCLIENTE()
{
//Variable para controlar el archivo temporal
FILE *Temporal;
system("cls");

cout << "\n\rELIMINACION FISICA DE REGISTROS DE CLIENTES";
// Intenta abrir el archivo CLIENTES.SEC en modo de solo lectura
F = fopen("Cliente.Sec","rb");
// Valida la existencia del archivo
if(F == NULL)
{
cout << "\n\n\n\rNo existe el archivo !!!\n";
cout << "\n\r<<< ... PRESIONE ENTER para continuar >>>";
getch();
return;
}
// Crea el archivo Temporal.Sec
Temporal = fopen("Temporal.Sec","wb");

fread(&Registro, sizeof(Registro), 1, F);
while(!feof(F))
{
if(strcmp(Registro.Cod, "----")!= 0)
// Graba el registro valido en el archivo temporal
fwrite(&Registro, sizeof(Registro), 1, Temporal);
//Lee el siguinete elemento del archivo
fread(&Registro, sizeof(Registro), 1, F);
}
//fcloseall(); // Cierra todos los archivos abiertos
fclose(F);
fclose(Temporal);
remove("Clientes.Sec"); //Elimina el archivo original
rename("Temporal.Sec", "Clientes.Sec");
//Renombra el archivo temporal con el nombre del archivo original

cout << "\n\n\n\rArchivo DEFRAGMENTADO ... !!!\n";
cout << "\n\r<<< ... PRESIONE ENTER para continuar >>>";
getch();
return;
}

void MostrarRegCLIENTE()
{
system("cls");

cout << "\n\r\t\t\tLISTADO DE REGISTROS DE CLIENTES\n\n";
F = fopen("Cliente.Sec","rb");
if(F == NULL)
{
cout << "\n\n\n\rNo existe el archivo !!!\n";
cout << "\n\r<<< ... PRESIONE ENTER para continuar >>>";
getch();
return;
}

Encabezado1();
fread(&Registro, sizeof(Registro), 1, F);
while(!feof(F))
{
printf("\n%-8s%-25s%-25s%12s %-5c",Registro.Cod,Registro.Nombre,Registro.Direccion, Registro.tel,Registro.Tipo);
fread(&Registro,sizeof(Registro),1,F);
}
fclose(F); // Cierra el archivo
Raya60();
cout << "\n\rFin del listado !!!\n";
cout << "\n\r<<< ... PRESIONE ENTER para continuar >>>";
getch();
return;
}

void Encabezado1()
{
Raya58();
cout << "\nCODIGO N O M B R E D I R E C C I O N TELEFONO TIPO";
Raya60();
}

void Raya58()
{
cout << "\n\r==============================================================================";
}

void Raya60()
{
cout << "\n\r------------------------------------------------------------------------------";
}

int Menu()
{
int i;
do
{
system("cls");
textcolor(LIGHTGREEN);
cout << "\n\n\r Actualizacion de Clientes";
textcolor(WHITE);
cout << "\n\n\n\r 1.- ACTUALIZAR Nombre";
cout << "\n\r 2.- ACTUALIZAR Direccion";
cout << "\n\r 3.- ACTUALIZAR Tipo";
textcolor(LIGHTRED);
cout << "\n\r 0.- TERMINAR";
textcolor(WHITE);

cout << "\n\n\n\r Seleccione su opcion ---> ";
cin >> i;
}while(i<0 || i>3);
return(i);
}
void ordenarxcod(){
FILE *F;
CLIENTE A,B,aux;
int i,j,n;
F=fopen("Cliente.Sec","rb+");
if(F==NULL){
printf("No se puede abrir el archivo.\n");
exit(1);
}
fseek(F,0,SEEK_END);
n=ftell(F)/sizeof(A);
for(i=0;i<=n-1;i++){
for(j=i+1;j<=n;j++){
fseek(F,i*sizeof(A),SEEK_SET);
fread(&A,sizeof(A),1,F);
fseek(F,j*sizeof(B),SEEK_SET);
fread(&B,sizeof(B),1,F);
if(strcmp(A.Cod,B.Cod)==1){
aux=A;
A=B;
B=aux;
fseek(F,i*sizeof(A),SEEK_SET);
fwrite(&A,sizeof(A),1,F);
fseek(F,j*sizeof(B),SEEK_SET);
fwrite(&B,sizeof(B),1,F);
}
}
}
MostrarRegCLIENTE();
}
void ordenarxnom(){
FILE *F;
CLIENTE A,B,aux;
int i,j,n;
F=fopen("Cliente.Sec","rb+");
if(F==NULL){
printf("No se puede abrir el archivo.\n");
exit(1);
}
fseek(F,0,SEEK_END);
n=ftell(F)/sizeof(A);
for(i=0;i<=n-1;i++){
for(j=i+1;j<=n;j++){
fseek(F,i*sizeof(A),SEEK_SET);
fread(&A,sizeof(A),1,F);
fseek(F,j*sizeof(B),SEEK_SET);
fread(&B,sizeof(B),1,F);
if(strcmp(A.Nombre,B.Nombre)==1){
aux=A;
A=B;
B=aux;
fseek(F,i*sizeof(A),SEEK_SET);
fwrite(&A,sizeof(A),1,F);
fseek(F,j*sizeof(B),SEEK_SET);
fwrite(&B,sizeof(B),1,F);
}
}
}
MostrarRegCLIENTE();
}
void cuadro(int i,int j,int k,int l){
register int a;
for(a=j+1;a<l;a++){
gotoxy(i,a);
printf("%c",186);
gotoxy(k,a);
printf("%c",186);
}
for(a=i+1;a<k;a++){
gotoxy(a,j);
printf("%c",205);
gotoxy(a,l);
printf("%c",205);
}
gotoxy(i,j);printf("%c",201);
gotoxy(k,j);printf("%c",187);
gotoxy(i,l);printf("%c",200);
gotoxy(k,l);printf("%c",188);
gotoxy(1,1);
}

HOLA TODOS LOS PROGRAMADORES ESPERO OBTENER BUENOS RESULTADOS Y HACER DISTINTAS AMISTADES E INFUNDIR EN ESTA RAMA , EN ESTA OPORTUNIDAD LES BRINDO UN TRABAJO HECHO EN BASE A LOS METODOS DE ORDENAMIENTO DE CAIRO , ESTAN TODOS ADAPTADOS Y LO ELEGANTE DE ESTE PROGRAMA ES QUE PUEDO SABER QUE METODO ES MAS RAPIDO PARA ELEMENTOS ALEATORIOS MAYORES DE 20000 Y ASI , ESPERO SUS OPINIONES Y COMENTARIOS ATTE, EL QUE DESEA MANDARME UN MENSAJE Y SE LO PUEDO FACILITAR O ALGUIEN ME PUEDE ORIENTAR COMO PUEDO COLGAR PROGRAMAS A ESTA PAGINA

ATTE : ANTON RAMIREZ , LEONARDO VLADIMIR  (ALUMNO UNI)

BUENO SI GUSTAN AQUI LES DEJO EL PSEUDOCIGO , SOLO ES CUESTION DE COMPILAR UTILIZO EL DEV-C++ , ESPERO COMENTARIOS :

Código (cpp) [Seleccionar] Expandir


/**
*Nombre del programa: METODOS DE ORDENAMIENTO
*Descripción: Este menu de ordenamiento contiene los 10 metodos de ordenamiento del libro de cairo ,aqui se podra mostrar
* cual es el mas rapido, cual es el mas lento .
* La forma que utilize para hallar el tiempo de cada ordenamiento para un mismo vector que tenga los mismos
* elementos aleatorios es ir al subprograma leerVector y poner en comentario a random cosa que siempre me
* va mostrar el mismo vector con los mismos elementos y por eso ya con el mismo vector generado siempre que
* compilo puedo distribuir el tiempo y saber quien es el mas rapido o mas lento.
*Autor: Anton ramirez,leonardo vladimir(20090231A)
*Fecha: 05/10/2010
*
*/

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <time.h>
#define Max 120000
#define TOPE 1000
#define randomize (srand(time(0)))
#define random(num) (rand()%(num))

using namespace std;

int METODODEORDENAMIENTO();
void leerVector(int X[Max],int *dimX);
void mostrarVector(int X[Max],int dimX);
void ordenarxBurbuja(int X[Max],int dimX);
void ordenarxBurbuja_senal(int X [Max],int *dimX);
void ordenarxShaker_sort(int X[Max],int *dimX);
void ordenarxInsercion_directa(int X[Max],int *dimX);
void ordenarxInsercion_binaria(int X[Max],int *dimX);
void ordenarxSeleccion_directa(int X[Max],int dimX);
void ordenarxShell(int X[Max],int *dimX);
void ordenarxQuicksort_recursivo(int X[Max],int *dimX);
void Reduce_recursivo(int X[Max],int INI,int FIN);
void ordenarxQuicksort_iterativo(int X[Max],int *dimX);
int Reduce_iterativo(int X[Max],int INI,int FIN);
void ordenarxHeapsort(int X[Max],int *dimX);
void Inserta_monticulo(int X[Max],int *dimX);
void Elimina_monticulo(int X[Max],int *dimX);

int main()
{
int Opcion,A[Max],na;
do{
Opcion = METODODEORDENAMIENTO();
switch(Opcion)
{
case 1: {
system("cls");
printf("\n*******************Proceso de Lectura del Vector Aleatorio********************\n\n");
leerVector(A,&na);
system("pause");
system("cls");
break;
}
case 2: {
system("cls");
printf("\n****************Mostramos el Vector Aleatorio Generado***********************\n\n");
mostrarVector(A,na);
printf("\n\n");
system("pause");
system("cls");
break;
}
case 3: {
system("cls");
printf("\n******************Ordenamiento por el Metodo de Burbuja************************\n\n");
ordenarxBurbuja(A,na);
printf("\n\n");
system("pause");
system("cls");
break;
}
case 4: {
system("cls");
printf("\n**************Ordenamiento por el Metodo de Burbuja con Senal****************\n\n");
ordenarxBurbuja_senal(A,&na);
printf("\n\n");
system("pause");
system("cls");
break;
}
case 5: {
system("cls");
printf("\n***************Ordenamiento por el Metodo de Shaker sort**********************\n\n");
ordenarxShaker_sort(A,&na);
printf("\n\n");
system("pause");
system("cls");
break;
}
case 6: {
system("cls");
printf("\n***************Ordenamiento por el Metodo de Insercion Directa*****************\n\n");
ordenarxInsercion_directa(A,&na);
printf("\n\n");
system("pause");
system("cls");
break;
}
case 7: {
system("cls");
printf("\n*******************Ordenamiento por el Metodo de Insercion Binaria************\n\n");
ordenarxInsercion_binaria(A,&na);
printf("\n\n");
system("pause");
system("cls");
break;
}
case 8:{
system("cls");
printf("\n***************Ordenacion por el Metodo de Seleccion Directa******************\n\n");
ordenarxSeleccion_directa(A,na);
printf("\n\n");
system("pause");
system("cls");
break;
}
case 9:{
system("cls");
printf("\n******************Ordenamiento por el Metodo de Shell**************************\n\n");
ordenarxShell(A,&na);
printf("\n\n");
system("pause");
system("cls");
break;
}
case 10:{
system("cls");
printf("\n**************Ordenamiento por el Metodo Quicksort Recursivo*******************\n\n");
ordenarxQuicksort_recursivo(A,&na);
printf("\n\n");
system("pause");
system("cls");
break;
}
case 11:{
system("cls");
printf("\n*************Ordenamiento por el Metodo Quicksort Iterativo*********************\n\n");
ordenarxQuicksort_iterativo(A,&na);
printf("\n\n");
system("pause");
system("cls");
break;
}
case 12:{
system("cls");
printf("\n************************Ordenamiento por el Metodo del Monticulo****************\n\n");
ordenarxHeapsort(A,&na);
printf("\n\n");
system("pause");
system("cls");
break;
}
}
}while(Opcion != 0);
return(0);
}

int METODODEORDENAMIENTO()
{
int i;
do
{
system("cls");
printf("================================================================================\n");
cout << "----------------M E T O D O S D E O R D E N A M I E N T O S-----------------";
printf("================================================================================\n");
cout << "\n ESCOJER EL MEJOR METODO PARA ORDENAR UN VECTOR: ";
cout << "\n\n\r 0.- TERMINAR";
cout << "\n\r 1.- LEER VECTOR ";
cout << "\n\r 2.- MOSTRAR VECTOR ";
cout << "\n\r 3.- ORDENAR X BURBUJA";
cout << "\n\r 4.- ORDENAR X BURBUJA_SENAL";
cout << "\n\r 5.- ORDENAR X SHAKER_SORT";
cout << "\n\r 6.- ORDENAR X INSERCION_DIRECTA";
cout << "\n\r 7.- ORDENAR X INSERCION_BINARIA";
cout << "\n\r 8.- ORDENAR X SELECCION_DIRECTA";
cout << "\n\r 9.- ORDENAR X SHELL";
cout << "\n\r 10.- ORDENAR X QUICKSORT_RECURSIVO";
cout << "\n\r 11.- ORDENAR X QUICKSORT_ITERATIVO";
cout << "\n\r 12.- ORDENAR X HEAPSORT";
cout << "\n\n\n\r Seleccione su opcion ---> ";
cin >> i;
}while(i<0 || i>12);
return(i);

}
void leerVector(int X[Max],int *dimX)
{
int n,i,val;
randomize;//randomize es aqui donde si lo pongo como comentario me genera el mismo vector y es mas facil medir el tiempo..
printf("INGRESE LA DIMENSION DE SU VECTOR A GENERAR: ");
cin>>n;
if(n<Max)
{
for(i=0;i<n;)
{
val=random(TOPE);
X[i]=val;
i=i+1;
}
*dimX=n;
printf("\n............Proceso de Lectura de Numeros Aleatorios Completada............\n\n");
}
else
{
printf("Dimension fuera de Rango...\n\n");
}
}

void mostrarVector(int X[Max],int dimX)
{
int i,val;
if(dimX>0){
for(i=0;i<dimX;)
{
val=X[i];
printf("%3d ",val);
i=i+1;
}
}
else{
printf("Vector vacio ...!\n\n");
}
}
void ordenarxBurbuja(int X[Max],int dimX)
{
int i,j,aux;
long ini,fin;
ini = clock();// INICIA EL PROCESO DEL ORDENAMIENTO
for(int i=0;i<dimX-1;i++){
for(int j=i+1;j<dimX;j++){
if(X[i]>X[j]){
aux=X[j];
X[j]=X[i];
X[i]=aux;
}
}
}
mostrarVector(X,dimX);
fin=clock();
printf("\n\ntiempo en segundos %f s\n\n",(fin-ini)/(float)CLOCKS_PER_SEC);
}

void ordenarxBurbuja_senal(int X [Max],int *dimX)
{
bool BAND=false;
int i=0,j,aux,
N=*dimX-1;
long ini,fin;
ini = clock();
while((i<=N-1)&&(!BAND))
{
BAND=true;
for(j=0;j<=N-1;j++)
{
if(X[j]>X[j+1])
{
aux=X[j];
X[j]=X[j+1];
X[j+1]=aux;
BAND=false;
}
}
i=i+1;
}
mostrarVector(X,*dimX);
fin=clock();
printf("\n\ntiempo en segundos %f s\n\n",(fin-ini)/(float)CLOCKS_PER_SEC);
}

void ordenarxShaker_sort(int X[Max],int *dimX)//METODO DE LA SACUDIDA
{
int i,IZQ=1,aux,N=*dimX-1,k=N,DER=N;
long ini,fin;
ini = clock();
while(DER>=IZQ)
{
for(i=DER;i>=IZQ;i--)
{
if(X[i-1]>X[i])
{
aux=X[i-1];
X[i-1]=X[i];
X[i]=aux;
k=i;
}
}
IZQ=k+1;
for(i=IZQ;i<=DER;i++)
{
if(X[i-1]>X[i])
{
aux=X[i-1];
X[i-1]=X[i];
X[i]=aux;
k=i;
}
}
DER=k-1;
}
mostrarVector(X,*dimX);
fin=clock();
printf("\n\ntiempo en segundos %f s\n\n",(fin-ini)/(float)CLOCKS_PER_SEC);
}

void ordenarxInsercion_directa(int X[Max],int *dimX)
{
int i,aux,k,N=*dimX-1;
long ini,fin;
ini = clock();
for(i=1;i<=N;i++)
{
aux=X[i];
k=i-1;
while((k>=0)&&(aux<X[k]))
{
X[k+1]=X[k];
k=k-1;
}
X[k+1]=aux;
}
mostrarVector(X,*dimX);
fin=clock();
printf("\n\ntiempo en segundos %f s\n\n",(fin-ini)/(float)CLOCKS_PER_SEC);
}

void ordenarxInsercion_binaria(int X[Max],int *dimX)
{
int i,aux,IZQ,DER,M,j,N=*dimX-1;
long ini,fin;
ini = clock();
for(i=1;i<=N;i++)
{
aux=X[i];
IZQ=0;
DER=i-1;
while(IZQ<=DER)
{
M=(int)((IZQ+DER)/2);
if(aux<=X[M]){
DER=M-1;
}
else
{
IZQ=M+1;
}
}
j=i-1;
while(j>=IZQ)
{
X[j+1]=X[j];
j=j-1;
}
X[IZQ]=aux;
}
mostrarVector(X,*dimX);
fin=clock();
printf("\n\ntiempo en segundos %f s\n\n",(fin-ini)/(float)CLOCKS_PER_SEC);
}

//ORDENAMIENTO POR SELECCION
/*ESTE METODO CONSISTE EN ENCONTRAR EL MENOR ELEMENTO DEL ARREGLO
Y UBICARLO AL PRINCIPIO... LUEGO SE BUSCA EL MENOR ELEMENTO DEL RESTO Y SE
UBICA EN SEGUNDO LUGAR. SE REPITE EL PROCESO N-1 VECES*/
void ordenarxSeleccion_directa(int X[Max],int dimX)
{
int i,MENOR,k,j;
time_t ini,fin;
ini = clock();// inicia el calculo del metodo de ordenamiento

for(i=0;i<dimX;)
{
MENOR=X[i];
k=i;
for(j=i+1;j<dimX;)
{
if(X[j]<MENOR)
{
MENOR=X[j];
k=j;
}
j=j+1;
}
X[k]=X[i];
X[i]=MENOR;
i=i+1;
}
mostrarVector(X,dimX);
fin=clock();
printf("\n\ntiempo en segundos %f s\n\n",(fin-ini)/(double)CLOCKS_PER_SEC);
}

void ordenarxShell(int X[Max],int *dimX)
{
int i,aux,N=*dimX-1,INT=N+1;
bool BAND;
long ini,fin;
ini = clock();
while(INT>0)
{
INT=(int)(INT/2);
BAND=true;
while(BAND)
{
BAND=false;
i=0;
while((i+INT)<=N)
{
if(X[i]>X[i+INT])
{
aux=X[i];
X[i]=X[i+INT];
X[i+INT]=aux;
BAND=true;
}
i=i+1;
}
}
}
mostrarVector(X,*dimX);
fin=clock();
printf("\n\ntiempo en segundos %f s\n\n",(fin-ini)/(float)CLOCKS_PER_SEC);
}

void ordenarxQuicksort_recursivo(int X[Max],int *dimX)
{
int N=*dimX-1;
long ini,fin;
ini = clock();
Reduce_recursivo(X,0,N);
mostrarVector(X,*dimX);
fin=clock();
printf("\n\ntiempo en segundos %f s\n\n",(fin-ini)/(float)CLOCKS_PER_SEC);
}

void Reduce_recursivo(int X[Max],int INI,int FIN)
{
int IZQ=INI,DER=FIN,POS=INI,aux;
bool BAND=true;
while(BAND)
{
BAND=false;
while((X[POS]<=X[DER])&&(POS!=DER))
{
DER=DER-1;
}
if(POS!=DER)
{
aux=X[POS];
X[POS]=X[DER];
X[DER]=aux;
POS=DER;
while((X[POS]>=X[IZQ])&&(POS!=IZQ))
{
IZQ=IZQ+1;
}
if(POS!=IZQ)
{
BAND=true;
aux=X[POS];
X[POS]=X[IZQ];
X[IZQ]=aux;
POS=IZQ;
}
}
}
if((POS-1)>INI)
{
Reduce_recursivo(X,INI,POS-1);
}
if(FIN>(POS+1))
{
Reduce_recursivo(X,POS+1,FIN);
}
}
void ordenarxQuicksort_iterativo(int X[Max],int *dimX)
{
int full=0,I,F,POS,N=*dimX-1,P1[Max],P2[Max];
long ini,fin;
P1[full]=0;//PILA MENOR
P2[full]=N;//PILA MAYOR
ini = clock();
while(full>=0)
{
I=P1[full];
F=P2[full];
full=full-1;
POS=Reduce_iterativo(X,I,F);
if(I<(POS-1))
{
full=full+1;
P1[full]=I;
P2[full]=POS-1;
}
if(F>(POS+1))
{
full=full+1;
P1[full]=POS+1;
P2[full]=F;
}
}
mostrarVector(X,*dimX);
fin=clock();
printf("\n\ntiempo en segundos %f s\n\n",(fin-ini)/(float)CLOCKS_PER_SEC);
}

int Reduce_iterativo(int X[Max],int INI,int FIN)
{
int IZQ=INI,DER=FIN,aux,POS=INI;
bool BAND=true;
while(BAND)
{
while((X[POS]<=X[DER])&&(POS!=DER))
{
DER=DER-1;
}
if(POS==DER)
{
BAND=false;
}
else
{
aux=X[POS];
X[POS]=X[DER];
X[DER]=aux;
POS=DER;
while((X[POS]>=X[IZQ])&&(POS!=IZQ))
{
IZQ=IZQ+1;
}
if(POS==IZQ)
{
BAND=false;
}
else
{
aux=X[POS];
X[POS]=X[IZQ];
X[IZQ]=aux;
POS=IZQ;
}
}
}
//return(POS);// POS variable es una variable donde se almacena el resultado del algoritmo.
}

void ordenarxHeapsort(int X[Max],int *dimX)//METODO DEL MONTICULO
{//METODO EFICIENTE QUE TRABAJA CON ARBOLES .
long ini,fin;
ini = clock();
Inserta_monticulo(X,dimX);
Elimina_monticulo(X,dimX);
mostrarVector(X,*dimX);
fin=clock();
printf("\n\ntiempo en segundos %f s\n\n",(fin-ini)/(float)CLOCKS_PER_SEC);
}

void Inserta_monticulo(int X[Max],int *dimX)
{
int i,k,aux,N=*dimX-1;
bool BAND;
for(i=1;i<=N;i++)
{
k=i;
BAND=true;
while((k>0)&&BAND)
{
BAND=false;
if(X[k]>X[(int)(k/2)])
{
aux=X[(int)(k/2)];
X[(int)(k/2)]=X[k];
X[k]=aux;
k=(int)(k/2);
BAND=true;
}
}
}
}

void Elimina_monticulo(int X[Max],int *dimX)
{
int i,aux,IZQ,DER,k,AP,MAYOR,N=*dimX-1;
bool BOOL;
for(i=N;i>=1;i--)
{
aux=X[i];
X[i]=X[0];
IZQ=1;
DER=2;
k=0;
BOOL=true;
while((IZQ<i)&&BOOL)
{
MAYOR=X[IZQ];
AP=IZQ;
if((MAYOR<X[DER])&&(DER!=i))
{
MAYOR=X[DER];
AP=DER;
}
if(aux<MAYOR)
{
X[k]=X[AP];
k=AP;
}
else
{
BOOL=false;
}
IZQ=k*2;
DER=IZQ+1;
}
X[k]=aux;
}
}