Temas

Código [Seleccionar] Expandir


al momento de graficar arboles binarios me dipen que grafique el siguiente arbol
14, 15 , 4, 9, 7, 18, 3, 5, 16, 4, 20, 17, 9, 14, 5            
                                  14
                                /     \
                             4          15
                           /    \        /  \
                         3       9    14    18
                                 / \      /    \
                               7    9     16   20
                              /             \
                             5               17
                           /
                         4



bueno mi consulta es si aplico bien la insercion de elementos duplicados en un arbol binario:
- si hay un valor duplicador insertarlo a la derecha de dicho nodo asumiendo (>=)

por favor si estoy errando me harian el favor de decirme cual es la regla para efectuar la insercion de duplicados en un arbol binario.

hola tengo una consulta como puedo modificar mi programa para que acepte cadenas y no solo un caracter: aqui adjunto mi programa.

Código [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
typedef struct nodo
{
   char elemento;
  struct nodo *siguiente;
  struct nodo *anterior;
} NODOLISTA;

typedef NODOLISTA *PtrNodo;
typedef NODOLISTA *Lista;

void insertar(Lista*, char);
void mostrar(Lista);

main()
{
      Lista lista=NULL;
      insertar(&lista,'Juan');
      insertar(&lista,'Homero');
           
      mostrar(lista);
      getchar();
      return 0;
}

void insertar(Lista *lista, char nombre)
{
   PtrNodo nuevo, actual;
   nuevo = (PtrNodo)malloc(sizeof(NODOLISTA));
   nuevo->elemento = nombre;
   actual = *lista;
   if(actual)
     {
         while(actual->anterior)
              {
                actual = actual->anterior;
              }
     }
   if(!actual || actual->elemento > nombre)
     {
        nuevo->siguiente = actual;
        nuevo->anterior = NULL;
        if(actual)
          {
            actual->anterior = nuevo;
          }
        if(!*lista)
          {
            *lista = nuevo;
          }
     }
   else
      {
         while(actual->siguiente &&actual->siguiente->elemento <= nombre)
              {
                 actual = actual->siguiente;
              }
         nuevo->siguiente= actual->siguiente;
         actual->siguiente = nuevo;
         nuevo->anterior = actual;
         if(nuevo->siguiente)
           {
         nuevo->siguiente->anterior = nuevo;
      }
   }
}

void mostrar(Lista lista)
{
  PtrNodo nodo = lista;
  if(!lista)
    {
      printf("\"La Lista esta Vacia\"");
    }
  else
     {
         while(nodo->anterior)
              {
                 nodo = nodo->anterior;
              }
         while(nodo)
              {
                 printf("-> %s", nodo->elemento);
                 nodo = nodo->siguiente;
              }

     }   
  printf("\n");
}




o alguien no tiene alguna funcion de insertar de una lista de la siguiente forma
insertar(lista,'juan');

hola como puedo sumar los datos de esta funcion;por ejemplo la impresion de datos esta correcta,lo que no comprendo es como sumar esos datos impresos

ejemplo: digite nivel: 2
             los datos del nivel 2: 10 30
             la suma del nivel:?

Código [Seleccionar] Expandir



void nodos_nivel(struct nodo* NODOARBOL, int nivel)
{
     if(NODOARBOL)
       if(nivel==1)
          printf("%d\t",NODOARBOL->dato);
       else
          {
             nodos_nivel(NODOARBOL->izq,nivel-1);
             nodos_nivel(NODOARBOL->der,nivel-1);
          }
}


que debo modificar para eliminar los elementos impares, no me permiten usar funciones auxiliares en mi programa:

Código [Seleccionar] Expandir



int Borrar(struct Cola **Cabecera,struct Cola **cola)
{
    int valor;
    struct Cola *Temporal;
    valor=(*Cabecera)->Dato;
    Temporal= *Cabecera;
    *Cabecera=(*Cabecera)->Siguiente;
    if(*Cabecera==NULL)
    *cola=NULL;
    free(Temporal);
    return valor;
}


Bueno mi problema es el siguiente:  diseñe un programa con arboles binarios, que imprima el recorrido inorden de los siguientes datos 1, 6 , 4 , 10, 12, 8. Nota el usuario no debe digitar ningu dato.

bueno , al compilar el programa no me da ningun error, pero no me imprime  el recorrido en Inorden de mi arbol no se en que me estoy equivocando, si me pueden decir, les adjunto el codigo:

Código [Seleccionar] Expandir



#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef int Tipo_elemento;

struct nodo
{
   Tipo_elemento el;
   struct nodo *izq, *der;
};

typedef struct nodo NODO;

NODO* Crear_nodo(Tipo_elemento el);
NODO* Construir(Tipo_elemento el, NODO *izq, NODO *der);

//recibe como parametro un arbol y retorna su hijo izquierdo
NODO* Hijo_izq(NODO *a);

/recibe como parametro un arbol y retorna su hijo derecho
NODO* Hijo_der(NODO *a);

/*------------------- Recoridos del arbol binario ---------------------*/
void Inorden(NODO *a);


/*---------------------------------------------------------------------*/

NODO* Crear_nodo(Tipo_elemento el)
{
  NODO *nuevo;
  nuevo=(NODO*)malloc(sizeof(NODO));
  nuevo->el=el;
  nuevo->izq = nuevo->der = NULL;
  return nuevo;
}
NODO* Construir(Tipo_elemento el, NODO *izq, NODO *der)
{
  NODO *nn;
  nn=Crear_nodo(el);
  nn->izq=izq;
  nn->der=der;
  return (nn);
}
NODO* Hijo_izq(NODO *a)
{
  if(a)
    return (a->izq);
  else
     {
 return (NULL);
     }
}
NODO* Hijo_der(NODO *a)
{
  if(a)
    return (a->der);
  else
     {
 return (NULL);
     }
}

void main()
{
    NODO *raiz=NULL;
    Construir(1,izq,der); Construir(6,NULL,NULL);  Construir(4,NULL,NULL);
    Construir(10,izq,der); Construir(12,NULL,NULL);  Construir(8,NULL,NULL);
   
    printf("El recorrido en inorden sera:");
    Inorden(raiz);
    getchar();
}

void Inorden(NODO *a)
{
   if(a)
     {
 Inorden(a->izq);
 printf("%d", a->el);
 Inorden(a->der);
     }
}







tengo una duda con los ficheros cuando implemento el siguiente codigo solo me crea el txt pero no me guarda nada, pero si me crea el archivo.

Código [Seleccionar] Expandir


FILE *fp;
fp = fopen ( "datos.txt", "w" );
fclose ( fp );


creen que sera por la forma en que pregunto datos por ejemplos lo pregunto con printf(" "); y leo con scanf o es de otra manera les agradeceria

Hola quisiera si alguien tiene ejemplos de ¿Como manejar puerto paralelo con el ensamblador?

hola alguien tiene estos codigos: cola de prioridad ascendenete y cola de prioridad descendente, no importa si estan es pdeucocodigo los necesitos para estudiar las colas.

bueno estoy creando una lista, los datos en mi lista son:

nombre: xxxxx
carnet:xxxxx
boleta:xxxxxxxxxx

la cuestions es que quiero poner esos tres datos es un rectangulo, pero tengo un problema, que cuando digitos nombre de diferente longitud el rectangulo me varia por ejemplo:

Código [Seleccionar] Expandir


------------------------------------------------------
|  nombre: zoe  carne: CD200001   boleta:100000001  |
--------------------------------------------------------------
|  nombre: Edenilson   carne: ED200025   boleta:100000002    |
--------------------------------------------------------------
|  nombre: mateo  carne: ED200025   boleta:100000002 |
------------------------------------------------------
ocupo:
 printf("---------------------------------------------------------------\n");
 printf("|");
 printf("nombre:%s  carne:%d  boleta:%d |\n",no, car,bol);
 printf("------------------------------------------------------------------");



lo que quiero saber es si hay alguna forma en c/c++ de imprimir un rentangulo
sin que ese rectangulo no se vea modificado por la longitud de los datos por ejemplo:

---------------------------------------------------------
|  nombre: zoe   carne: CD200001   boleta:100000001      |
---------------------------------------------------------
|  nombre: Edenilson   carne: ED200025   boleta:100000002|
---------------------------------------------------------
| nombre: mateo    carne: ED200025   boleta:100000002    |
---------------------------------------------------------
nota: he ocupado validacion para que no exceda las longitudes






estoy creando el juego quien quiere ser millonario:

typedef struct nodo
{
   struct millonario date;
   struct nodo *next;   
}stack;


bueno lo que no entiendio es porque me dijieron que la implentacion la hiciera con manejo de pilas, yo se que las pilas son un tipo de listas que tiene la condicion "ultimo elemento que entra es el primero que sale" bueno si asi que logica se puede interpretar efectuaro con pilas, no entiendo.

tengo una consulta:

bueno en c que facilita el uso de clases, facilitara una mejor interpretacion del codigo, una mayor eficiencia del codigo, no se yo las ocupo porque creo que facilitan al programador una mayor interpretacion y manejo de datos no se si me equivoco aclarenme...

Código [Seleccionar] Expandir


class stack
{
   private:

     long double *ptr;
     long double top;
     long double size;

   public:

     stack()
      {
top=0;
size=200;
ptr=new long double [size];
      }

int full()
       {
if(top==size)
{
return 1;
}
else
return 0;
       }

      int empty()
       {


if(top==0)
{
return 1;
}
return 0;
       }
};stack st;


Bueno la mayoria de libros trata las listas doble de la siguiente manera:

Código [Seleccionar] Expandir


struct elemento
   {

     struct elemento *siguiente, *anterior;
   }



me encontre una separata con un codigo que no declaraba estos dos punteros si no que estos eran funciones es el equivalente esto a lo anteriro les agradeceria su opinion.

Código [Seleccionar] Expandir



#define MAX 100

// tipos de datos
typedef int  posicion;
typedef int  tipo;
typedef int  logico;
typedef int datos;
typedef struct Lista;
typedef struct boton;
typedef struct Lista
{
  struct boton e[MAX];
  int cont;
};

// prototipos de funciones
void inicializa(struct Lista *L);
logico vacia(struct Lista L);
logico llena(struct Lista L);
void inserta(struct Lista *L, posicion p, struct boton e);
posicion primera(struct Lista L);
posicion ultima(struct Lista L);
datos recuperar(struct Lista L, posicion p);
posicion fin (struct Lista L);
posicion siguiente(struct Lista L, posicion p);
posicion anterior(struct Lista L, posicion p);

posicion primera(struct Lista L)
{
if(vacia(L)==1)
return posicion_invalida;

return 0;
}

posicion ultima(struct Lista L)
{
  return L.cont;
}



hola , tengo una duda mi enunciado de mi problema es el siguiente: "Dados los elementos 1 ,- 2 , -3 ,4 ,5 ,7 realice una pila que sume los elementos positivos y los elementos negativos. Nota: usar memoria dinamica y no teclear datos en su programa"

la salida de impresion me da lo siguiente

Los elementos de la pila:

1 ,- 2 , -3 ,4 ,5 ,7

la suma de los  positivos: 16 lo correcto seria 17
la suma de los negativos: -5

pero como pueden ver no me suma el primer elemento que es uno, no se que sera espero me puedan corregir si he errado, aqui les pongo el codigo.




aqui esta mi codigo:

Código [Seleccionar] Expandir



#include<stdio.h>
#include<stdlib.h>
struct Pila
{
   int Dato;
   struct Pila *Siguiente;
};
void Push(struct Pila **,int);
int Pop(struct Pila **);
void ImprimePila(struct Pila *);
int main(void)
{
  struct Pila *PtrPila;
  PtrPila=NULL;
  Push(&PtrPila, 7);  Push(&PtrPila, 5);  Push(&PtrPila, 4);
  Push(&PtrPila,-3);  Push(&PtrPila,-2);  Push(&PtrPila, 1);
  ImprimePila(PtrPila);
  getchar();
  return 0;
}

void Push(struct Pila **Tope, int valor)
{
  struct Pila *Nuevo;
  Nuevo = (struct Pila *) malloc( sizeof(struct Pila) );
  if(Nuevo!=NULL)
    {
     Nuevo -> Dato = valor;
     Nuevo -> Siguiente = *Tope;
     *Tope=Nuevo;
   }
  else
     printf("No hay memoria suficiente.\n");
}
int Pop(struct Pila **Tope)
{
   struct Pila *Temporal;
   int ValorPop;
   Temporal= *Tope;
   ValorPop=(*Tope)->Dato;
   *Tope=(*Tope)->Siguiente;
   free(Temporal);
   return ValorPop;
}
void ImprimePila(struct Pila *Actual)
{
    int suma=0, negativo=0;
    if(Actual==NULL)
      {
printf("La pila esta vacia.\n"); }
    else
      {
  printf("Los elementos de la pila:\n");
  while(Actual!=NULL)
       {
  printf(" %d ",Actual->Dato);
  Actual=Actual->Siguiente;
  if(Actual->Dato >=0)
     suma+=Actual->Dato ;
  else
     negativo+=Actual -> Dato;
      }
      printf("\nLa suma de los positivos: %d", suma);
      printf("\nLa suma de los negativos: %d", negativo);


}

}



No soy muy amigo de este tema en c, pero me puse a estudiarlo y me busque codigos fuentes y la mayoria los declaran. pero me surgio una duda por  el ejemplo  que encontre:

Código [Seleccionar] Expandir


void visualiza(void)
{
  int i;
  for(i=1;i<160;i+=2)
      {
          if(*shortcuts=='^') // aqui mi duda porque no son declarados con un int,
                                       // char o flotante, les estaria muy agradecido
            shortcuts++;
      }  
}


*Vdu=(char far *)0xb8000000;"  ?

alguien tiene informacion o documentacion de "La escritura en la memoria con pantallas de visualización"  0xB8000000; le estaria muy agradecido

Hola, estoy buscando este :

Tads, Estructuras Dedatos y Resolución de Problemas con C++ 



yo lo trate de buscar y me salia estos dos link pero no es el libro es un libro de bases de datos:

http://hotfile.com/dl/86295176/3d5037a/C_Solve.rar.html

http://depositfiles.com/es/files/cxk6qv9lm


si alguien sabe de donde esta o tiene el link

hola , alguien tiene un compilado solo de "C" para windows , no C++, porque la mayorias los han arruinado porque les han añadido librerias no estandares de C.


Les agradeceria si saben alguno o me recomiendan uno.

Hola tengo un ipod shuffle version tres.




Tengo un problema llevo cargandolo aproximandamente 8 horas y no me pasa de la luz anaranjada y ya lo cargue en tres maquinas distintas y igual tengo la ultima version de itunes 10.0.1

No que cual sera el problema si alguien que tenga un ipod de este tipo y le haya pasado lo mismo o sabe que tiene me puede decir por favor.

Hola tengo un problema con mi PC que cuando enciendo mi regulador de voltaje se enciende mi PC sin yo encerderla y le tengo que ir a configurar el boot para poder iniciar ,si no le configuro el boot queda la pantalla negra y no carga,  aveces tengo el media player y se me apaga el equipo  y me dice que el que ha ocurrido un error grave del sistema grave por lo que windows no puede continuar y despues  cuando vuelvo encende la pc me  sale la pantalla azul con lo siguiente

El proceso del sistema windows logo process termino inesperadamente con un estado de 0xc0000005 se ha apagado el sistema y no me pasa de alli que puedo hacer ya ,e aburri de formatear.

que me recomienda porfa se los agradeceria.

Hola estudie recientemente estructuras de datos en c (pilas, colas, listas, arboles) , yo quisiera seguir aprendiendo mas acerca de estructuras de datos no se si me pudieran recomendar algun libro pero que las trate mas complejas este tipo de estructuras , porque la mayoria de libros de estructuras abarcan casi los mismos ejemplos asi que si saben algun libro estructuras de datos en c me lo pudiera recomendar se los agradeceria...

Hola tengo un problema con este router, lo que me sucedio es que lo desconecte y solo deje la conexión de internet de  cable directa a la pc.

El problema me sucedio cuando lo quise conectar de nuevo me aperece el icono que se acaba de conectar a internet , pero no me pernite ni conectarme desde mi pc y ni de mi laptop

aqui les dejo una imagen:


http://www.freeimagehosting.net/image.php?796b73ca03.jpg


Y cuando dejo directo solo la conexión de cable si conecta perfectamente , que podra ser , si alguien sabe le estaria muy agradecido.

mi codigo es el siguiente:

Código [Seleccionar] Expandir



void CODIGO(void)
{
      FILE *archivo;

     int i;
     char c;
     printf("El codigo en orden alfabetico:");
     for(i=1; i<=MAX_N_S; i++)
if(frecuencia[i]!=0)
  {
     c=inicio_reconstruccion(i);
     if(c==' ')
printf("\n\tEspacio");
     else
       if(c=='\n')
  printf("\n\tLinea");
       else
    printf("\n\t%c",c);
if(codigo[i]==NULL)
   printf("\n\aError\a\n");
else
      printf("\t==>%s",codigo[i]);
  }
getch();
printf("\n\n\n\n");
printf("\nEl arbol de huffman quedo codificado a:\n\n");

archivo=fopen("huffman.txt","r");

for(i=0; entrada[i]!='\0';i++)
   {

       printf("%s",codigo[ inicio_mapa(entrada[i]) ] );
       fwrite(codigo[inicio_mapa(entrada[i])], sizeof(codigo),1,archivo);

   }
   fclose(archivo);
   
}




mi  consulta es que cuando quiero guardar el codigo en un txt solo me crea el archivo huffman.txt pero no me guarda nada , alguien si sabe como me lo podria guardar  le estari muy agradecido...

Hola estoy creando un funcion que me represente en menu de carga siguiente:


http://hosting.deimagenes.com/?v=carga.jpg

bueno cuando me carga que me maximiza la pantalla del compilador de la siguiente manera:


http://hosting.deimagenes.com/?v=tcmaximiza.jpg

bueno la consulta es como despues de representar ese menu de carga como minimizar la pantalla de turbo c a su tamaño original


http://hosting.deimagenes.com/?v=tcminimiza.jpg

El problema es que cuando voy visualizando las lista me sale demasiado grande el texto y no me muestra los primero registros.

Alguien sabe como minimizar esa pantalla sin la intervencion de ALT+Enter.
me refiereo desde el compilador alguna intruccion en c que haga esto .... porfa les estare muy agradecido.

bueno tengo que hacer una lista doble (inventario) que contenga un unico codigo , nombre , precio  y cantidad , por ejemplo:

codigo : 12345
nombre: cafe
precio  :$ 10.00
cantidad: 10

corrijame si voy mal

Código [Seleccionar] Expandir



typedef struct lista_d
{
char codigo[10];
char nombre[10];
float precio;
         int cantidad;
struct lista_d *prox;
struct lista_d *ant;
}   lista_d;
     lista_d *p;

lista_d *CreaNodo (char x)
{
lista_d *p = NULL;
p = (lista_d *) malloc(sizeof(lista_d));
if (p != NULL)
{
p->info = x;
p->prox = p->ant  =NULL;
}
return p;
}
void insertar(lista_d** cabeza, dato)
{
lista_d *nuevo;
nuevo=CreaNodo(dato);
nuevo->adelante=*cabeza;
nuevo->atras=NULL;
if(*cabeza!=NULL)
  {
  (*cabeza)->atras=nuevo;
         *cabeza=nuevo;
  }
}
void main()
{
lista_d *cabeza;
cabecera=NULL;
}


otra duda para actualizar una lista doble por ejemplo  si quiereo actuzalizar que en vez de que sean 10 articulos si no que 15 con el mismi codigo y producto solo se los sumo o lo aplico la funcion de eliminacion por ejemplo:

inventario no actulizado:

codigo : 12345
nombre: cafe
precio  :$ 10.00
cantidad: 10

inventario  actulizado:

codigo : 12345
nombre: cafe
precio  :$ 10.00
cantidad: 15

bueno me ha llamado la atencion el temas de arboles en especial los "arboles binarios y los arboles AVL"

Bueno yo se que un arbol binario  es una estructura de datos en la cual cada nodo siempre tiene un hijo izquierdo y un hijo derecho.
Un arbol AVL están siempre equilibrados de tal modo que para todos los nodos, la altura de la rama izquierda no difiere en más de una unidad de la altura de la rama derecha.

bueno mi duda que tengo es " porque muchos programadores aplican a los arboles binarios las operaciones de los arboles AVL"  por ejemplo

por ejemplo: las operaciones de un arbol binario son (mas basicas)
insertar un dato
eliminar un dato
buscar un dato

la de los arboles AVL
las rotaciones:  rotacion a la derecha
                       rotacion a la izquierda

bueno corrijamen si estoy en lo equivocado y si no saquenme de la duda:

yo creo que se aplican  los arboles AVL en los arboles binario para lograr un equilbrio o balanceo y  una mayor eficiencia con respecto a las busquedas debido a que el arbol queda ordenado logrando una eficiencia de ( Log n ) equilibrando

porfavor si alguien me puede aclarar esta duda, le agradeceria.

                       

estoy trabajando con punteros

Código [Seleccionar] Expandir


value = (*cabeza_ptr)->dato
temporal =*cabeza_ptr


bueno mi consulta es como se representa es pseudocogico esta intruccion * , ->

yo lo hice asi no se si estara bien

Código [Seleccionar] Expandir


value = cabeza: dato
temporal : cabeza_ptr


Hola mi programa tiene la siguiente estrcutura

Código [Seleccionar] Expandir


struct node
{
   int info;
   struct node *next;
};

typedef struct node *nodePtr;



bueno lo estoy pasando a pseudocodigo no se si lo  hice bien si no haganmelo saber

Código [Seleccionar] Expandir



estructura nodo
{
     var info
     estructura node → next
}
tipo_de_dato  estructura node → nodePtr





[Serie Schaum]

es un excelente libro de programacion si alguien lo tiene o sabe el link de descarga le estaria muy agradecido:

TITULO: C. Algoritmos, programación y estructura de datos. Serie Schaum

AUTOR/ES: Joyanes Aguilar, Luis; Castillo Sanz, Andrés;Sánchez García, Lucas & Zahonero Martínez, Ignacio

AÑO: 2005

EDICION: 1ª

IDIOMA: Castellano

[linux]

bueno estoy en la desarollando un sistema de invetario lo que no se como puedo hacer es hacer la validacion de texto por ejemplo yo hice este programa que valida la entrada de 5 caracteres de una cadena y no permite mas caracteres exactamente  5, pero el problema me surge que el programa lo estoy trabajano en linux no se si habra otra forma de hacer esto porque en linux.
En linux  da error por la libreria conio... les agradeceri si hay alguna forma de validar cadena ya sea con un ciclos for , while les estaria muy agradecido


por ejemplo si el usuario quiere difitar lo siguiente
  codigo -> elhacker
el programa solo le escribira "elhac" y aunque el usuario digite no se le deplegara mas caracactere solo exactamente 5, eso es lo que hace este programa. pero lo malo que se vale mucho de la libreria conio y el problema que lo desarollo en linux

vean

Código [Seleccionar] Expandir


//****  este programa lo desarolle en turbo c++ 3.0 ***** ///
// permite la entrada solo de 5 caracteres ideales para validacion de cadenas

#include <stdio.h>
#include <conio.h>
int main(void)
{
    char cadena[6];       // contiene el array char
    char *puntero;         // es el puntero donde se almacena el array char
    clrscr();
    cadena[0] = 6;       
    printf("Digite el codigo:\n");
    puntero = cgets(cadena);
    fflush(stdin);
putchar(*puntero);
putchar('\n');

    getch();
    return 0;
}



bueno es un diccionario con arboles binarios,  la estructuras de mi programa son las siguiente

Código [Seleccionar] Expandir


struct nodos
{
char ingles[50];
char español[50];
struct nodos *der;
struct nodos *izq;
int siguiente;
};
     typedef struct nodos Arbol;
     typedef Arbol *ARBOL;
     int listo;
    char in[50],es[50];

la consulta es como guardo todo el diccionario en un .txt

yo lo intente haci

Código [Seleccionar] Expandir


void cargar()
{
  nodos Arbol info;
  FILE *fp;

  fp=fopen("arbol.txt","r");
  if(fp==NULL)
  {
     printf("No se puede abrir el archivo\n");
     return;
  }

  while(!feof(fp))
  {
     if(fread(&info, sizeof(nodos Arbol), 1, fp)!=1) break;
      agregar(&raiz);
  }

  fclose(fp);
}

void guardar()
{
   nodos Arbol info;
  FILE *fp;

  fp=fopen("arbol.txt","w");
  if(fp==NULL)
  {
     printf("No se puede abrir el archivo\n");
     return;
  }



pero no me sirve y me da como 7 errores no se a que se debera alguien si sabe me podria decir en que equivoco

errores:
undefined symbol nodos
statement mising
expected
if statementm missing
undefine symbol raiz
declaration syntax error

no se que sera

*******************************************************************
bueno aca el codigo completo del programa si alguien puede poner esa opcion de guardar  en un txt se lo agradeceria :

Código [Seleccionar] Expandir


#include "stdio.h"
#include "stdlib.h"
#include "conio.h"
#include "string.h"
#include "iostream.h"
//-------------------------------------------------------------------------------------
// Estructura del Nodo
//-------------------------------------------------------------------------------------
struct nodos{
char ingles[50];
char espanol[50];
struct nodos *der;
struct nodos *izq;
int Fe;
};
//-------------------------------------------------------------------------------------
// --------------------
//-------------------------------------------------------------------------------------
typedef struct nodos Arbol;
typedef Arbol *ARBOL;
int listo;
char in[50],es[50];
//-------------------------------------------------------------------------------------
// Protótipos de las funciones
//-------------------------------------------------------------------------------------
void menu();
void menu_agregar();
void menu_ingles();
void menu_espanol();
void menu_borrar();
void menu_listar();
void agregar(ARBOL  *nodoarb);
void buscar_ingles(ARBOL nodoarb);
void buscar_espanol(ARBOL nodoarb);
void listar(ARBOL nodoarb);
void rotacionddsimple(ARBOL *nodoarb);
void rotaciondidoble(ARBOL *nodoarb);
void rotaciondd2(ARBOL *nodoarb);
void rotacionii2(ARBOL *nodoarb);
void rotacioniisimple(ARBOL *nodoarb);
void rotacioniddoble(ARBOL *nodoarb);
void menor(ARBOL nodoarb);
void actualizarbi(ARBOL *nodoarb, int *ban);
void actualizarbd(ARBOL *nodoarb, int *ban);
void eliminar(ARBOL *nodoarb, int *ban);
void borrar(ARBOL *nodoarb , int *ban);
//-------------------------------------------------------------------------------------
//     PROGRAMA PRINCIPAL
//-------------------------------------------------------------------------------------
void main()
{
char opc='1';
int ban=1;
ARBOL raiz=NULL;
do
{
menu();
cin>>opc;
switch(opc){
case '1':
menu_agregar();
    cout<<"Introduzca Palabra en Ingles : ";
cin>>in;
cout<<"Introduzca Palabra en Espanol : ";
cin>>es;
agregar(&raiz);
    break;
case '2':
menu_borrar();
cout<<"Que Palabra en Ingles desea Borrar? : ";
cin>>in;
borrar(&raiz,&ban);
cout<<"Elemento Borrado!";
    break;
case '3':
    menu_ingles();
cout<<"Que Palabra en Ingles desea Buscar? : ";
cin>>in;
listo=0;
buscar_ingles(raiz);
if (listo==0)
cout<<"Elemento no encontrado!";
getch();
listo=0;
break;
   
case '4':
menu_espanol();
cout<<"Que Palabra en Espanol desea Buscar? : ";
cin>>es;
listo=0;
buscar_espanol(raiz);
if (listo==0)
cout<<"Elemento no encontrado!";
getch();
listo=0;
break;
case '5':
menu_listar();
listar(raiz);
getch();
    break;
}
} while (opc !='6');
}
//-------------------------------------------------------------------------------------
//     Funcion Menu
//-------------------------------------------------------------------------------------
void menu()
{
system("cls");
cout<<"--------------------------------------------------------------------------------"<<endl;
cout<<"                                                                                "<<endl;
cout<<"               TRADUCTOR INGLES - ESPANOL / ESPANOL INGLES                      "<<endl;
cout<<"                                                                                "<<endl;
cout<<"--------------------------------------------------------------------------------"<<endl;
cout<<"                                                                                "<<endl;
cout<<"                  1. Agregar palabras al diccionario                            "<<endl;
cout<<"                                                                                "<<endl;
cout<<"                  2. Borrar palabras del diccionario                            "<<endl;
cout<<"                                                                                "<<endl;
cout<<"                  3. Consultar Palabra en Ingles                                "<<endl;
cout<<"                                                                                "<<endl;
cout<<"                  4. Consultar Palabra en Espanol                               "<<endl;
cout<<"                                                                                "<<endl;
cout<<"                  5. Listar Palabras                                            "<<endl;
cout<<"                                                                                "<<endl;
cout<<"                  6. Salir                                                      "<<endl;
cout<<"                                                                                "<<endl;
cout<<"--------------------------------------------------------------------------------"<<endl;
cout<<"                                                                                "<<endl;
cout<<"                                                                                "<<endl;
cout<<"                                                                                "<<endl;
cout<<"  Digite su Opcion?????                                                         "<<endl;

}

//-------------------------------------------------------------------------------------
//     Funcion Menu Agregar
//-------------------------------------------------------------------------------------
void menu_agregar()
{
system("cls");
cout<<"--------------------------------------------------------------------------------"<<endl;
cout<<"                                                                                "<<endl;
cout<<"                      AGREGAR PALABRAS AL TRADUCTOR                             "<<endl;
cout<<"                                                                                "<<endl;
cout<<"--------------------------------------------------------------------------------"<<endl;
cout<<"                                                                                "<<endl;
cout<<"                                                                                "<<endl;
cout<<"                                                                                "<<endl;
cout<<"                                                                                "<<endl;
}

//-------------------------------------------------------------------------------------
//     Funcion Menu Buscar Ingles
//-------------------------------------------------------------------------------------
void menu_ingles()
{
system("cls");
cout<<"--------------------------------------------------------------------------------"<<endl;
cout<<"                                                                                "<<endl;
cout<<"                         BUSCAR PALABRA EN INGLES                               "<<endl;
cout<<"                                                                                "<<endl;
cout<<"--------------------------------------------------------------------------------"<<endl;
cout<<"                                                                                "<<endl;
cout<<"                                                                                "<<endl;
cout<<"                                                                                "<<endl;
cout<<"                                                                                "<<endl;
}

//-------------------------------------------------------------------------------------
//     Funcion Menu Buscar Espanol
//-------------------------------------------------------------------------------------
void menu_espanol()
{
system("cls");
cout<<"--------------------------------------------------------------------------------"<<endl;
cout<<"                                                                                "<<endl;
cout<<"                        BUSCAR PALABRA EN ESPANOL                               "<<endl;
cout<<"                                                                                "<<endl;
cout<<"--------------------------------------------------------------------------------"<<endl;
cout<<"                                                                                "<<endl;
cout<<"                                                                                "<<endl;
cout<<"                                                                                "<<endl;
cout<<"                                                                                "<<endl;
}

//-------------------------------------------------------------------------------------
//     Funcion Menu Borrar
//-------------------------------------------------------------------------------------
void menu_borrar()
{
system("cls");
cout<<"--------------------------------------------------------------------------------"<<endl;
cout<<"                                                                                "<<endl;
cout<<"                      BORRAR PALABRA DEL DICCIONARIO                            "<<endl;
cout<<"                                                                                "<<endl;
cout<<"--------------------------------------------------------------------------------"<<endl;
cout<<"                                                                                "<<endl;
cout<<"                                                                                "<<endl;
cout<<"                                                                                "<<endl;
cout<<"                                                                                "<<endl;
}
//-------------------------------------------------------------------------------------
//     Funcion Menu Listar
//-------------------------------------------------------------------------------------
void menu_listar()
{
system("cls");
cout<<"--------------------------------------------------------------------------------"<<endl;
cout<<"                                                                                "<<endl;
cout<<"                      LISTAR PALABRAS DEL TRADUCTOR                             "<<endl;
cout<<"                                                                                "<<endl;
cout<<"--------------------------------------------------------------------------------"<<endl;
cout<<"                                                                                "<<endl;
}

//-------------------------------------------------------------------------------------
//      Funcion Agregar palabras al Diccionario
//-------------------------------------------------------------------------------------

void agregar(ARBOL  *nodoarb)
{

int det;
if (*nodoarb == NULL){
*nodoarb = new(Arbol);
if (*nodoarb != NULL){
strcpy((*nodoarb)->ingles,in);
strcpy((*nodoarb)->espanol,es);
(*nodoarb)->der=NULL;
(*nodoarb)->izq=NULL;
}
else{
            system("cls");
cout<<"No hay memoria suficiente!";
}
}
else
{
det=strcmp(in,(*nodoarb)->ingles);

if (det < 0)
agregar (&((*nodoarb)->izq));
else
if (det > 0)
agregar (&((*nodoarb)->der));
else
{
system("cls");
cout<<"¡¡¡ Dato duplicado !!!";
getch();
system("cls");
}
}
}

//-------------------------------------------------------------------------------------
//     Funcion Buscar Ingles
//-------------------------------------------------------------------------------------

void buscar_ingles(ARBOL nodoarb)
{
if (nodoarb != NULL){
buscar_ingles(nodoarb->izq);
if (strcmp(in,nodoarb->ingles)==0)
{
cout<<endl;
cout<<endl;
cout<<endl;
cout<<"                        "<<nodoarb->ingles<<" -> "<<nodoarb->espanol<<endl;
listo=1;
return;
}
buscar_ingles(nodoarb->der);
}
}

//-------------------------------------------------------------------------------------
//     Funcion Buscar Ingles
//-------------------------------------------------------------------------------------

void buscar_espanol(ARBOL nodoarb)
{
if (nodoarb != NULL){
buscar_espanol(nodoarb->izq);
if (strcmp(es,nodoarb->espanol)==0)
{
cout<<endl;
cout<<endl;
cout<<endl;
cout<<"                        "<<nodoarb->espanol<<" -> "<<nodoarb->ingles<<endl;
listo=1;
return;
}
buscar_espanol(nodoarb->der);
}
}
//-------------------------------------------------------------------------------------
//     Funcion listar Palabras
//-------------------------------------------------------------------------------------


void listar(ARBOL nodoarb)
{
if (nodoarb != NULL){
listar(nodoarb->izq);
cout<<"                            "<<nodoarb->ingles<<" -> "<<nodoarb->espanol<<endl;
listar(nodoarb->der);
}
}

//-------------------------------------------------------------------------------------
//     Funcion rotacionddsimple
//-------------------------------------------------------------------------------------

void rotacionddsimple(ARBOL *nodoarb)
{
  ARBOL nda=NULL;
nda=(*nodoarb)->der;
(*nodoarb)->der=nda->izq;
nda->izq=(*nodoarb);
nda->Fe=0;
(*nodoarb)->Fe=0;
}

//-------------------------------------------------------------------------------------
//     Funcion rotaciondidoble
//-------------------------------------------------------------------------------------

void rotaciondidoble(ARBOL *nodoarb)
{
  ARBOL nda1=NULL, nda2=NULL;
nda1=(*nodoarb)->der;
nda2=nda1->der;

nda1->izq=nda2->der;
nda2->der=nda1;
(*nodoarb)->der=nda2->izq;
nda2->izq=(*nodoarb);

if (nda2->Fe == 1)
(*nodoarb)->Fe=-1;
else
(*nodoarb)->Fe=0;
if (nda2->Fe == -1)
(*nodoarb)->Fe=1;
else
(*nodoarb)->Fe=0;

nda2->Fe=0;
(*nodoarb)=nda2;
}

//-------------------------------------------------------------------------------------
//     Funcion rotaciondd2
//-------------------------------------------------------------------------------------

void rotaciondd2(ARBOL *nodoarb)
{
  ARBOL nda=NULL;
nda=(*nodoarb)->der;
(*nodoarb)->der=nda->izq;
nda->izq=(*nodoarb);
nda->Fe=-1;
(*nodoarb)->Fe=1;
(*nodoarb)=nda;
}

//-------------------------------------------------------------------------------------
//     Funcion rotacionii2
//-------------------------------------------------------------------------------------

void rotacionii2(ARBOL *nodoarb)
{
  ARBOL nda=NULL;
nda=(*nodoarb)->izq;
(*nodoarb)->izq=nda->der;
nda->der=(*nodoarb);
nda->Fe=1;
(*nodoarb)->Fe=-1;
(*nodoarb)=nda;
}

//-------------------------------------------------------------------------------------
//     Funcion rotacionsimple
//-------------------------------------------------------------------------------------


void rotacioniisimple(ARBOL *nodoarb)
{
  ARBOL nda=NULL;
nda=(*nodoarb)->izq;
(*nodoarb)->izq=nda->der;
nda->der=(*nodoarb);
nda->Fe=0;
(*nodoarb)->Fe=0;
        *nodoarb=nda;
}

//-------------------------------------------------------------------------------------
//     Funcion rotacioniddoble
//-------------------------------------------------------------------------------------

void rotacioniddoble(ARBOL *nodoarb)
{
  ARBOL nda1=NULL, nda2=NULL;

nda1=(*nodoarb)->izq;
nda2=nda1->der;
nda1->der=nda2->izq;
nda2->izq=nda1;

(*nodoarb)->izq=nda2->der;
nda2->der=(*nodoarb);

if (nda2->Fe == 1)
nda1->Fe=-1;
else
nda1->Fe=0;
if (nda2->Fe == -1)
(*nodoarb)->Fe=1;
else
(*nodoarb)->Fe=0;

nda2->Fe=0;
(*nodoarb)=nda2;
}

//-------------------------------------------------------------------------------------
//     Funcion Menor
//-------------------------------------------------------------------------------------

void menor(ARBOL nodoarb)
{
if (nodoarb->izq == NULL)
{
strcpy(in,nodoarb->ingles);
strcpy(es,nodoarb->espanol);
}
else
menor(nodoarb->izq);
}

//-------------------------------------------------------------------------------------
//     Funcion Actualizarbi
//-------------------------------------------------------------------------------------

void actualizarbi(ARBOL *nodoarb, int *ban)
{
switch((*nodoarb)->Fe){
case -1:
(*nodoarb)->Fe=0;
break;
case 0:
(*nodoarb)->Fe=1;
*ban=0;
break;
case 1:
switch((*nodoarb)->der->Fe){
case 1:
rotacionddsimple(&(*nodoarb));
break;
case -1:
rotaciondidoble(&(*nodoarb));
break;
case 0:
rotaciondd2(&(*nodoarb));
*ban=0;
break;

}
break;
}
}
//-------------------------------------------------------------------------------------
//     Funcion Actualizarbd
//-------------------------------------------------------------------------------------


void actualizarbd(ARBOL *nodoarb, int *ban)
{
switch((*nodoarb)->Fe){
case 1:
(*nodoarb)->Fe=0;
break;
case 0:
(*nodoarb)->Fe=-1;
*ban=0;
break;
case -1:
switch((*nodoarb)->izq->Fe){
case -1:
rotacioniisimple(&(*nodoarb));
break;
case 1:
rotacioniddoble(&(*nodoarb));
break;
case 0:
rotacionii2(&(*nodoarb));
*ban=0;
break;

}
break;
}
}

//-------------------------------------------------------------------------------------
//     Funcion Eliminar
//-------------------------------------------------------------------------------------

void eliminar(ARBOL *nodoarb, int *ban)
{
ARBOL aux=NULL;

if ((*nodoarb)->izq == NULL){
aux=*nodoarb;
*nodoarb=(*nodoarb)->der;
free(aux);
*ban=1;
}
else{
if ((*nodoarb)->der == NULL){
aux=*nodoarb;
*nodoarb=(*nodoarb)->izq;
free(aux);
*ban=1;
}
else{
menor((*nodoarb)->der);
borrar(&(*nodoarb)->der,&(*ban));
if (*ban)
actualizarbd(&(*nodoarb),&(*ban));
}
}
}


//-------------------------------------------------------------------------------------
//     Funcion Borrar
//-------------------------------------------------------------------------------------


void borrar(ARBOL *nodoarb , int *ban)
{
if (nodoarb == NULL)
*ban=0;
else
if (strcmp((*nodoarb)->ingles,in)==0)
eliminar(&(*nodoarb),&(*ban));

else
if (strcmp((*nodoarb)->ingles,in) > 0 ){
borrar(&(*nodoarb)->izq,&(*ban));
if (*ban)
actualizarbi(&(*nodoarb),&(*ban));
}
else{
borrar(&(*nodoarb)->der,&(*ban));
if (*ban)
actualizarbd(&(*nodoarb),&(*ban));

}
}

//-------------------------------------------------------------------------------------
//                FIN
//-------------------------------------------------------------------------------------



hola estoy creando un programa que me imprime circulo pero me lo imprime haci:




yo utilizo la funcion circle(300,250,50); bueno mi consulta seria como rellenar ese circulo de esta manera (este es solo un ejemplo el):



si alguien sabe le estaria muy agradecido  porque quisiera saber como hacerlo.

bueno resulto que encontre un programa que venian los siguientes archivos

interfaz.h
funciones.h
principal.cpp
colas.cpp
pilas.cpp

entonces no se sinceramente no se si sera como un projecto si alguien sabe como hacerlo en turbo c++ 3.0 (Borlan) me puede decir como compilarlo es que ya probe y nada, les estaria muy agradecido.

alguien conoce algun juego hecho con la metodologia de un arbol binario si lo sabe me puede hacer el favor de desirmelo. Le estaria muy agradecido, es que quiero hacer un juego pero sencillo  con arboles binarios ya sea en c++ o dev.

Que sifnifica cuando estos  ciclo for se efectua de esta manera. Porque tengo unos programas que me los pasaron y estan de esta manera y soy sincero no creia que se pudiera hacer eso por eso les pido de favor si alguien sabe me lo diga.

Código [Seleccionar] Expandir



1.  que pasa cuando un ciclo for lo podemos de esta manera que efectua

for(; ;)
    {

     }


2. o cuando se pone de esta manera que realiza

for(10;10; ;)
        {

        }




Bueno hice los siguientes ejercicios:
- Secuencias de nodos que ordene de preorden, inorden, postorden
- Un arbol de bisqueda
- Cuantos nodos tiene que tener un arbol
- arbol que imprima las hojas de un arbol binario y los nodos interno de un arbol
- entre otros

Pero la consulta: que aplicacion de la vida cotidiana puedo demostrar utilizando arboles binarios pues la quiero pasar a c++ y demostarla , pues no pongo esos programas porque estan en la red por eso le pide que me den ideas de que puedo desarollar.

Por ejemplo yo habia pensado un arbol genealogico

                  abuela         abuelo                         abuela           abuelo   
                             papa                                             mama     
                                                hijo                 hija     
                                   
por esos le pido de favor me den mas ideas que otras aplicaciones puedo demostrar..