Manejo de Archivos

        Un archivo es una secuencia de bits que facilita el lenguaje para almacenar los datos en forma permanente en los dispositivos de
almacenamiento.


ifsteam  -> iostream  conecta un archivo de entrada
ofstream -> ostream   conecta un archivo de salida
fstream  -> iostream  conecta un archivo de entrada y salida
         fstream.h define las clases ifstream, ostream y fstream para operaciones de lectura, escritura y lectura/escritura en archivos respectivamente, utilizamos la función miembro "open" para abrir el archivo, escribimos en el archivo los datos utilizando el operador de inserción y por último cerramos el archivo por medio de la función miembro "close"


#include <fstream.h>
int main()
{
    ofstream archivo;  // objeto de la clase ofstream

    archivo.open("datos.txt");

    archivo << "Primera línea de texto" << endl;
    archivo << "Segunda línea de texto" << endl;
    archivo << "Última línea de texto" << endl;

    archivo.close();
    return 0;
}

Busqueda

Es una operación que consiste en localizar un elemento dentro de la estructura de datos

Búsqueda Secuencial (lineal): 

Consiste en recorrer el arreglo, elemento por elemento dentro de cada una de las casillas comparándola con el valor que se va a buscar, al coincidir se finaliza la búsqueda.

#include <iostream> 

#include <conio.h>

using namespace std;

