PROGRAMACIÓN

Comencemos con la definición de programación:

La programación informática o programación algorítmica, acortada como programación, es el proceso de diseñar, codificar, depurar y mantener el código fuente de programas computacionales.

Y ahora con la opinión personal basada en mi experiencia en la programación:

La programación estructurada engloba muchos temas y subtemas de los cuales les hablaré un poco en este blog, para empezar, para mi la programación es algo muy complejo que requiere de prática para la excelencia, también eso es lo que la hace muy bonita, con todas sus partes prácticas y teóricas puedo decir que la programación es parte del futuro.

VARIABLES

En programación, una variable está formada por un espacio en el sistema de almacenaje (memoria principal de un ordenador) y un nombre simbólico (un identificador) que está asociado a dicho espacio. Ese espacio contiene una cantidad de información conocida o desconocida, es decir un valor, dicha variable se puede usar para ejecutar funciones y asignar varoles.

VECTOR

En programación se denomina matriz, vector (de una sola dimensión) o formación (en inglés array) a una zona de almacenamiento contiguo que contiene una serie de elementos del mismo tipo, los elementos de la matriz. Desde el punto de vista lógico una matriz se puede ver como un conjunto de elementos ordenados en fila (o filas y columnas si tuviera dos dimensiones).

Los vectores son una forma de almacenar datos que permiten contener una serie de valores del mismo tipo, cada uno de los valores contenidos tiene una posición asociada que se usará para accederlos. Está posición o índice será siempre un número entero positivo.

EJEMPLO:

#include <iostream>
using namespace std;
int vector   [5];
int main(){
vector [0]=1;
vector [1]=2;
vector [2]=5;
vector [3]=10;
vector [4]=50;
for(int dim = 0; dim < 5;dim ++){
cout<<"\nvector["<<dim<<"] = "<<vector [dim];
}

}

MATRIZ

En general, una matriz es un conjunto ordenado en una estructura de filas y columnas. Los elementos de este conjunto pueden ser objetos matemáticos de muy variados tipos, aunque de forma particular, trabajaremos exclusivamente con matrices formadas por números reales.

EJEMPLO:

#include <iostream>
#include <conio.h>
using namespace std;
//matriz de 3x3 y su matriz transpuesta
int main(){
int numeros[3][3];

for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
cout<<"Digite un numero ["<<i<<"]["<<j<<"]: ";
cin>>numeros[i][j];
}
}

cout<<"Matriz normal\n";
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
cout<<numeros[i][j]<<" ";
}
cout<<"\n";

}
cout<<"\nMatriz Transpuesta\n";
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
cout<<numeros[j][i]<<" ";
}
cout<<"\n";

}
getch();
return 0;
}

ARRAY

Un array es un medio de guardar un conjunto de objetos de la misma clase. Se accede a cada elemento individual del array mediante un número entero denominado índice. 0 es el índice del primer elemento y n-1 es el índice del último elemento, siendo n, la dimensión del array. Los arrays son objetos en Java y como tales vamos a ver los pasos que hemos de seguir para usarlos convenientemente:

• Declarar el array
• Crear el array
• Inicializar los elementos del array
• Usar el array

EJEMPLO:

#include <iostream>
using namespace std;
int main(){
char c [4];
c[0]='H';
c[1]='O';
c[2]='L';
c[3]='A';

for(int i = 0; i < 4;i ++){
cout<<c[i];
}
cout<< endl;
cin.get();
return 0;
}

COLAS

Una cola (también llamada fila) es una estructura de datos, caracterizada por ser una secuencia de elementos en la que la operación de inserción push se realiza por un extremo y la operación de extracción pop por el otro. También se le llama estructura FIFO (del inglés First In First Out), debido a que el primer elemento en entrar será también el primero en salir.

Las colas se utilizan en sistemas informáticos, transportes y operaciones de investigación (entre otros), dónde los objetos, personas o eventos son tomados como datos que se almacenan y se guardan mediante colas para su posterior procesamiento. Este tipo de estructura de datos abstracta se implementa en lenguajes orientados a objetos mediante clases, en forma de listas enlazadas.

EJEMPLO:

#include <iostream>
using namespace std;


/*                Estructura de los nodos de la cola      
------------------------------------------------------------------------*/
struct nodo
{
    int nro;
    struct nodo *sgte;
};


/*                      Estructura de la cola      
------------------------------------------------------------------------*/
struct cola
{
    nodo *delante;
    nodo *atras  ;
};


/*                        Encolar elemento      
------------------------------------------------------------------------*/
void encolar( struct cola &q, int valor )
{
     struct nodo *aux = new(struct nodo);
     
     aux->nro = valor;
     aux->sgte = NULL;
     
     if( q.delante == NULL)
         q.delante = aux;   // encola el primero elemento
     else
         (q.atras)->sgte = aux;
         
     q.atras = aux;        // puntero que siempre apunta al ultimo elemento
     
}

