Lista doblemente enlazada mostrar de primero a ultimo y viceversa

#include<iostream>
using namespace std;

struct ListaD{
    int info;
    struct ListaD *sig;
    struct ListaD *ant;
};

void crearCabLD(struct ListaD *&cab,int info){
    cab=new ListaD;
    cab->info=info;
    cab->sig=cab->ant=NULL;
}

void agregarNodoLD(struct ListaD *&cab,int info){
    struct ListaD *aux=cab;
    while(aux->sig){
        aux=aux->sig;
    }
    aux->sig=new ListaD;
    aux->sig->ant=aux;
    aux=aux->sig;
    aux->info=info;
    aux->sig=NULL;
}

void crearListaLD(struct ListaD *&cab){
    int info=666;
    while(info>0){
        cout<<endl<<"Dato: ";
        cin>>info;
        if(info>0){
            if(!cab){
                crearCabLD(cab,info);
            }
            else{
                agregarNodoLD(cab,info);
            }
        }
    }
}

void Mostrar(struct ListaD *&cab){
    struct ListaD *aux=cab;
    while(aux->sig!=NULL){
        cout<<aux->info<<"\t";
        aux=aux->sig;
    }
    cout<<aux->info<<"\t\n";

    while(aux!=cab){
        cout<<aux->info<<"\t";
        aux=aux->ant;
    }
    cout<<aux->info<<"\t";
}

main(){
    struct ListaD *cab=NULL;
    crearListaLD(cab);
    Mostrar(cab);
}

pseudocodigo antes y despues de nodo pedido