char vector[20]={'a','b','c','d','e','f','g',…
char busca;
int i;

main ()
{
cout << "Elemento a buscar:" << endl

cin >> busca;
 

 for(i = 0; i<20; i++){
if (vector[i]==busca) cout << "Se encontro coincidencia" << endl
 

}

Búsqueda Binaria:

Es el método más recomendado para encontrar elementos en un arreglo ordenado, este proceso inicia comparando el elemento central del arreglo con el elemento que se desea buscar, si existe coincidencia se finaliza la búsqueda, Sino el elemento que se desea buscar se ubica en el lado izquierdo (inferior) o en  el lado derecho (superior) generando una división, Si el elemento buscado es mayor se procede a hacer búsqueda binaria en el lado derecho (superior), si el valor buscado es menor  se realiza la búsqueda binaria en el lado izquierdo (inferior), así sucesivamente hasta encontrar el elemento. Es decir, este método realiza en un arreglo división y división hasta encontrar el elemento.

 
#include <iostream>
using std::cout;
using std::cin;
using std::endl;
void mostrarArreglo(const int[], int); //prototipo de funcion que recibe un arreglo constante
int busquedaBinaria(const int[], int, int); //arreglo, tamano, clave
void ordenarArreglo(int[], int); //prototipo que modifica y ordena el arreglo
void intercambiar(int&, int&); //prototipo, intercambia los valores de dos elementos
int main()
{
  int clave =0;
  const int tamano = 15;
  int arreglo[tamano] = {25,17,13,16,41,32,12,115,95,84,54,63,78,21,10};
  //ordenamos el arreglo para que funcione la busquedaBinaria
  ordenarArreglo(arreglo,tamano);
  cout << "Elementos del arreglo: " << endl;
  mostrarArreglo(arreglo,tamano);
  cout << "Indique un valor a buscar y se le devolvera el indice: " << endl;
  cin >> clave;
  cout<< "Su valor se encuentra en arreglo["<<busquedaBinaria(arreglo,tamano,clave)<<"]" << endl;
  cout << "Fin del programa :)" << endl;
  return 0;
} //fin de main
void mostrarArreglo(const int arreglo[], int tamano)
{
  for (int i = 0 ; i < tamano ; i++)
    cout << "arreglo[" << i << "]=" << arreglo[i] << endl;
}
int busquedaBinaria(const int arreglo[], int tamano, int clave)
{
  int Iarriba = tamano-1;
  int Iabajo = 0;
  int Icentro;
  while (Iabajo <= Iarriba)
    {
      Icentro = (Iarriba + Iabajo)/2;
      if (arreglo[Icentro] == clave)
 return Icentro;
      else
 if (clave < arreglo[Icentro])
   Iarriba=Icentro-1;
 else
   Iabajo=Icentro+1;
    }
  return -1;
}
void ordenarArreglo(int arreglo[], int tamano)
{
  for (int i = 0; i< tamano -1 ; i++)
    for (int j = 0; j< tamano -1 ; j++)
      if (arreglo[j] > arreglo[j+1])
 intercambiar(arreglo[j],arreglo[j+1]);
}
void intercambiar(int &a, int &b)
{
  int tmp = b;
  b = a;
  a = tmp;
}

Metodo de Ordenamiento en C++

Un proceso muy común en C++ es el método de ordenamiento; este proceso consiste en reacomodar los elementos de una lista al orden que uno desee.

Entre las más resaltantes existen:

Ordenamiento por Selección:

Este método consiste en buscar el dato más pequeño de una lista, intercambiándolo por el dato que se encuentra en la primera posición, luego el segundo más pequeño intercambiándolo por el que se encuentra en la segunda posición, así sucesivamente.

#include<iostream.h>

void intercambio (int &x, int &y){
    int aux = x;
    x=y;
    y=aux;}

void ordintercambio (int a[], int n){
    int i,j;
    for(i=0; i<n; i++)
        for(j=0; j<n; j++)
            if(a[i] < a[j])
                intercambio (a[i], a[j]);}
void imprimir (int a[], int n){
    for(int i=0; i<n; i++)
        cout<<a[i]<<"    \n";}

void main(void){
    int lista[20] = {80,15,13,4,6,9,75,86,99,32,95,1,87,51,2,3,7,99,10,20};
    int i;
   
    cout<<"Lista Original \n";
    imprimir (lista,20);
    ordintercambio (lista,20);
    cout<<endl<<"Lista Ordenada \n";
    imprimir (lista,20);
}

Dicho programa consiste en ordenar las 20 posiciones de menor a mayor (80,15,13,4,6,9,75,86,99,32,95,1,87,51,2,3,7,99,10,20)

Ordenamiento Burbuja:

             Consiste en ir comparando cada entrada con la siguiente e intercambiar sus posiciones, haciendo que el elemento más grande vaya hasta el último renglón y el más pequeño al primer renglón, así sucesivamente.

Se le denomina Ordenamiento "Burbuja" debido a que los elementos más grandes van subiendo ("ultimo") como si fueran burbujas.

#include <iostream>

 using namespace::std;

 enum { Tamano = 10};

 // Cambiar la variable Tamaño para ordenar una

 // cantidad diferente de datos

 /*Prototipo de función Imprime */

 void Imprime( int A[]);

 /*prototipo de función Recibe */

 void Recibe ( int B[]);

 /*Prototipo de función Burbuja */

 void Burbuja( int C[]);

 int main()

 {      // Abre main

 int Arreglo[Tamano] = {0, 0};

 // El Arreglo se ha inicializado a 0

 cout <<"\n Este programa recibe una serie de %d números enteros" << Tamano;

 cout <<" y los ordena por medio del algoritmo de ordenación burbuja. "<< endl;

 /*Se llena el arreglo mediante un llamado a la función Recibe*/

 Recibe(Arreglo);

 /*Se imprime el arreglo con las entradas en el orden original */

 cout <<"\nEsta es el orden en que se introdujeron los elementos: " <<endl;

 Imprime(Arreglo);

 /*Se ordena el arreglo mediante una llamada a la función Burbuja*/

 Burbuja(Arreglo);

 /*Se imprime el arreglo ordenado */

 cout <<"\nEste es el orden después de el ordenamiento burbuja. " <<endl;

 Imprime(Arreglo);

 return 0;

 }           // Cierra main

 //FUNCION IMPRIME

 void Imprime( int A[] )

 {     // Abre la función Imprime

 for ( int j = 0; j < Tamano; j++ )

 {      // Abre for

 cout << "\t" << A[j];

 if ( 0 == j + 1 % 10)

 cout <<endl <<endl;

 }      // Cierra for

 cout <<endl <<endl;

 }     // Cierra la función Imprime

 //FUNCION RECIBE

 void Recibe( int B[] )

 {         // Abre función Recibe

 for ( int i = 0; i < Tamano; i++ )

 {      // Abre for

 cout << "\nIntroduzca el elemento " << i + 1 << " del arreglo: " << endl;

 cin >> B[i];

 }

 }         // Cierra función Recibe

 //FUNCIÓN BURBUJA

   void Burbuja( int C[])

 {                 // Abre función Burbuja

 int temporal;

 for ( int m = 0; m < Tamano - 1; m++ )

 for ( int n = 0; n <= Tamano - 1; n++ )

 {    // Abre for

     

 if ( C[n] > C[n + 1] )

 {    // Abre if

 temporal = C[n];

 C[n] = C[n + 1];

 C[n + 1] = temporal;

 }    // Cierra if

 }         //Cierra for

 }                 // Cierra función Burbuja

Se le denomina Ordenamiento "Burbuja" debido a que los elementos mas grandes van subiendo ("se dirige a lo ultimo") como si fueran burbujas