/*                        Desencolar elemento      
------------------------------------------------------------------------*/
int desencolar( struct cola &q )
{
     int num ;
     struct nodo *aux ;
     
     aux = q.delante;      // aux apunta al inicio de la cola
     num = aux->nro;
     q.delante = (q.delante)->sgte;
     delete(aux);          // libera memoria a donde apuntaba aux
     
     return num;
}

/*                        Mostrar Cola      
------------------------------------------------------------------------*/
void muestraCola( struct cola q )
{
     struct nodo *aux;
     
     aux = q.delante;
         
     while( aux != NULL )
     {
            cout<<"   "<< aux->nro ;
            aux = aux->sgte;
     }    
}

/*              Eliminar todos los elementos de la Cola      
------------------------------------------------------------------------*/
void vaciaCola( struct cola &q)
{
     struct nodo *aux;
     
     while( q.delante != NULL)
     {
            aux = q.delante;
            q.delante = aux->sgte;
            delete(aux);
     }
     q.delante = NULL;
     q.atras   = NULL;
     
}

/*                        Menu de opciones    
------------------------------------------------------------------------*/
void menu()
{
    cout<<"\n\t IMPLEMENTACION DE COLAS EN C++\n\n";
    cout<<" 1. ENCOLAR                               "<<endl;
    cout<<" 2. DESENCOLAR                            "<<endl;
    cout<<" 3. MOSTRAR COLA                          "<<endl;
    cout<<" 4. VACIAR COLA                           "<<endl;
    cout<<" 5. SALIR                                 "<<endl;

    cout<<"\n INGRESE OPCION: ";
}

/*                        Funcion Principal        
------------------------------------------------------------------------*/
int main()
{
    struct cola q;
   
    q.delante = NULL;
    q.atras   = NULL;
   
   
    int dato;  // numero a encolar
    int op;    // opcion del menu
    int x ;    // numero que devuelve la funcon pop
   
    system("color 0b");

    do
    {
        menu();  cin>> op;

        switch(op)
        {
            case 1:

                 cout<< "\n NUMERO A ENCOLAR: "; cin>> dato;
                 encolar( q, dato );
                 cout<<"\n\n\t\tNumero " << dato << " encolado...\n\n";
            break;


            case 2:

                 x = desencolar( q );
                 cout<<"\n\n\t\tNumero "<< x <<" desencolado...\n\n";
            break;
                 

            case 3:

                 cout << "\n\n MOSTRANDO COLA\n\n";
                 if(q.delante!=NULL) muestraCola( q );
                 else   cout<<"\n\n\tCola vacia...!"<<endl;
            break;


            case 4:

                 vaciaCola( q );
                 cout<<"\n\n\t\tHecho...\n\n";
            break;
           
         }

        cout<<endl<<endl;
        system("pause");  system("cls");

    }while(op!=5);
   
   
    return 0;

}

PILAS

Una pilas es una lista ordenada o estructura de datos que permite almacenar y recuperar datos, el modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, «último en entrar, primero en salir») . Esta estructura se aplica en multitud de supuestos en el área de informática debido a su simplicidad y capacidad de dar respuesta a numerosos procesos.

 EJEMPLO:

#include <iostream>
using namespace std;
 //Menu de apilado de numeros 
struct nodo{
    int nro;
    struct nodo *sgte;
};

typedef nodo *ptrPila;   // creando nodo tipo puntero( tipo de dato )

/*                        Apilar elemento      
------------------------------------------------------------------------*/
void push( ptrPila &p, int valor )
{
     ptrPila aux;
     aux = new(struct nodo);  // apuntamos al nuevo nodo creado
     aux->nro = valor;
     
     aux->sgte = p ;
     p = aux ;
}

/*                Desapilar elemento(devuelve elemento)      
------------------------------------------------------------------------*/
int pop( ptrPila &p )
{
     int num ;
     ptrPila aux;
     
     aux = p ;
     num = aux->nro;   // asignamos el primer vamor de la pila
     
     p = aux->sgte ;
     delete(aux);
     
     return num;
}

/*                     Muestra elementos de la pila      
------------------------------------------------------------------------*/
void mostrar_pila( ptrPila p )
{
     ptrPila aux;
     aux = p;     // apunta al inicio de la lista
     
     while( aux !=NULL )
     {
            cout<<"\t"<< aux->nro <<endl;
            aux = aux->sgte;
     }    
}

/*                Eliminar todos los elementos de la pila      
------------------------------------------------------------------------*/
void destruir_pila( ptrPila &p)
{
     ptrPila aux;
     
     while( p != NULL)
     {
           aux = p;
           p = aux->sgte;
           delete(aux);
     }
}

