viernes, 3 de diciembre de 2010

Gráficos en c

Las funciones que llevan a cabo los gráficos en c es permitir generar dibujos y presentaciones de los programas en general (es decir, la forma en que lucen al usuario). Las funciones de salida dependen del adaptador y del monitor que se esté utilizando, el controlador seleccionado se carga desde el disco durante la inicialización de la biblioteca de gráficos llamada:

Initgraph() y se necesita incluir la librería #include <graphics.h>

Para activar el modo grafico un programa;
Este debe empezar llamando la función Initgraph(), que inicializa el paquete de gráficos BGL.
La escritura en modo grafico se puede llevar acabo con las funciones especiales para ello:

Void far outtext(char far*cadena de texto);

Esta función muestra una pantalla en modo grafico una cadena de texto en la posición actual (en los modos gráficos no existe un cursor visible, pero la posición actual  se conserva como si existiera uno invisible).

Void far outtextxy( int x, int y , charfar*cad)

Escribe un texto en la posición determinado por las coordenadas x, y en la ventana grafica.
Para cambiar el tipo de letras se usa la función;
Void far settextstyle(int fuente, int dirección, int tamaño_car);

Establece la fuente active que usaran las funciones de escritura de texto grafico también se establece  la dirección y el tamaño de los caracteres.

Blibliografia:

Codigo fuente de un grafico que reproduce unos circulos de colores de diferentes tamaños.
#include"conio.h"
#include"stdlib.h"
#include"stdio.h"
#include"graphics.h"
using namespace std;
int main()
{
      int pantalla=DETECT,modo,error;
      printf("presione una tecla para continuar con el grafo");
      _getch();
      initgraph(&pantalla,&modo,"");
      error=graphresult();
      if(error!=grOk)
      {
            printf("error al iniciar el modo grafico!");
            _getch();
            exit(0);
      }
      int y,x,radio,color;
      rand();
      while(!kbhit())
{
            x=rand()%(600);
            y=rand()%(450);
            radio=rand()%(90);
            color=rand()%(16);
            setcolor(color);
            setfillstyle(1,color);
            fillellipse(x,y,radio,radio);
            delay(100);
}
}


Codigo fuente de un grafico que forma una casa.

#include "stdio.h"
#include "stdlib.h"
#include "conio.h"
#include "graphics.h"

int main()
{
      int iGraphicsDriver = DETECT, iGraphicsMode, iError, x, y;
      system("cls");
      initgraph(&iGraphicsDriver, &iGraphicsMode, "");
      iError = graphresult();
      if(iError != grOk)
      {
            printf("\n\tERROR AL INICAR EL MODO GRAFICO %c", 7);
            _getch();
            exit(EXIT_SUCCESS);
      }    
     
      setcolor(BLUE);
      line(90,195,240,90);
      line(240,90,390,195);
      setcolor(YELLOW);
      rectangle(90,195,390,420);
      setcolor(RED);
      rectangle(120,240,165,285);
      rectangle(285,240,330,285);
      setcolor(GREEN);
      rectangle(210,345,270,420);
      setcolor(WHITE);
      circle(240,150,30);
      circle(255,390,5);
      //Casa();

      _getch();
      return 0;
}
Este programa realiza el grafico de una casa donde se realiza a base de lineas donde se le pasa como parametros los valores de las coordenadas de acuerdo como se quiera el tamaño de la imagen de cada punto esto se hace con las lineas, rectangulo y el circulo.

viernes, 19 de noviembre de 2010

ESTRUCTURAS EN C

Una Estructura es:

 una colección de variables simples, que pueden contener diferentes tipos de datos. Es un tipo de dato definido por el usuario. Son también conocidas como Registros. Ayudan a organizar y manejar datos complicados en programas debido a que agrupan diferentes tipos de datos a las que se les trata como una sola unidad en lugar de ser vistas como unidades separadas.

La Declaración de estructuras:
 en programas C es un nuevo tipo de datos denominado tipo Estructura y declarar una variable de este tipo.

En la definición del tipo de estructura, se especifican los elementos que la componen así como sus tipos. Cada elemento es llamado miembro (similar a un campo de un registro).

programa de un estructura (codigi fuente):