INSERTARANTES(P,DATO,REF){

inserta el nodo antes que otro con información X en una lista doblemente ligada

(Q,X,T =variables de tipo puntero, F ultimo nodo)

1. Hacer q:=P y BAND:=0

2. Repetir mientras (Q->inf!=REF&&BAND==0)

    2.1 Si (Q->lig!=NULL)

         hacer Q:=Q->LDER, T:=Q

         sino  BAND:=1

     2.2 Fin paso 2.1

3. Fin paso 2

4. Si BAND=1

    entonces "Elemento no fue encontrado"

    sino  Crear X,  Hacer T:=Q->LIZ, X->inf:=DATO,

         X->LDE:=Q

         X->LIZ:=T

         Q->LIZ:=X, T->LDE:=X

5.  Fin paso 4.

INSERTARDESPUES(P,DATO,REF){

inserta el nodo despues que otro con información X en una lista doblemente enlazada

(Q,X,T =variables de tipo puntero, F ultimo nodo)

1. Hacer q:=P y BAND:=0

2. Repetir mientras (Q->inf!=REF&&BAND==0)

    2.1 Si (Q->lig!=NULL)

         hacer Q:=Q->LIZ, T:=Q

         sino  BAND:=1

     2.2 Fin paso 2.1

3. Fin paso 2

4. Si BAND=1

    entonces "Elemento no fue encontrado"

    sino  Crear X,  Hacer T:=Q->LDE, X->inf:=DATO,

         X->LIZ:=Q

         X->LDE:=T

         Q->LDE:=X, T->LIZ:=X

5.  Fin paso 4.

ejercicio lista simple

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

struct nodo {
 char est;
 int cod;
 struct nodo *sig;
};

main()
{
 int i = 0;
 int num;
 char x;
 struct nodo *p,*q;
 printf ("favor digite nombre del estudiante");
 scanf("%s",&x);
 printf ("favor digite codigo del estudiante");
 scanf("%d",&num);
 p=(struct nodo *) malloc (sizeof (struct nodo));
 p->cod=num;
 p->est=x;
 p->sig=NULL;
 
while (i<2){
 q=(struct nodo *)malloc (sizeof(struct nodo));
 printf ("favor digite nombre del estudiante");
 scanf("%s",&x);
 printf ("favor digite codigo del estudiante");
 scanf("%d",&num);
 q->sig=p;
 p=q;
 i++;
} 
}

Lista simple

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

struct nodo {
 int inf;
 struct nodo *sig;
};

main()
{
 int i = 0;
 int num;
 struct nodo *p,*q;
 printf ("favor digite numero");
 scanf("%d",& num);
 p=(struct nodo *) malloc (sizeof (struct nodo));
 p->inf=num;
 p->sig=NULL;
 
while (i<5){
 q=(struct nodo *)malloc (sizeof(struct nodo));
 printf("Si est an gentil digite el HP numero :");
 scanf("%d",&num);
 q->sig=p;
 p=q;
 i++;
} 
}

lista simple recorrer

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

struct nodo {
char le;
struct nodo *sig;
};

void recorrer (struct nodo *p){
struct nodo *q;
q=p;
printf("%c",(p->sig));
getchar();
while(q->sig!=NULL){
printf("%c",(q->le));
q=q->sig;
}
}

main()
{
char caracter;
struct nodo *p,*t;
printf ("favor digite caracter");
scanf("%c",& caracter);
p=(struct nodo *) malloc (sizeof (struct nodo));
p->le=caracter;
p->sig=NULL;
t=p;

while (caracter !='.'){
struct nodo *q;
q=(struct nodo *)malloc (sizeof(struct nodo));
printf("favor digite caracter");
scanf("%c",&caracter);
q->le=caracter;
q->sig=NULL;
t->sig=q;
t=q;
}
recorrer (p);
}

Arreglos y estructuras

struct: esta orden se emplea para agrupar variables de tipos iguales o diferentes en un solo registro, con la misma se pueden crear estructuras anónimas, estructuras con nombre, y un tipo especial de estructura conocida como bit-fields ( banderas o campos de bits ).

Las estructuras son colecciones de variables relacionadas bajo un nombre. Las estructuras pueden contener variables de muchos tipos diferentes de datos - a diferencia de los arreglos que contienen unicamente elementos de un mismo tipo de datos. 

----------------------------------------------------------------------------------

struct fecha 

{ 

int dia; 

int mes;

int anio; 

int dia del anio; 

char nombre mes[9]; 

}; 

_____________________________

struct persona

{ 

char nombre[tamanio nombre]; 

char direccion[tamanio dir];

long codigo postal; 

long seguridad social; 

double salario; 

fecha cumpleanios; 

fecha contrato; 

}; 

-----------------------------------------------------------------------------------

 ¿QUE ES UN APUNTADOR? Una de las cosas más difíciles que encuentran los principiantes en C es entender el concepto de apuntadores. El propósito de este documento es dar una introducción sobre apuntadores y de su uso a estos principiantes. Me he encontrado a menudo que la principal razón por la que los principiantes tienen problemas con los apuntadores es que tienen una muy pobre o mínima concepción de las variables, (del modo en que C hace uso de ellas). Así que comencemos con una discusión sobre las variables de C en general. Una variable en un programa es algo con un nombre, que contiene un valor que puede variar. El modo en que el compilador y el enlazador (linker) manejan esto es que asignan un bloque específico de la memoria dentro de la computadora para guardar el valor de una variable. El tamaño de este bloque depende del rango en que a esta variable le es permitido variar. Por ejemplo, en PC’s de 32 bits, el tamaño de una variable de tipo entero (int) es de 4 bytes, en una máquina antigua de 16 bits los enteros tienen un tamaño de 2 bytes. En C el tamaño de un tipo de variable como una de tipo entero no tiene porqué ser el mismo en todos los tipos de máquinas. Es más en C disponemos de diferentes tipos de variables enteras, están los enteros largos (long int) y los enteros cortos (short int) sobre los que puedes averiguar en cualquier texto básico sobre C. El presente documento asume que se está usando un sistema de 32 bits con enteros de 4 bytes. 

 TIPOS DE APUNTADORES Y ARREGLOS Consideremos el porqué tenemos que identificar el "tipo" de variable a la que apunta un puntero como en: int *ptr; Una de las razones para hacer esto es que una vez que ptr apunta a algo y si escribimos: *ptr = 2; El compilador sabrá cuantos bytes va a copiar en la posición de memoria a la que apunta ptr. Si ptr fuera declarado como un puntero a entero, se copiarían 4 bytes. De modo similar para números de punto flotante (float) y enteros dobles (doubles), se copiaría el número apropiado de bytes. Pero definir el tipo al que el apuntador apunta permite un cierto número de maneras interesantes en que el compilador puede interpretar el código. Por ejemplo, consideremos un bloque de memoria consistente en 10 números enteros en una fila. Eso es 40 bytes de memoria son reservados para colocar 10 enteros. Digamos que ahora apuntamos nuestro apuntador entero ptr al primero de estos números enteros. Es más, supongamos que este primer entero está almacenado en la posición de memoria 100 (decimal). Entonces que pasa cuando escribimos: ptr + 1;

otro puede ser.

prolog

que es prolog

Prolog es un propósito general de la programación lógica idioma asociado a la inteligencia artificial y la lingüística computacional . 

Prolog tiene sus raíces en la lógica de primer orden , una lógica formal , ya diferencia de muchos otros lenguajes de programación , Prolog es declarativa : la lógica del programa se expresa en términos de relaciones, representada como hechos y reglas . Un cálculo se inicia mediante la ejecución de una consulta sobre estas relaciones. 

El lenguaje fue concebida por un grupo de alrededor de Alain Colmerauer en Marsella , Francia , a principios de 1970 y el primer sistema Prolog fue desarrollado en 1972 por Colmerauer con Philippe Roussel.

Prolog fue uno de los lenguajes de programación lógica de primera, y sigue siendo el más popular entre dichas lenguas hoy en día, con varias implementaciones libres y comerciales disponibles. El lenguaje se ha utilizado para demostración de teoremas ,  sistemas expertos , la inferencia de tipos de sistemas,  y de planificación automática ,   así como su campo original prevista de uso, procesamiento del lenguaje natural .  Modern Prolog entornos admite la creación de interfaces gráficas de usuario , así como aplicaciones administrativas y en red.

Prolog es muy adecuado para las tareas específicas que se benefician de consultas lógicas basadas en reglas, tales como bases de datos de búsqueda, sistemas de control de voz, y las plantillas de llenado.

4)cual es la relacion entre prolog y logica de predicados

Con las formas mínimas anteriormente descritas se pueden construir las relaciones, base del conocimiento en Prolog.

Ejemplos de relaciones: padre(pepe, maria). // en esta relación se denota una existencia de parentesco entre pepe y maria, prolog en este punto no conoce //quien es el padre de quien, somos nosotros quienes le damos esa interpretación, prolog solamente se encarga de //crear una relación en su base del conocimiento. Obsérvese la sintaxis de la relación descrita: Nótese que los nombres de las personas empiezan por letras minúsculas indicando que son átomos de información y variables.
El nombre de la relación es también un átomo de información y no debe ser una cantidad numérica.
Número de objetos relacionados: sin son cero irán entre paréntesis y si son mas de uno, irán separados por comas. Los hechos terminan siempre en punto. (.)