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.
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.
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]; } }
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; }
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; }
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; }
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; }
