ESTRUCTURA DE DATOS

ARREGLO

Un arreglo es un grupo de datos del mismo tipo y dentro de este cada elemento tiene su posición o índice que facilita la identificación para hacer los procesos más eficientes.

#include<conio.h>
#include<stdio.h>
main()
{
 int n,num,i,arr[100],sum=0;
 printf("cantidad de numeros:");
 scanf("%d",&num);
 for(i=0;i<num;i++)
 {
   printf("ingrese valor %d:",i+1);
   scanf("\t\t%d",&arr[i]);
   sum=arr[i]+sum;
 }
 printf("la suma de los numeros... ");
 for(i=0;i<num;i++)
 {
   printf("%d",arr[i]);
 }
 printf("\nes: %d",sum);
 getch();
}

CADENA

Una cadena de caracteres es una secuencia de tipo char esto quiere decir que incluye números, letras y otros signos con la característica que cuando encuentran un valor nulo se termina la sucesión.

#include<conio.h>
#include<stdio.h>
main()
{
  char string[70];
  printf("ingrese los datos de la cadena..\n");
  scanf("%s",&string);
  printf("\n\nla cadena es:%s",string);
  getch();
}

LISTA

Las listas enlazadas son estructuras de datos semejantes a los array salvo que el acceso a un elemento no se hace mediante un indice sino mediante un puntero. En una lista los elementos están dispersos. El enlace entre los elementos se hace mediante un puntero. 

#include <stdio.h>
#include <conio.h>
//Ejemplo de crear un nuevo alumno utilizando listas enlazadas
typedef struct alum
{
         int matricula; 
         char nombre[60]; 
         short sexo; //0=mujer 1=hombre  
         char carrera[3]; 
         struct alum *sige;   
}ALUMNO; 
ALUMNO *Inicio = NULL; 
int main(void)
{
    ALUMNO *p, *q;
    printf("\t\t\tAgregar un Alumno    \n");
p=(ALUMNO *)malloc(sizeof(ALUMNO));//malloc: reservar un espacio en memoria
                printf("\tMatricula: ");
                scanf("%d", &p->matricula);
                printf("\tNombre: "); 
                scanf(" %[^\n]", p->nombre); 
                printf("\tSexo (0=mujer 1=hombre): ");
                scanf("%d", &p->sexo);
                printf("\tCarrera (3 letras ej: ITS)");
                scanf(" %[^\n]", p->carrera);
                p->sige=NULL;
                q=Inicio;
                if(Inicio == NULL)
                {
                     Inicio=p;
                } 
                else
                {
                    while(1)
                    {
                       if(q->sige==NULL) break;
                       q=q->sige;
                    }
                    q->sige=p;
                }
                break;                      
              } 
    q=Inicio;
    while(q!=NULL)
    {
       p=q;
       q=q->sige;
       free(p);
    }
    printf("Fin del programa\n");
    system("pause");
    return 0;
}

COLAS

Una cola es un tipo especial de lista abierta en la que sólo se pueden insertar nodos en uno de los extremos de la lista y sólo se pueden eliminar nodos en el otro. 

#include <stdio.h>
#include <conio.h>
//en el de cola utilizamos el método mas simple según su regla, el primero que entra es el primero que sale
//se introducen los números y hasta que se llenen las casillas que tu quieras ocupar hasta ahí llegara la cola
//y esto va en el orden que se ingresan los datos
main()
{
  int n,i,max,final,dato,cola[10], frente,num;
  printf(" ingresa cantidad maxima de datos en la cola\n :");
  scanf("%d",&num);
  printf(" \n\n");
  max=num;
  for(final=0;final<max;final++)
  {
    printf(" \t\t\t\t");
    scanf("%d",&dato);
    printf("\t\t\t\t----");
    printf("\n");
    cola[final]=dato;}
    if(final==1){
    frente=1;
  }
printf("DESBORDAMIENTO DE COLA (espacio insuficiente)");
getch();
}

PILAS

Una pila es un tipo especial de lista abierta en la que sólo se pueden insertar y eliminar nodos en uno de los extremos de la lista. 

