You are on page 1of 40
Exposiciones de Programación El presente trabajo es una recopilación de los diferentes temas tratados en la

Exposiciones de Programación

El presente trabajo es una recopilación de los diferentes temas tratados en la

catedra de programación, en lo cual nos impartió el conocimiento básico para la estructuración del código en C++.

 

Grupo #1. Instrucciones Break y continúe

La instrucción Break altera el flujo del control. Cuando las instrucciones break se ejecuta en una estructura while, for, do/while se provoca la salida inmediata de la estructura o el escape del ciclo de una manera anticipada al resto de la estructura

La instrucción continúe se ejecuta en una estructura while, for, do/while escapa del resto de las

instrucciones en el cuerpo de esa estructura y procede con la siguiente interacción del ciclo.

    int main()  {  int c=1;  int n;  int
int main()
{
int c=1;
int n;
int r;
int x;
int y;
500"<<endl;
cin>>n;
while (c<=100)
{
r=pow(n,c);

Programa#1.1

//Programa que desarrolla las potencias de un numero ingresado

  • cout<<r<<endl;

  • c=c+1;

  • if(r>500)

  • break;

  • }

  • cout<<"La siguiente potencia es mayor que 500"<<endl;

  • cout<<"ingres 2 numeros para realizar una suma"<<endl;

  • cin>>x;

  • cin>>y;

  • cout<<"La suma es"<<x+y<<endl;

  • return 0;

  • }

#include<iostream.h>

#include<math.h>

cout<<"Ingrese un numero y el programa le

mostrara las potencias menores que

Programa#1.2  // Programa que desarrolla la tabla de  cin>>n; multiplicar  while(c<=10)  #include<iostream.h>
Programa#1.2
// Programa que desarrolla la tabla de
cin>>n;
multiplicar
while(c<=10)
#include<iostream.h>
{
int main()
r=n*c;
{
if(r>=15)
int c=1;
break;
int n;
cout<<n<<" x "<<c<<" = "<<r<<endl;
int r;
c=c+1;
int salida;
}
cout<<"ingrese un numero entero y el
cin>>salida;
programa le desarrollara las tablas de
multiplicar hasta el diez"<<endl;
return 0;
cout<<"y lo interrumpira cuando aparezca un
resultado mayor que 15"<<endl;
}


Grupo #2. Funciones

Una función es un modulo que esta separado del cuerpo principal, está formada por un

conjunto de sentencias que realizan una determinada tarea y que podemos invocar mediante un nombre, [tipo devuelto] nombre función ([tipo parametro1][, tipo

....

]).

parametro2][,

 Grupo #2. Funciones Una función es un modulo que esta separado del cuerpo principal, está
Parámetros  Los parámetros formales son los datos que recibe la función para operar con ellos.
Parámetros
Los parámetros formales son los datos que recibe la función para operar con ellos. Una
función puede recibir cero o más parámetros. Se debe especificar para cada parámetro su
tipo.
Los parámetros formales deben coincidir en número, orden y tipo


Llamado de la función

La instrucción RETURN es quien regresa un y solo un dato a la parte del programa que la este llamando o invocando

 Llamado de la función La instrucción RETURN es quien regresa un y solo un dato
Programa # 2.1  //volumen de un rectangulo;  #include<iostream.h>  #include<math.h>  double volumenrect(double a,double
Programa # 2.1
//volumen de un rectangulo;
#include<iostream.h>
#include<math.h>
double volumenrect(double a,double b,double h){
double v;
v=a*b*h;
return v;}
int main(){
double num1, num2, num3;
cout<<"Volumen de un rectangulo"<<endl;
cout<<"Ingrese a=largo"<<endl;
cin>>num1;
cout<<"Ingrese el b=ancho"<<endl;
cin>>num2;
cout<<"Ingrese el h=altura"<<endl;
cin>>num3;
cout<<"El volumen del rectangulo es:"<<volumenrect(num1,num2,num3)<<endl;
return 0;}
Programa #2.2  //Maximo de un entero.  #include<iostream.h>  int maximo(int x, int y, int
Programa #2.2
//Maximo de un entero.
#include<iostream.h>
int maximo(int x, int y, int z){
int max=x;
if (y>maxz){
max=y;}
if (z>max){
max=z;}
return max;}
int main(){
int ent1,ent2,ent3;
cout<<"entero 1:"; cin>>ent1;
cout<<"entero 2:"; cin>>ent2;
cout<<"entero 3:"; cin>>ent3;
cout<<"El maximo es:"<<maximo(ent1, ent2, ent3);
return 0;}
Grupo#3. Libreria Math.h  Comparación de Cuadros #include<iostream.h> intsumar(){ inta,b,r; cout<<"SUMA DE ENTERO"<<endl; cout<<"ingrese el primer

Grupo#3. Libreria Math.h

  • Comparación de Cuadros

#include<iostream.h> intsumar(){ inta,b,r; cout<<"SUMA DE ENTERO"<<endl; cout<<"ingrese el primer número:"; cin>>a; cout<<"ingrese el segundo número:"; cin>>b;
#include<iostream.h>
intsumar(){
inta,b,r;
cout<<"SUMA DE ENTERO"<<endl;
cout<<"ingrese el primer número:";
cin>>a;
cout<<"ingrese el segundo número:";
cin>>b;
r= a+b;
cout<<"la suma es:"<<r<<endl;
}
Int main()
{
sumar ();
return 0;
}

#include<iostream.h>

int main(){

inta,b,r; cout<<"SUMA DE ENTERO"<<endl; cout<<"ingrese el primer número:"; cin>>a; cout<<"ingrese el segundo número:"; cin>>b; r= a+b; cout<<"la suma es:"<<r<<endl; return 0; }

Grupo#3. Libreria Math.h  Comparación de Cuadros #include<iostream.h> intsumar(){ inta,b,r; cout<<"SUMA DE ENTERO"<<endl; cout<<"ingrese el primer
Librería math.h  math.h es un archivo de cabecera de la biblioteca estándar del lenguaje de

Librería math.h

  • math.h es un archivo de cabecera de la biblioteca estándar del lenguaje de programación C diseñado para operaciones matemáticas básicas. Muchas de sus funciones incluyen el uso de números en coma flotante. C++ también implementa estas funciones por razones de compatibilidad y las declara en la cabecera

Librería math.h  math.h es un archivo de cabecera de la biblioteca estándar del lenguaje de
Programa # 3.1  //Area de un Circulo  #include<iostream.h>  #include <math.h>  double Areacirculo(double
Programa # 3.1
//Area de un Circulo
#include<iostream.h>
#include <math.h>
double Areacirculo(double r)
{
double A;
A=pow(r,2)*3.1415;
return A;
}
int main()
{
double radio;
cout<<"AREA DE UN CIRCULO"<<endl;
cout<<"introduzca el radio:"; cin>>radio;
cout<<"El area es:"<<Areacirculo(radio);
return 0;
}
    

Grupo#4. Archivos de encabezado

Definición: Los archivos de encabezado contienen los prototipos de función para las funciones relacionadas que forman cada porción de la biblioteca.

Los archivos de encabezado también contienen definiciones de varios tipos de

clases y funciones, así como las constantes que necesitan las funciones.

Un archivo de encabezado “instruye” al compilador acerca de como interconectarse con los componentes de la biblioteca y los componentes escritos por el usuario.

Algunos archivos de encabezado, y que son de uso mas frecuente :

<cfloat> (float.h) : Esta cabecera se describe las características de los tipos

flotantes para el sistema específico y Implementación compilador utilizado

<cmath>(math.h) : Es un archivo de cabecera diseñado para operaciones matemáticas básicas.

Archivos de encabezado  <cstdio>(stdio.h): El archivo de cabecera que contiene las definiciones de macros, las
Archivos de encabezado
<cstdio>(stdio.h): El archivo de cabecera que contiene las definiciones de macros,
las constantes, las declaraciones de funciones y la definición de tipos usados por varias
operaciones estándar de entrada y salida. (stdio significa “Standar Input Output header”).
Contiene funciones para poder ingresar datos por teclado y para mostrar por pantalla, además de
algunas otras.
<cstdlib> (stdlib.h): (std-lib: standard library o biblioteca estándar) Contiene prototipos de
función para las conversiones de números a texto, de texto a números, asignación de memoria,
números aleatorios y varias otras funciones utilitarias.
<string>(string.h) : Contiene la definición de macros, constantes, funciones y tipos de utilidad
para trabajar concadenas de caracteres y algunas operaciones de manipulación de memoria
<ctime>(time.h) : Contiene funciones para manipular y formatear la fecha y hora del sistema.
<ctype>(ctype.h): Ésta librería se encarga de todo lo relacionado a modificar y operar con
caracteres.
<cassert>(assert.h): Ésta librería es muy útil a la hora de depuración de programas y previsión
de comportamientos inesperados.
Tipos de archivos para librerías más comunes. función tipo librería sintaxis información cos(d) double math.h double
Tipos de archivos para librerías más comunes.
función
tipo
librería
sintaxis
información
cos(d)
double
math.h
double
Devuelve el coseno de d
cos(double d);
complex
cos(complex d);
sin(d)
double
double
math.h
Devuelve el seno de d
sin(doublé d);
double
tan(d)
double
math.h
Devuelve la tangente de d
tan(double d);
double
sqrt(d)
double
math.h
Devuelve la raiz cuadrada de d
sqrt(double d);
double
pow(d1, d2)
double
math.h
pow(double d1,
Devuelve d1 elevado a la potencia d2
double d2);
log10(d)
double
math.h
log10(double double d); Devuelve el logaritmno (en base 10) de d
double
log(d)
double
math.h
Devuelve el logaritmo natural de d
log(double d);
abs(i)
int
stdlib.h
int abs(int i);
Devuelve el valor absoluto de i
int tolower(int
tolower
int
ctype.h o stdlib.h
Convierte una letra a minuscula
c);
int toupper(int
toupper
int
ctype.h o stdlib.h
Convierte una letra a mayuscula
c);
int
Lee un caracter desde el dispostivo de entrada
getchar( )
int
stdio.h
getchar(void);
estandar
printf( ... ) int stdio.h int printf(const char *formato[,argume Escribe datos en dispositivo de salida estandar.
printf(
...
)
int
stdio.h
int printf(const
char
*formato[,argume
Escribe datos en
dispositivo de
salida estandar.
nto,
...
]);
%c
%d
Caracter
Entero Decimal
Real (double o float),
%e
notacion cientifica.
%f
%s
%x
Coma flotante
Cadena de caracteres
Hexadecimal sin signo
scanf(
...
)
int
stdio.h
int scanf(const char
*formato
{,direccion, ]); ...
Lee datos en
dispositivo de
entrada estandar
%c
%d
%x
%i
%f
%o
%p
Caracter
Enetero Decimal
Hexadecimal
Entero Decimal
Numero Real
Octal
Puntero
%s
Cadena
isalnum(c) int ctype.h int isalnum(int c); Determina si el argumento es alfanumerico. Devuelve un valor disitinto
isalnum(c)
int
ctype.h
int isalnum(int c);
Determina si el argumento
es alfanumerico. Devuelve
un valor disitinto de cero si
es cierto; en otro caso
devuelve 0
time(p)
long int
time.h
time_t time(time_t *h);
Devuelve el numero de
segundos transcurridos despues
de un tiempo base designado
struct tm *gmtime(time_t *)
Recibe un puntero a una variable
de tiempo (time_t*) y devuelve
su conversión como fecha/hora
UTC a struct tm a través de un
puntero.
time_t mktime(struct_tm *)
Inversamente
a gmtime() y localtime(),l recibe un
puntero a struct tm (struct tm*) y
devuelve su conversión al tipo time t.
struct tm
*localtime(time_t *)
Similar funcionalidad a gmtime(),
pero devuelve la conversión
time_t time(time_t *)
como fecha/hora LOCAL.
Devuelve la fecha/hora (time_t) actual
o -1 en caso de no ser posible. Si el
argumento que se le pasa no es
NULL, también asigna la fecha/hora
actual a dicho argumento.
int tm_hour
hora (0 - 23)
int tm_mday
día del mes (1 - 31)
Horario de
int tm_isdst
int tm_min
minutos (0 - 59)
verano
enabled/disabled
int tm_sec
segundos (0 - 60)
int tm_mon
mes (0 - 11, 0 = Enero)
int tm_wday
día de la semana (0 - 6, 0 =
domingo)
int tm_year
año desde 1900
Programa # 4.1 //Resolviendo una cuadratica printf("\n\nEl resultado de la ecuacion es %f\n\n",S); #include <stdio.h> }else{
Programa # 4.1
//Resolviendo una cuadratica
printf("\n\nEl resultado de la ecuacion es %f\n\n",S);
#include <stdio.h>
}else{
#include <math.h>
sol1=(-B+sqrt(D))/(2*A);
#include <conio.h>
sol2=(-B-sqrt(D))/(2*A);
#include <time.h>
printf("\n\nLos resultados de la ecuacion son %f y
%f\n\n",sol1,sol2);
}
int main( )
printf("\nGracias por utilizar este programa\n\n");
{
time_t x;
float A, B, C, D, S, sol1, sol2;
struct tm *hora;
printf("Bienvenido, resolveremos su ecuación de segundo
grado.\n\n");
struct tm *fecha;
printf("\nPo favor ingrese en coeficiente A: ");
time(&x);
scanf("%f",&A);
hora = localtime(&x);
printf("\nAhora, escriba el coeficiente B: ");
fecha = localtime(&x);
scanf("%f",&B);
printf("%d-%d-%d\n", fecha->tm_mday, fecha->tm_mon+1,
fecha->tm_year+1900);
printf("\nPor ultimo, inserte el coeficiente C: ");
printf("%d:%d:%d", hora->tm_hour, hora->tm_min, hora-
scanf("%f",&C);
>tm_sec);
D=B*B-4*A*C;
getch();
if(D<0){
return 0;
printf("\n\nDisculpe, no tiene solucion real\n\n");
}
}else if(D==0){
S=-B/2*A;
Programa # 4.2 //Uso de assert.h #include <iostream.h> #include <assert.h> #include <conio.h> int main() { double
Programa # 4.2
//Uso de assert.h
#include <iostream.h>
#include <assert.h>
#include <conio.h>
int main() {
double a, b,divi;
cout<<"Ingrese el numerador:\n";
cin>>a;
cout<<"Ingrese el denominador:\n";
cin>>b;
assert(b!=0);
divi=a/b;
cout<<"la divicion es: " <<a<<"\\"<<b<<"= "<<divi;
getch();
return 0;
}
Programa #4.3 //Conteo de vocales #include <stdio.h> #include <conio.h> void main(){ }else if(c=='u'){ u++; }else if(c=='-'){
Programa #4.3
//Conteo de vocales
#include <stdio.h>
#include <conio.h>
void main(){
}else if(c=='u'){
u++;
}else if(c=='-'){
contador=1;
int contador=0,a=0,e=0,i=0,o=0,u=0;
}else{
char c;
printf("Introduzca caracteres hasta pulsar el guion:\n\n");
contador=0;
while(contador==0){
c=getche();
}
}
printf("\n\n\t\t\tRecuento de vocales\n");
if(c=='a'){
printf("\nLa a se ha repetido %d veces \n",a);
a++;
}else if(c=='e'){
e++;
}else if(c=='i'){
i++;
}else if(c=='o'){
o++;
printf("\nLa e se ha repetido %d veces \n",e);
printf("\nLa i se ha repetido %d veces \n",i);
printf("\nLa o se ha repetido %d veces \n",o);
printf("\nLa u se ha repetido %d veces \n",u);
printf("\n\nGracias por utilizar este programa.\n\n");
getch();
Grupo #5. Printf () y Scanf ()  Printf : Salida de datos con formato. Escribe
Grupo #5. Printf () y Scanf ()
Printf : Salida de datos con formato. Escribe una serie de caracteres en la salida estándar
(pantalla).
Formato de Printf: Cadena de caracteres, entre comillas dobles, que especifica como va a
ser la salida.
Argumento de Printf : Indica las variables a escribir.
Scanf: Entrada de datos con formato. Lee datos de la entrada estándar (teclado), los
interpreta y los almacena en los argumentos.
Formato de Scanf: Cadena de caracteres, entre comillas dobles, que especifica como van
a ser introducidos los datos.
Argumento de Scanf : Indica las direcciones de variables que almacenaran los datos (&).
Las funciones printf y scanf, la utilizaremos para mostrar e ingresar información
respectivamente. La función scanf es el equivalente e inverso de la función printf, de
hecho también se incluye en la librería estándar de C (stdio.h). Funciona exactamente
igual que printf, pero al inverso. Es decir en vez de "devolver" datos, "recibirá".
Ejemplo de Printf : printf("Hola Mundo"); printf("Función printf, para mostrar información en pantalla"); Ejemplo de Scanf:

Ejemplo de Printf :

printf("Hola Mundo"); printf("Función printf, para mostrar información en pantalla");

Ejemplo de Scanf:

scanf("%d",&numero Entero); scanf("%f",&numeroFlotante); scanf("%c",&letra);

Para %d, se debe asignar una variable del tipo int Para %f, se debe asignar una variable del tipo float Para %c, se debe asignar una variable del tipo char.

Programa #5.1  //puntos en el plano cartesiano  D= sqrt(pow(x2-x1,2)+pow(y2-y1,2));  #include<stdio.h>  printf("La distancia
Programa #5.1
//puntos en el plano cartesiano
D= sqrt(pow(x2-x1,2)+pow(y2-y1,2));
#include<stdio.h>
printf("La distancia entre los dos puntos
de la recta son: %f\n",D);
#include<math.h>
x3=(x1+x2)/2;
int main ()
y3=(y1+y2)/2;
{
int x1, x2, y1, y2;
printf("La coordenada del punto medio en
el eje x es: %f\n",x3);
double M,Ix, Iy, D, x3, y3;
printf("Ingrese los puntos de la recta:\n");
printf("La coordenada del punto medio en
el eje y es: %f\n",y3);
scanf("%d %d %d %d",
return 0;
&x1,&x2,&y1,&y2);
}
M=(y2-y1)/(x2-x1);
printf("\nLa pendiente es igual a: %f\n",
M);
Iy= (y1-x1)*M;
printf("El intercepto en y es: %f\n", Iy);
Ix= x1-(y1/M);
printf("El intercepto en x es: %f\n", Ix);
Programa #5.2  //Programa multiplicador  #include <stdio.h>  main ()  {  int a,
Programa #5.2
//Programa multiplicador
#include <stdio.h>
main ()
{
int a, b, producto;
printf ("\nTeclee dos números enteros: ");
scanf ("%d %d", &a, &b);
producto = multiplica (a, b);
printf ("\nEl resultado es %d", producto);
}
/* Definición de la función multiplica() */
multiplica (int x, int y)
{
return (x * y);
}
Grupo #6. Recursividad  La recursividad consiste en realizar una definición de un concepto en términos
Grupo #6. Recursividad
La recursividad consiste en realizar una definición de un concepto en términos del propio concepto que
se está definiendo.
Una función recursiva es una función que se llama a si misma, ya sea de manera directa, o indirecta(a
través de otra función ).
Los métodos para solucionar problemas recursivos tienen un conjunto de elementos en común, se llama
a una función recursiva para resolver un problema.
Solución de problemas recursivos
División sucesiva del problema original en uno o varios más pequeños, del mismo tipo que el inicial.
Se van resolviendo estos problemas más sencillos.
Con las soluciones de éstos se construyen las soluciones de los problemas más complejos.
Características de los problemas que pueden ser resueltos de manera recursiva  Los problemas pueden ser
Características de los problemas que pueden ser
resueltos de manera recursiva
Los problemas pueden ser redefinidos en términos de uno o más sub problemas, idénticos
en naturaleza al problema original, pero de alguna forma menores en tamaño.
Uno o más sub problemas tienen solución directa o conocida, no recursiva.
Aplicando la redefinición del problema en términos de problemas más pequeños, dicho
problema se reduce sucesivamente a los sub problemas cuyas soluciones se conocen
directamente.
La solución a los problemas más simples se utiliza para construir la solución al problema
inicial.
El Caso Base  La llamada recursiva, que expresa el problema original en términos de otro

El Caso Base

  • La llamada recursiva, que expresa el problema original en términos de otro más pequeño, y el valor para el cual se conoce una solución no recursiva.

  • Esto es lo que se conoce como caso base: una instancia del problema cuya solución no requiere de llamadas recursivas.

  • Es la condición de finalización de la función recursiva. Sin el caso base la rutina recursiva se llamaría indefinidamente y no finalizaría nunca.

  • Es el cimiento sobre el cual se construirá la solución completa al problema.

Programa #6.1 //Programa factorial scanf("%i",&num); //Pedir variable num #include<stdio.h> #include<conio.h> printf("\tEl resultado es: %i\n", factorial(num)); //Llama
Programa #6.1
//Programa factorial
scanf("%i",&num); //Pedir variable num
#include<stdio.h>
#include<conio.h>
printf("\tEl resultado es: %i\n",
factorial(num)); //Llama la funcion e
imprime resultado
int factorial(int n)
getch ();
{
return 0;
if(n<2)//Caso Base
}
return 1;
else
return n * factorial(n-1); //paso
recursivo
}
int main()
{
int num=0;
printf("::CALCULAR FACTORIAL::\n");
printf("Introduce un numero: ");
Programa #6.2  // Este programa muestra en la pantalla cierto  { numero de “Garra”
Programa #6.2
// Este programa muestra en la pantalla cierto
{
numero de “Garra” dependiendo del numero
if(n == 1) //Caso Base
que decidamos darle a “Porra” e ira bajando
ese numero hasta el caso base que es n==1 y
{
entonces imprimirá en la pantalla la palabra “
Catracha”
cout << " Catracha !!\n";
}
#include<iostream.h>
else
#include<conio.h>
{
void porra(int n);
cout << " Garra
";
int main()
porra(n - 1);
{
}
porra(3);
getch ();
return 0;
}
}
void porra(int n)
Grupo #7. Funciones Inline  Inline es utilizada en C++ y se aplica a una función.
Grupo #7. Funciones Inline
Inline es utilizada en C++ y se aplica a una función. Esta indica al compilador que
cada llamado a la función inline deberá ser reemplazado por el cuerpo de esta
función. En la práctica la función inline es utilizada solo cuando las funciones son
pequeñas para evitar generar un ejecutable de tamaño considerable.
La función inline se puede usar en cualquier biblioteca de C++.
Const
Cuando una función miembro no deba modificar el valor de ningún dato de la clase,
podemos y debemos declararla como constante Una variable declarada const no se
puede cambiar, es decir, es una constante. No obstante, la palabra const sólo se tiene
en cuenta durante el tiempo de compilación. El compilador emite un error cuando
encuentra una instrucción que asignar un valor a una constante.
Programa #7.1  //Volumen de un Cubo  cout<<"el volumen del cubo es: "<<cubo(valorlado)<<endl;  #include<iostream.h>
Programa #7.1
//Volumen de un Cubo
cout<<"el volumen del cubo es:
"<<cubo(valorlado)<<endl;
#include<iostream.h>
getch();
#include<conio.h>
return 0;
inline double cubo(const double lado)
}
{
return lado*lado*lado;
}
int main()
{
cout<<"introduzca la longitud del lado de
su cubo:";
double valorlado;
cin>>valorlado;
Programa #7.2  // Programa del Factorial  cout<<"el valor de n debe ser positivo"<<endl<<endl; 
Programa #7.2
// Programa del Factorial
cout<<"el valor de n debe ser
positivo"<<endl<<endl;
include<iostream.h>
#include<conio.h>
cout<<"******************************
int i; int factorial=1;
*"<<endl;
inline long int factoriales (const long int fac) {
cout<<"Ingrese un nuevo valor de n
"<<endl;
for (i=1; i<=fac; i++)
{
cin>>n; }
factorial=i*factorial;}
if (n==0) { cout<<"el factorial es:1"<<endl;}
return factorial ; }
int main()
{
else { cout<<"el valor del factorial
es:"<<factoriales(n)<<endl;}
long int n;
getch () ;
cout<<"ingrese el valor de n"<<endl;
return 0;
}
cin>>n;
while (n<0)
{
Grupo #8. Arreglos  Un arreglos es aquel almacenan una especie de lista de muchos elementos
Grupo #8. Arreglos
Un arreglos es aquel almacenan una especie de lista de muchos elementos de un mismo tipo de
dato.
Se considera un buen principio de programación declarar la cantidad de elementos de nuestro
arreglo en una variable constante; como se muestra en el siguiente ejemplo.
const int tam=10;
int lista [tam];
Los arreglos pueden ser: Unidimensional, Bidimensional, Multidimensional
Arreglo unidimensional: es un tipo de datos estructurados que está formado de una
colección finita y ordenada de datos del mismo tipo. Es la estructura natural para
modelar listas de elementos iguales.
Están formados por un conjunto de elementos de un mismo tipo de datos que se
almacenan bajo un mismo nombre, y se diferencian por la posición que tiene cada
elemento dentro del arreglo de datos.
[5,6,7,4,9,3]
int lista []
 Arreglo bidimensional: es la representación de tablas de valores o matrices, consistiendo de información arreglada
Arreglo bidimensional: es la representación de tablas de valores o matrices, consistiendo de
información arreglada en reglones y columnas.
[5,6,7,4] int matriz[][]
Arreglo multidimensional: Es un tipo de dato estructurado, que está compuesto por dimensiones.
El termino dimensión representa el numero de índices utilizados para referirse a un elemento en
particular dentro del arreglo.
<2,2,2> int vector []
Subíndices en un arreglo: Los subíndices nos permiten ver la posición de un elemento dentro de
un arreglo.
C=[1,3,4,2,6,7,8] el elemento que tiene subíndice 0 o que está en la posición 0 del arreglo es 1;
C[0]=1, C[5]=7.
Declarar un arreglo es así como declaramos las variables de tipo entero (int)
1. Tipo de Dato (Almacena el arreglo si es entero)
2. Nombre o identificador
3. Cantidad de Elementos (se colocan entre corchetes)
Programa #8.1  //Inicializacion de un arreglo  #include<iostream.h>  #include<iomanip.h>  int main() { 

Programa #8.1

  • //Inicializacion de un arreglo

  • #include<iostream.h>

  • #include<iomanip.h>

  • int main() {

  • int n[10];

  • for (int i=0; i<10; i++)

  • n[i]=0;

  • cout<<" elemento"<< setw(15)<<"valor"<<endl;

  • for (int j=0; j<10; j++)

  • cout<<setw(7)<<j<< setw(15)<<n[j]<<endl;

  • return 0;

  • }

Programa #8.2  //AREGLO EN DOS DIMENSIONES  for (int y=0; y<2;y++) {  // suma
Programa #8.2
//AREGLO EN DOS DIMENSIONES
for (int y=0; y<2;y++) {
// suma de matrices
cout<<"b"<<(x+1)<<(y+1)<<"=";
# include<iostream.h>
cin>>matrizB[x][y];
# include<iomanip.h>
}
int main(){
cout<<endl;
int matrizA[2][2],matrizB[2][2];
for (int p=0; p<2;p++) {
cout<<"ingrese los elementos de la matriz A \n";
for (int q=0; q<2;q++)
for (int i=0; i<2;i++)
cout<<setw(10)<<matrizB[p][q];
for (int j=0; j<2;j++) {
cout<<endl;
cout<<"a"<<(i+1)<<(j+1)<<"=";
}
cin>>matrizA[i][j];
cout<<endl;
}
cout<<"la suma de matrices es:\n\n";
cout<<endl;
for(int a=0;a<2;a++) {
for (int m=0; m<2;m++) {
for(int b=0;b<2;b++)
for (int n=0; n<2;n++)
cout<<setw(5)<<matrizA[a][b]+matrizB[a][b];
cout<<setw(10)<<matrizA[m][n];
cout<<endl;
cout<<endl;
}
}
return 0;
cout<<endl;
}
cout<<"ingrese los elementos de la matriz B \n";
for (int x=0; x<2;x++)
Grupo #9. Ordenamiento de Arreglos  Clave: La parte de un registro por la cual se
Grupo #9. Ordenamiento de Arreglos
Clave: La parte de un registro por la cual se ordena la lista. Por ejemplo, una lista de
registros con campos nombre, dirección y teléfono se puede ordenar alfabéticamente
de acuerdo a la clave nombre. En este caso los campos dirección y teléfono no se
toman en cuenta en el ordenamiento.
Criterio de ordenamiento (o de comparación): EL criterio que utilizamos para asignar
valores a los registros con base en una o más claves. De esta manera decidimos si
un registro es mayor o menor que otro.
Registro:
Un grupo
de
datos que forman
la
lista.
Pueden ser datos
atómicos
(enteros, caracteres, reales,
etc.) o grupos
de
ellos,
que
en C equivalen
a
las
estructuras.
La Ordenación de burbuja (Bubble Sort en inglés) es un sencillo algoritmo de
ordenamiento. Funciona revisando cada elemento de la lista que va a ser ordenada
con el siguiente, intercambiándolos de posición si están en el orden equivocado. Es
necesario revisar varias veces toda la lista hasta que no se necesiten más
intercambios, lo cual significa que la lista está ordenada.
También es conocido como el método del intercambio directo. Dado que solo
usa comparaciones para operar elementos, se lo considera un algoritmo de
comparación, siendo el más sencillo de implementar
 La idea básica de este algoritmo consiste en comparar pares de elementos adyacentes e intercambiarlos
La idea básica de este algoritmo consiste en comparar pares de elementos adyacentes e
intercambiarlos entre sí hasta que todos se encuentren ordenados. Se realizan (n-1)
pasadas, transportando en cada de las mismas el menor o mayor elemento (según sea el
caso) a su posición ideal.
Vamos a ordenar la lista en forma ascendiente, es decir, de menor a mayor. Obviamente
es esencialmente lo mismo que hacerlo en forma inversa.
La forma de intercambiar los elementos depende de la estructura de datos: si es un
arreglo (dinámico o estático) es necesario guardar una copia del primer elemento,
asignarle el segundo al primero y el temporal al segundo. La variable temporal es
necesaria, porque de lo contrario se perdería uno de los elementos. Si la estructura es una
lista dinámica el procedimiento es parecido, pero se utilizan las direcciones de los
elementos. En el pseudocódigo se utilizará el primer método.
La lista se manejará como un arreglo de C: si tiene TAM elementos, el primer elemento es
lista[0] y el último es lista[TAM-1]. Esto será así para todo el pseudocódigo presentado en
este artículo
  2.  3.  4.  5.  6. 4 - 3 - 5
2.
3.
4.
5.
6.
4
- 3 - 5
3
3
3
3
- 2 - 1

Estructura con un ciclo For

1. for (i=1; i<TAM; i++)

for

j=0 ; j<TAM - 1; j++)

if (lista[j] > lista[j+1])

temp = lista[j];

lista[j] = lista[j+1];

lista[j+1] = temp

Esta es nuestra lista:

- 2 - 1

Tenemos 5 elementos. Es decir, TAM toma el valor 5. Comenzamos comparando el primero con el segundo elemento. 4 es mayor que 3, así que intercambiamos. Ahora tenemos:

- 4 - 5 - 2 - 1

Ahora comparamos el segundo con el tercero: 4 es menor que 5, así que no hacemos nada.

Continuamos con el tercero y el cuarto: 5 es mayor que 2. Intercambiamos y obtenemos:

- 4 - 2 - 5 - 1

Comparamos el cuarto y el quinto: 5 es mayor que 1. Intercambiamos nuevamente:

- 4 - 2 - 1 - 5 Repitiendo este proceso vamos obteniendo los siguientes resultados:

3 - 4 5 ; 1

- 2 - 3 - 4 - 5

- 4 5 ; 2 - 1 -

Programa #9.1  #include <iostream>  for(int j=0; j < tamanoarreglo - 1; j++ ) 
Programa #9.1
#include <iostream>
for(int j=0; j < tamanoarreglo - 1; j++ )
#include <iomanip>
if (a[j] > a[j + 1 ])
using std:: setw;
{
int main ()
mantiene = a[j];
{
a[j] = a[j + 1 ];
const int tamanoarreglo = 10;
a[j + 1 ] = mantiene;
int
}
a[tamanoarreglo]={2,7,8,3,78,98,21,34,89,9
};
cout<<"\n elementos de datos en orden
ascendente\n";
int mantiene;
for (int k = 0; k< tamanoarreglo; k++)
cout<<"elementos de datos en el orden
cout<<setw(4)<<a[k];
original";
cout<<endl;
getchar();
getchar();
for(int i = 0; i< tamanoarreglo; i++)
return 0;
cout<<setw(4)<<a[i];
}
for(int pasada =0; pasada <
tamanoarreglo - 1; pasada++ )