/*                        Menu de opciones    
------------------------------------------------------------------------*/
void menu()
{
    cout<<"\n\t IMPLEMENTACION DE PILAS EN C++\n\n";
    cout<<" 1. APILAR                                "<<endl;
    cout<<" 2. DESAPILAR                             "<<endl;
    cout<<" 3. MOSTRAR PILA                          "<<endl;
    cout<<" 4. DESTRUIR PILA                         "<<endl;
    cout<<" 5. SALIR                                 "<<endl;

    cout<<"\n INGRESE OPCION: ";
}

/*                        Funcion Principal        
------------------------------------------------------------------------*/
int main()
{
    ptrPila p = NULL;  // creando pila
    int dato;
    int op;
    int x ; // numero que devuelve la funcon pop
   
    system("color 0b");

    do
    {
        menu();  cin>> op;

        switch(op)
        {
            case 1:

                 cout<< "\n NUMERO A APILAR: "; cin>> dato;
                 push( p, dato );
                 cout<<"\n\n\t\tNumero " << dato << " apilado...\n\n";
            break;


            case 2:

                 x = pop( p );
                 cout<<"\n\n\t\tNumero "<< x <<" desapilado...\n\n";
            break;
                 

            case 3:

                 cout << "\n\n MOSTRANDO PILA\n\n";
                 if(p!=NULL)
                    mostrar_pila( p );
                 else
                    cout<<"\n\n\tPila vacia..!"<<endl;
            break;


            case 4:

                 destruir_pila( p );
                 cout<<"\n\n\t\tPila eliminada...\n\n";
            break;
           
         }

        cout<<endl<<endl;
        system("pause");  system("cls");

    }while(op!=5);
   
   
    return 0;
}

LISTAS

Las listas, en términos sencillos son sucesiones desde 0 a más elementos en la cual están en orden secuencial y no indexado,por lo que para acceder al último elemento de la lista hay que recorrer todos los lugares.

EJEMPLO:

#include<iostream>
#include<stdlib.h>
using namespace std;
//*******************************
struct nodo{
    int info;
    struct nodo *sgt;
};
//************************************
main(){
    struct nodo *cabe;
    struct nodo *nuevo;
    struct nodo *aux;
    cabe=NULL;
    int dato;
    int cant, i=1, cont;
    cout<<"Entrar cantidad de datos:";cin>>cant; 
    while(i<=cant){
                       nuevo=(struct nodo *)malloc(sizeof(struct nodo));
                       nuevo->sgt=cabe;
                       cout<<"Inserta dato:";
                       cin>>dato;
                       nuevo->info=dato;
                       cabe=nuevo;
                       i++;
    }

    while(nuevo!=NULL){
        cout<<"\nDATO:"<<nuevo->info;
        nuevo=nuevo->sgt;
    }
   
    system("pause>>null");
}

ARRAY DINÁMICO

Es una cadena o matriz que crece o disminuye dependiendo de los elementos que se declaren o se pida al usuario en todo caso es una cadena de caracteres.

EJEMPLO:

#include<iostream>
#include<conio.h>
#include<stdlib.h>
using namespace std;

void pedirNotas();
void mostrarNotas();
int numCalif,*calif;
int main(){
pedirNotas();
mostrarNotas();

delete[]calif;


getch();
return 0;
}
//\n
void pedirNotas(){
cout<<"Digite el numero de calificaciones: ";
cin>>numCalif;
//reservamos memoria new
//array dinámico
calif = new int[numCalif];

for(int i=0;i<numCalif;i++){
cout<<"Ingrese una nota: ";
cin>>calif[i];
}
}

void mostrarNotas(){
cout<<"\n\nMostrar notas del usuario:\n";
for(int i=0;i<numCalif;i++)
cout<<calif[i]<<endl;
}

PUNTERO

Un puntero es una variable que contiene la dirección de memoria de un dato o de otra variable que contiene al dato en un arreglo. Ésto quiere decir, que el puntero apunta al espacio físico donde está el dato o la variable. Un puntero puede apuntar a un objeto de cualquier tipo, como por ejemplo, a una estructura o una función. Los punteros se pueden utilizar para referencia y manipular estructuras de datos, para referenciar bloques de memoria asignados dinámicamente y para proveer el paso de argumentos por referencias en las llamadas a funciones.

EJEMPLO:

#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
main()                      
/* ejemplo de uso de un puntero */

{

int index,*pt1,*pt2;

index = 39;                      /* cualquier valor numérico */

pt1 = &index;                   /* la dirección de index */

pt2 = pt1;

printf("El valor es  %d %d %d\n",index,*pt1,*pt2);

*pt1 = 13;           /* esto cambia el valor de index */

printf("El valor es %d %d %d\n",index,*pt1,*pt2);

}