#include <stdio.h>
#include <conio.h>
//en el de pila la regla es que el primero que entra es el ultimo que sale
//por lo que se creo el codigo de ingresar cierta cantidad de numeros e invertirlos.
main()
{
  int num,i,pila[10];
  printf(" ingresa la cantidad de numeros\n :");
  scanf("%d",&num);
  printf(" \n\n");
  for(i=0;i<num;i++)
  {
    printf(" \n\n");
    printf("ingrese dato %d:",i+1);
    printf(" \t\t\t\t----");
    scanf("%d",&pila[i]);
    printf("\n");
  }
  printf("\n\n");
  printf("los datos ingresados acomodados de forma inversa son:");
  printf("\t\t\t\t----");
  for( i=num-1;i>=0;i--)
  {
    printf("\t\t\t\t----");
    printf("%d",pila[i]);
    printf("\n");
  }
  getch();
}

ÁRBOL

Estructura no lineal jerárquica en la que cada elemento tiene un único antecesor y puede tener varios sucesores.

#include <stdio.h>
#include <conio.h>
typedef struct nodoArbol NodoArbol;
typedef NodoArbol*ptrNodoArol;
void insertaNodo( ptrNodoArbol *ptrArbol, int valor );
int main()
{
  int I;
  int NODO;
  ptrNodoArbol prtRaiz=NULL;
  printf("Los numeros ingresados en el árbol son:");
  for (i=1;i<=10;i++) 
  {
    NODO=rand()%15;
    printf("%d", NODO);
    insertaNodo(&ptrRaiz,valor);
    void PreOrden(NODO)
    {
      if (NODO != NULL)
      {
        printf("%d", NODO->info);
        PreOrden(NODO->izq);
        PreOrden(NODO->der);
      }
    }
    void InOrden(NODO)
   {
     if (NODO != NULL)
     {
       InOrden(NODO->izq);
       printf("%d", NODO->info);
       InOrden(NODO->der);
     }
   }
   void PostOrden(NODO)
   {
   if (NODO != NULL)
   {
      PostOrden(NODO->izq);
      PostOrden(NODO->der);
      printf("%d", NODO->info);
   }
  }
  getch();
}

TABLA DE DISPERCION

Es una estructura de datos que asocia llaves o claves con valores. Principal mente esta estructura tiene como objetivo hacer búsquedas mas rápidas teniendo listas guardadas con dichas claves que hacen mas accesible el encontrar un registro. Funciona transformando la clave con una función hash en un hash, un número que identifica la posición (casilla o cubeta) donde la tabla hash localiza el valor deseado.

#include <stdio.h>
#include <conio.h>
#include <iostream>
#include <stdio.h>
#include <iomanip>
struct dato
{
 int n;
 char llave[8];
 char info[8];
 int sr;
}dato;
struct encabezado{
int ns;
}en;
FILE *arch;
int lr, le;
int fh( char *llave )
{
 int n = 0;
 for(int i=0; i<strlen(llave); i++)
 {
  n += int(llave[i]);
 }
 n = n%10 + 1;
 return n;
}
void busqueda()
{
 int pos, n;
 char v_llave[10];
 arch = fopen("datos.txt", "r");
 fflush(stdin);
 cout << " Ingrese clave : "; gets(v_llave);
 n = fh(v_llave);
 pos = (n-1)*lr + le;
 fseek(arch, pos, 0);
 fread(&dato, lr, 1, arch);
 if(strcmp(v_llave, dato.llave)==0)
 {
  cout << " Su contenido es: " << dato.info << endl;
  return;
 }
 else
 {
  cout << " No se encontro la clave." << endl;
 }
 fclose(arch);
}
int main()
{
 int x;
 lr = sizeof(struct dato);
 le = sizeof( struct encabezado);
 do
 {
  en.ns=0;
  cout << "\t\t Tabla de dispercion\n\n";
  cout << "\t 1. Buscar Registro\n";
  cout << "\t 2. Salir\n";
  cout << "\t >> Ingrese opcion: ";
  cin >> x;
  cout<<endl;
  switch(x)
  {
   case 1:
   busqueda(); break;
   case 2:
   exit(0);
  }
  cout <<"\n ";
  system("pause");
  system("cls");
 }while(x>0);
 return 0;
}

BIG DATA

La finalidad de Big Data es la entrega de información con fines predictivos en un tiempo reducido sobre grandes volúmenes de datos.
Big data” son activos de información caracterizados por su alto volumen, velocidad y variedad, que demandan soluciones innovadoras y eficientes de procesado para la mejora del conocimiento y toma de decisiones en las organizaciones.

MAPREDUCE

Mapa-reducir es un paradigma de procesamiento de datos para la condensación de grandes volúmenes de datos útiles en agregados resultados. Para mapas reducir operaciones, MongoDB provee la MapReduce comandos de base de datos.