#include<iostream>
#include<conio.h>
using namespace std;
struct alumno                                        //aqui se declara la estructura llamada alumno
{
char nombre[15];                                  //se declaran las variables de la estructura
int matricula;
int cal1,cal2,cal3,prom;

void datos()                                       //dentro de la estrucctura se hace una funcion donde se van a pedir los datos del alumno
{
cout<<"escribe la matricula"<<endl;
cin>>matricula;
cout<<"escribe el nombre"<<endl;
cin>>nombre;
cout<<"escribe la calificacion 1"<<endl;
cin>>cal1;
cout<<"escribe la calificacion 2"<<endl;
cin>>cal2;
cout<<"escribe la calificacion 3"<<endl;
cin>>cal3;
prom=(cal1+cal2+cal3)/3;

}
void imprimir()                                    //se hace otra funcion donde se van a imprimir los datos del alumno
{
cout<<"la matricula es   "<< matricula<<endl;
cout<<"el nombre  es  "<< nombre<<endl;
cout<<"el promedio es "<< prom<<endl;

}a;
 int main()                                    //dentro del main se van a instanciar los datos y la impresion que se hizo en la estructura
{
a.datos();
a.imprimir();
getch();
return 0;
}

Asignación dinámica de memoria


Asignación dinámica de memoria: new y delete

En C la asignación dinámica de memoria se manipula con las funciones malloc() y free(). En C++ se define un método de hacer asignación dinámica utilizando los operadores new y delete.
El operador new está disponible directamente en C++, de modo que no se necesita utilizar ningún archivo de cabecera; new se puede utilizar con dos formatos:new tipo // asigna un único elemento
new tipo[num_eltos] // signa un array
Si la cantidad de memoria solicitada no está disponible, el operador new proporciona el valor 0. El operador delete libera la memoria signada con new.delete variable
delete [n] variable
new es superior a malloc por tres razones:
1.-
new conoce cuánta memoria se asigna a cada tipo de variable.
2.- 
malloc() debe indicar cuánta memoria asignar.
3.-
new hace que se llame a un constructor para el objeto asignado y malloc no puede.
delete produce una llamada al destructor en este orden:
1. Se llama al destructor
2. Se libera memoria
delete es más seguro que free() ya que protege de intentar liberar memoria apuntada por un puntero nulo.
Bibliografía de la investigación:
código fuente del programa:
#include<iostream.h>
#include<conio.h>
int main(void)
{
clrscr();
int *vector, tm;
int indice=0,i;
cout<<"Ingrese el numero de elementos:";
cin>>tm;
vector = new int[tm];//asignacion dinamica de memoria.
for(indice=0;indice<tm;indice++)
{
cout<<"Introduzca un vector["<<indice + 1<<"]:";
cin>>vector[indice];                                                                      
}
for(i=0;i<tm;++i)
{
cout<<vector[i]<<endl;
}
return 0;
}

 
En este programa se le pide al usuario que inserte el número de elementos que va a  tener su vector  y con el oprador NEW sele asigna el valor a cada elemento del vector, después con un ciclo for se imprime en pantalla el valor que se le asigno al elemento.

jueves, 28 de octubre de 2010

ORDENACIÓN POR INSERCIÓN

Código fuente del programa

#include <iostream.h>
#include <conio.h>
#include <stdio.h>
#include<string.h>

void main()
{
clrscr();
char nombre[5][30];
int cal[3][5];
int prom[5];
int temp;
char nombretemp[20];
int suma;
int i,j,k;
char t;
int inter;
for(i=0;i<5;i++){
 suma=0;
cout<<"Introduce el nombre"<<endl;
cin>>nombre[i];
for(j=0;j<3;j++){
cout<<"calificacion"<<endl;
cin>>cal[i][j];
suma=suma+cal[i][j];
}
 prom[i]=suma/3;
cout<<nombre[i]<<endl;
cout<<"promedio :"<<prom[i]<<endl;
}
//ordenacion po inseccion
for(i=1;i<5;i++){
t=prom[i];
 for(k=i-1;(k>=0)&&(t<prom[k]);k--)
{
prom[k+1]=prom[k];
prom[k-1]=t;
strcpy(nombretemp,nombre[k]);
strcpy(nombre[k],nombre[k+1]);
strcpy(nombre[k+1],nombretemp);
}
}
cout << "Los promedios ordenados de manera ascendente son"<<endl;
  for(i=0;i<5;i++){
  cout<<prom[i]<<"  "<<nombre[i]<<endl;
}
cout << "Las promedios ordenados de manera descendente son"<<endl;
  for(i=4;i>=0;i--){
  cout<<prom[i]<<"  "<<nombre[i]<<endl;
}
getch();
}


En este programa se captura cinco nombres  y tres calificaciones de cada uno de ellos, así mismo se determina su promedio y por medio del método de ordenación por inserción se ordenan de manera ascendente y descendente   con su respectivo nombre.
Este método inicialmente ordena los dos primeros miembros del array, después el algoritmo inserta el tercer miembro en su posición correcta respecto de los  dos primeros miembros del array  y así sucesivamente hasta que todos los miembros quedan ordenados  correctamente.

ORDENACIÒN POR SELECCIÒN

CODIGO FUENTE DEL PROGRAMA

#include <iostream.h>
#include <conio.h>
#include <stdio.h>
#include <string.h>

void main()
{
clrscr();
char nombre[5][30];
int cal[3][5];
int prom[5];
int temp;
char nombretemp[20];
int suma;
int i,j,k;
char t;
int inter;
for(i=0;i<5;i++){
 suma=0;
cout<<"Introduce el nombre"<<endl;
cin>>nombre[i];
for(j=0;j<3;j++){
cout<<"calificacion"<<endl;
cin>>cal[i][j];
suma=suma+cal[i][j];
}
 prom[i]=suma/3;
cout<<nombre[i]<<endl;
cout<<"promedio :"<<prom[i]<<endl;
}
//metodo de seleccion
for(i=0;i<5-1;i++){
k=0;
temp=prom[i];
t=prom[i];
 for(k=i+1;k<5;k++){
if(prom[k]<t)
{
temp=prom[k];
t=prom[k];
t=temp;
inter=1;
strcpy(nombretemp,nombre[k]);
strcpy(nombre[k],nombre[k+1]);
strcpy(nombre[k+1],nombretemp);
}
}
if(inter)
{
prom[temp]=prom[i];
prom[i]=t;
}
}

cout << "Los promedios ordenados de manera ascendente son"<<endl;
  for(i=0;i<5;i++){
  cout<<prom[i]<<"  "<<nombre[i]<<endl;
}
cout << "Las promedios ordenados de manera descendente son"<<endl;
  for(i=4;i>=0;i--){
  cout<<prom[i]<<"  "<<nombre[i]<<endl;
}
getch();
}

Este programa captura cinco nombres y tres calificaciones da cada uno determina el promedio y los ordena de manera acendente y decendente por el metodo de selecciòn.
Este metodo funciona asi:

selecciona el elemento con el menor valor y lo intercambia con el primer elemento. Despues, entre los restantes n-1 elementos, busca el siguiente elemento menor y lo intercambia con el segundo elemento y asi sucesivamente hasta llegar al valor mayor.

ORDENAMIENTO POR EL METODO DE LA BURBUJA

CODIGO FUENTE DEL PROGRAMA


#include <iostream.h>
#include <conio.h>
#include <stdio.h>
#include<string.h>

void main()
{
clrscr();
char nombre[5][20];
int cal[3][5];
int prom[5];
int temp;
char nombretemp[10];
int suma;
int i,j,k;
for(i=0;i<5;i++){
 suma=0;
cout<<"Introduce el nombre"<<endl;
cin>>nombre[i];
for(j=0;j<3;j++){
cout<<"calificacion"<<endl;
cin>>cal[i][j];
suma=suma+cal[i][j];
}
 prom[i]=suma/3;
cout<<nombre[i]<<endl;
cout<<"promedio :"<<prom[i]<<endl;
}
//metodo de burbuja
for(i=0;i<5-1;i++){
 for(k=0;k<5-1;k++){
if(prom[k]>prom[k+1])
{
temp=prom[k];
prom[k]=prom[k+1];
prom[k+1]=temp;
strcpy(nombretemp,nombre[k]);
strcpy(nombre[k],nombre[k+1]);
strcpy(nombre[k+1],nombretemp);
}
}
}
cout << "Los promedios ordenados de manera ascendente son: \n";
  for(i=0;i<5;i++){
  cout<<prom[i]<<"  "<<nombre[i]<<endl;
}
cout << "Las promedios ordenados de manera descendente son: \n";
  for(i=4;i>=0;i--){
  cout<<prom[i]<<"  "<<nombre[i]<<endl;
}
getch();
}


Este programa captura cinco nombres y tres calificaciones de cada uno, asi mismo determina el promedio de cada nombre y por medio del ordenamiento del metodo de la burbuja ordena los promedios de manera decendiente y acendiente con su respectivo nombre.

miércoles, 20 de octubre de 2010

METODOS DE ORDENAMIENTO

ORDENAMIENTO.

Uno de los procedimientos más comunes y útiles en el procesamiento de datos, es la clasificación u ordenación de los mismos. Se considera ordenar al proceso de reorganizar un conjunto dado de objetos en una secuencia determinada. Cuando se analiza un método de ordenación, hay que determinar cuántas comparaciones e intercambios se realizan para el caso más favorable, para el caso medio y para el caso más desfavorable.
La colocación en orden de una lista de valores se llama Ordenación. Por ejemplo, se podría disponer una lista de valores numéricos en orden ascendente o descendente, o bien una lista de nombres en orden alfabético. La localización de un elemento de una lista se llama búsqueda.
Tal operación se puede hacer de manera más eficiente después de que la lista ha sido ordenada.
Existen varios métodos para ordenamiento, clasificados en tres formas:
Intercambio
Selección
Inserción.
En cada familia se distinguen dos versiones: un método simple y directo, fácil de comprender pero de escasa eficiencia respecto al tiempo de ejecución, y un método rápido, más sofisticado en su ejecución por la complejidad de las operaciones a realizar, pero mucho más eficiente en cuanto a tiempo de ejecución. En general, para arreglos con pocos elementos, los métodos directos son más eficientes (menor tiempo de ejecución) mientras que para grandes cantidades de datos se deben emplear los llamados métodos rápidos.
Intercambio

El método de intercambio se basa en comparar los elementos del arreglo e intercambiarlos si su posición actual o inicial es contraria inversa a la deseada. Pertenece a este método el de la burbuja clasificado como intercambio directo. Aunque no es muy eficiente para ordenar listas grandes, es fácil de entender y muy adecuado para ordenar una pequeña lista de unos 100 elementos o menos.
Una pasada por la ordenación de burbujeo consiste en un recorrido completo a través del arreglo, en el que se comparan los contenidos de las casillas adyacentes, y se cambian si no están en orden. La ordenación por burbujeo completa consiste en una serie de pasadas ("burbujeo") que termina con una en la que ya no se hacen cambios porque todo está en orden.
Ejemplo:
Supóngase que están almacenados cuatro números en un arreglo con casillas de memoria de x[1] a x[4]. Se desea disponer esos números en orden creciente. La primera pasada de la ordenación por burbujeo haría lo siguiente:
Comparar el contenido de x[1] con el de x[2]; si x[1] contiene el mayor de los números, se intercambian sus contenidos.
Comparar el contenido de x[2] con el de x[3]; e intercambiarlos si fuera necesario.
Comparar el contenido de x[3] con el de x[4]; e intercambiarlos si fuera necesario.
Al final de la primera pasada, el mayor de los números estará en x[4].
Quicksort.

Si bien el método de la burbuja era considerado como el peor método de ordenación simple o menos eficiente, el método Quicksort basa su estrategia en la idea intuitiva de que es más fácil ordenar una gran estructura de datos subdividiéndolas en otras más pequeñas introduciendo un orden relativo entre ellas. En otras palabras, si dividimos el array a ordenar en dos subarrays de forma que los elementos del subarray inferior sean más pequeños que los del subarray superior, y aplicamos el método reiteradamente, al final tendremos el array inicial totalmente ordenado. Existen además otros métodos conocidos, el de ordenación por montículo y el de shell.
Selección.

Los métodos de ordenación por selección se basan en dos principios básicos:
Seleccionar el elemento más pequeño (o más grande) del arreglo.
Colocarlo en la posición más baja (o más alta) del arreglo.
A diferencia del método de la burbuja, en este método el elemento más pequeño (o más grande) es el que se coloca en la posición final que le corresponde.
Inserción.

El fundamento de este método consiste en insertar los elementos no ordenados del arreglo en subarreglos del mismo que ya estén ordenados. Dependiendo del método elegido para encontrar la posición de inserción tendremos distintas versiones del método de inserción
Bibliografía
http://www.mailxmail.com/curso-aprende-programar/metodos-ordenamiento-busqueda