-------------------Listas-------------------------------------------
Lista
Es una colección o secuencia de elementos o nodos, dispuestos uno detrás del otro, en la que cada
elemento se conecta al siguiente por un enlace o puntero. La lista encadena nodos juntos desde el
frente al final de la lista.

---------------------------------------------------------------------------------------------------
Represente de forma Gráfica una lista
lista ---> pUNTERO (dato) ---> pUNTERO (dato) ---> pUNTERO (dato)
---------------------------------------------------------------------------------------------------
Explique cómo funciona una lista.
Las listas funcionan de una manera flexible ya que no poseen una política, es decir que pueden
adoptar el comportamiento de una cola, de una pila o ninguna, Además su eliminación e inserción
se realizan de manera que no existe un orden.
----------------------------------------------------------------------------------------------------
 Mencione las características de una lista
Es Dinámica , Posee Estructura lineal, Es ordenada y Es Flexible
----------------------------------------------------------------------------------------------------
Mencione y Explique los tipos de Listas
Listas simplemente enlazadas:
Cada nodo contiene un único enlace que conecta ese al nodo siguiente o sucesor.
Listas doblemente enlazadas:
Cada nodo contiene dos enlaces, uno a su nodo predecesor y el otro a su sucesor.
Lista circular simplemente enlazada:
Una lista enlazada simplemente en la que el último elemento se enlaza al primer elemento, de tal
modo que la lista puede ser recorrida de modo circular.
Lista circular doblemente enlazada:
Una lista doblemente enlazada en la que el último elemento se enlaza al primer elemento y
viceversa.
• Para cualquier clasificación de los cuatro tipos de estructura de listas, se puede elegir una
implementación basada en arreglos o una implementación basada en punteros
• Las implementaciones pueden hacerse de forma:
• Fija de memoria basada en arreglos.
• Dinámica de memoria mediante punteros 
-----------------------------------------------------------------------------------------------------
Para recorrer todos los nodos de la lista, se comienza con el primer nodo, es decir el nodo al que
apunta el puntero externo, se toma el valor del campo de enlace, es decir el valor del puntero al
siguiente nodo, para avanzar al segundo nodo, el campo liga del segundo nodo nos dará la dirección
del tercer nodo, y así sucesivamente
-----------------------------------------------------------------------------------------------------
Cuando se agrega un nuevo nodo a una lista, mencione en que consiste esta operación y en
qué posición se puede realizar la inserción.
Esta operación consiste en agregar un nuevo nodo a la lista, definiendo sus datos y su puntero al
siguiente elemento o a NULL en el caso de que se agregue al final.
La posición de inserción puede ser:
1. En la cabeza de la lista
2. Al final de la lista
3. Antes de un nodo de la lista
------------------------------------------------------------------------------------------------------
Después de un nodo de la lista
Al quitar un nodo de una lista, Mencione los casos según el nodo eliminado.
• Caso1: Eliminar el primer nodo.
• Caso 2: Eliminar el último nodo.
• Caso 3: Eliminar un nodo con cierta información
• Caso 4: Eliminar el nodo anterior o posterior al nodo con cierta información
--------------------------------------------------------------------------------------------------------
Mencione en que consiste la operación Buscar en una lista.
Esta operación consiste en visitar cada uno de los nodos, para encontrar algún nodo que
cumpla con un requisito de búsqueda definido al iniciar la búsqueda, tomando el campo
de enlace como puntero al siguiente nodo a visitar, hasta encontrar el nodo que cumpla
con el criterio o hasta terminar de recorrer la lista.
----------------------------------------------------------------------------------------------------------
¿Cuándo se utiliza el puntero NULO?
La palabra NULL representa el puntero nulo que es una constante.
Se puede utilizar el puntero nulo para cualquier valor de puntero que no apunte a ningún
sitio.
Siempre se declara un puntero al primer nodo (cabeza) y un puntero al último nodo (cola)
----------------------------------------------------------------------------------------------------------
1. ¿Qué es un Árbol?
Un árbol consta de un conjunto finito de elementos, llamados nodos y un conjunto finito
de líneas dirigidas, llamadas ramas, que conectan los nodos.
2. ¿Cuáles son las Propiedades de un Árbol?
a. Hay un sólo nodo (raíz), sin ramas incidentes
b. Cada nodo (Excepto la raíz)) recibe una única rama.
c. Todo nodo es accesible desde la raíz.
3. ¿Cómo se puede Representar un Árbol?
a. Anidación de Paréntesis.
b. Notación decimal de Dewey
c. Notación indentada.
d. Representación gráfica
4. ¿Cómo se define el Nivel de un Nodo?
a. El nivel de un nodo es la longitud del camino que lo conecta a la raíz.
5. ¿Cuál es la longitud del camino?
La longitud de un camino es el número de arcos que contiene. (número de nodos-1)
6. ¿Cuál es la profundidad de un árbol?
La profundidad o altura de un árbol es a longitud del camino más largo que conecta la
raíz a una hoja más 1.
7. ¿Cuál es la raíz de un Árbol?
El primer nodo de un árbol, se denomina raíz del árbol
8. ¿Qué es una Rama?
Las fechas que conectan un nodo a otro se llama arcos o ramas.
9. ¿Qué es una Hoja?
Los nodos terminales, se denominan hojas: nodos de donde no se deduce ningún
nodo
10. ¿Cuáles son los tipos de nodo en un Árbol?
a. Raíz
b. Rama
c. Hoja
--------------------------------------------------------------------------------------------------------------
1. ¿Qué es un Árbol Binario?
a. Un árbol binario es un árbol en el que ningún nodo puede tener más de
dos subárboles. En un árbol binario, cada nodo puede tener cero, uno o dos hijos
(Subárboles). Se conoce el nodo de la izquierda como hijo izquierdo y el nodo de la
derecha como hijo derecho.
2. ¿Qué es un Árbol N-ARIO?
a. Los arboles n-arios es una estructura recursiva en la que cada elemento puede tener
cualquier número de subárboles n-arios asociados.
3. ¿A qué se le denomina Árbol lleno?
a. Es aquel que el que todos los nodos tienen cero o 2 hijos con excepción de la Raíz.
4. ¿Qué es un Árbol binario perfecto?
a. Es un Árbol lleno en donde todos las Hojas están en el mismo Nivel
5. ¿Qué es un Árbol de expresión?
a. es una secuencia de token (componentes de léxicos) que siguen unas reglas
prescritas. Un token puede ser un operando o un operador.
6. Listar las propiedades de un Árbol de expresión
1. Cada hoja es un operando.
2. Los nodos raíz e internos son operadores.
3. Los subárboles son sub expresiones en las que el nodo raíz es un operador
7. Listar las reglas para construir Árboles de Expresión.
a. La prioridad se determina sólo por paréntesis.
b. La expresión completa se sitúa entre paréntesis
----------------------------------------------------------------------------------------------------------------
1. Defina que es el recorrido sobre Árboles
Los recorridos son algoritmos que nos permiten recorrer un árbol en un orden
especifico, los recorridos nos pueden ayudar encontrar un nodo en el árbol, o buscar
una posición determinada para insertar o eliminar un nodo.
2. ¿Cómo se catalogan los recorridos de los Arboles?
? Recorrido de un Árbol Binario
? Recorrido de profundidad.
? Recorrido de Anchura.
3. ¿Cuáles son los tres tipos de secuencia de recorrido de un Árbol?
1. Recorrido Preorden
2. Recorrido en Orden
3. Recorrido postorden.
4. Defina el recorrido Preorden
El recorrido inicia en la Raíz y luego se recorre en pre-orden cada unos de los subárboles
de izquierda a derecha
5. Defina el recorrido Posorden
Procesa el nodo raíz después de que los subárboles izquierdo y derecho se hayan
procesado. Comienza situándose en la hoja más a la izquierda y se procesa.
6. Defina el recorrido Inorden
Procesa primero el subárbol izquierdo, después el raíz y, a continuación, el subárbol
derecho.
7. ¿Qué es la búsqueda de Amplitud?
Un árbol binario de búsqueda es aquel en que, dado un nodo, todos los datos del
subárbol izquierdo son menores que los datos de ese nodo, mientras que todos los
datos del subárbol derecho son mayores que sus propios datos
----------------------------------------------------------------------------------------------------------
1. Que es Árbol AVL
Los árboles 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 o viceversa. Gracias a esta forma de equilibrio (o balanceo), la complejidad de
una búsqueda en uno de estos árboles se mantiene siempre en orden de
complejidad O (log n). El factor de equilibrio puede ser almacenado directamente en
cada nodo o ser computado a partir de las alturas de los subárboles.
2. ¿Qué es el Factor de Equilibrio?
Cada nodo, además de la información que se pretende almacenar, debe tener los dos
punteros a los árboles derecho e izquierdo, igual que los árboles binarios de búsqueda
(ABB), y además el dato que controla el factor de equilibrio.
3. Defina las operaciones de un Árbol AVL
? Las operaciones básicas de un árbol AVL implican generalmente el realizar los
mismos algoritmos que serían realizados en un árbol binario de búsqueda
desequilibrado, pero precedido o seguido por una o más de las llamadas "rotaciones
AVL".
i.Insertar
ii.Eliminar
iii.Buscar
4. ¿Qué son Rotaciones?
? El reequilibrado se produce de abajo hacia arriba sobre los nodos en los que se
produce el desequilibrio. Pueden darse dos casos: rotación simple o rotación doble; a
su vez ambos casos pueden ser hacia la derecha o hacia la izquierda.
? Las rotaciones internas en árboles binarios son operaciones internas comunes
utilizadas para mantener el balance perfecto (o casi perfecto del árbol binario). Un
árbol balanceado permite operaciones en tiempo logarítmico.
5. ¿Qué es la ROTACIÓN SIMPLE A LA DERECHA?
De un árbol de raíz (r) y de hijos izquierdo (i) y derecho (d), lo que haremos será
formar un nuevo árbol cuya raíz sea la raíz del hijo izquierdo, como hijo izquierdo
colocamos el hijo izquierdo de i (nuestro i’) y como hijo derecho construimos un nuevo
árbol que tendrá como raíz, la raíz del árbol (r), el hijo derecho de i (d’) será el hijo
izquierdo y el hijo derecho será el hijo derecho del árbol (d).
6. ¿Qué es la ROTACIÓN SIMPLE A LA IZQUIERDA?
De un árbol de raíz (r) y de hijos izquierdo (i) y derecho (d), consiste en formar un nuevo
árbol cuya raíz sea la raíz del hijo derecho, como hijo derecho colocamos el hijo derecho
de d (nuestro d’) y como hijo izquierdo construimos un nuevo árbol que tendrá como
raíz la raíz del árbol (r), el hijo izquierdo de d será el hijo derecho (i’) de r y el hijo
izquierdo será el hijo izquierdo del árbol (i).
7. ¿Qué es la ROTACIÓN DOBLE A LA DERECHA?
La Rotación doble a la Derecha son dos rotaciones simples, primero rotación simple
izquierda y luego rotación simple derecha.
8. ¿Qué es la ROTACIÓN DOBLE A LA IZQUIERDA?
La Rotación doble a la Izquierda son dos rotaciones simples, primero rotación simple
derecha y luego rotación simple izquierda.
9. ¿Qué es la Inserción en un Árbol AVL?
La inserción en un árbol de AVL puede ser realizada insertando el valor dado en el árbol
como si fuera un árbol de búsqueda binario desequilibrado y después retrocediendo
hacia la raíz, rotando sobre cualquier nodo que pueda haberse desequilibrado durante
la inserción.
10. ¿Qué es la Extracción en un Árbol AVL?
El procedimiento de borrado es el mismo que en el caso de árbol binario de búsqueda.
La diferencia se encuentra en el proceso de reequilibrado posterior. El problema de la
extracción puede resolverse en O (log(n)) pasos. Una extracción trae consigo una
disminución de la altura de la rama donde se extrajo y tendrá como efecto un cambio
en el factor de equilibrio del nodo padre de la rama en cuestión, pudiendo necesitarse
una rotación.
¿Qué es un Árbol B?
? Un árbol B de orden p es un árbol n-ario de búsqueda, que cumple las siguientes
propiedades:
i.Raíz del árbol: o bien no tiene hijos o tiene como mínimo 2 y como
máximo p.
ii.Nodos internos: tienen entre ?p/2? y p hijos.
iii.Nodos hoja: todos los nodos hojas deben aparecer al mismo nivel en el árbol
(condición de balanceo).
2. Características de la búsqueda:
? Igual que en los árboles binarios, eligiendo la rama por la que seguir.
? La altura del árbol es ~ logp/2 n, en el peor caso.
3. Como se realiza la Inserción de entradas en un árbol B
? Buscar el nodo hoja donde se debería colocar la entrada.
? Si quedan sitios libres en esa hoja, insertarlo (en el orden adecuado).
? Si no quedan sitios (la hoja tiene p-1 valores) partir la hoja en 2 hojas (con ?(p-1)/2?
y ?(p-1)/2? nodos cada una) y añadir la mediana al nodo padre. Si en el padre
no caben más elementos, repetir recursivamente la partición de las hojas.
4. Cómo se realiza la Eliminación de entradas en un árbol B
? Buscar la clave en el árbol
? Nodo interno (no hoja): Sustituirla por la siguiente (o la anterior) en el orden. Es
decir, por la mayor de la rama izquierda, o la menor de la rama derecha.
? Nodo hoja: Eliminar la entrada de la hoja.
-----------------------------------------------------------------------------------------
5. ¿Qué es un Árbol B+?
? Un árbol B+ es un árbol balanceado, variante especializada del Árbol B que tiene
dos tipos de nodos
i.Internos: Solo apuntan a otros nodos
ii.Externos: Contienen los datos en sí.
--------------------------------------------------------------------------------------------
6. ¿Listar características de los árboles B+?
? Los nodos intermedios tienen como máximo n-1 datos
? Todos los nodos hojas tienen la misma altura
? La información debe estar ordenada.
? Toda la información se encuentra almacenada en los nodos hoja, por lo que en los
nodos internos se pueden duplicar las claves.
Listar las ventajas de Árboles B+
? Automáticamente se reorganiza con cambios pequeños y locales en las inserciones
y borrados. No se requiere la reorganización total del archivo.
? El acceso global es más rápido y la altura media del árbol es menor.
? Las hojas se pueden vincular obteniéndose, de esta forma, una trayectoria
secuencial para recorrer las claves del árbol.
8. Listar las Desventajas de Árboles B+
? Desventajas de los archivos secuenciales indexados: el rendimiento se degrada
según crece el archivo. Esta degradación se resuelve reorganizando el archivo.
? Una degradación al insertar y borrar, y espacio extra.
9. ¿En qué consiste la Inserción en un Árbol B+?
? Su diferencia con el proceso de inserción de árboles B consiste en que cuando se
inserta una nueva clave en una página llena, esta se divide también en otras dos, pero
ahora la primera contendrá con m/2 claves y la segunda 1+m/2, y lo que subirá a la
página antecesora será una copia de la clave central.
10. ¿En qué consiste la operación Eliminación en un Árbol B+?
? La operación de eliminación en árboles B+ es más simple que en árboles B. Esto
ocurre porque las claves a eliminar siempre se encuentran en las páginas hojas. En
general se distinguen dos casos
i.Caso 1: Si al eliminar una clave, la cantidad de llaves queda mayor o igual
que [m/2] entonces termina la operación. Las claves de los nodos raízo
internos no se modifican por más que sean una copia de la clave eliminada
en las hojas
ii.Caso 2: Si al eliminar una clave, la cantidad de llaves queda menor que [m/2]
entonces debe realizarse una redistribución de claves, tanto en el índice
como en las páginas hojas
-----------------------------------------------------------------------------------------
1. ¿Qué es un Grafo?
Un GRAFO es una estructura de datos dinámica que permite representar
diferentes tipos de relaciones entre objetos de manera gráfica.
2. ¿Cómo está formado un Grafo?
Un GRAFO es una estructura de datos dinámica que permite representar
diferentes tipos de relaciones entre objetos de manera gráfica.
-------------------------------------------------------------------------------------------------------
3. Defina un Arco:
Un arco o arista representa una relación entre dos nodos, se representa por (u, v).
------------------------------------------------------------------------------------------
4. ¿Qué es un grafo no dirigido?
El grafo es no dirigido si los arcos están formados por pares de nodos no
ordenados.
-------------------------------------------------------------------------------------------------
5. ¿A qué se le define un Digrafo?
Un grafo es dirigido (digrafo), si los pares de nodos que forman los arcos están
ordenados.
-------------------------------------------------------------------------------------------------
6. ¿Qué es la Adyacencia?
Dado el arco (u, v) de un grafo, se dice que los vértices u y v son adyacentes. Si el
grafo es dirigido, el vértice u es adyacente a v.
--------------------------------------------------------------------------------------------------
7. ¿Que se conoce como Grafo Valorado?
Tipos de grafos que en sus relaciones entre dos nodos tienen asociada una
magnitud denominada factor de peso.
--------------------------------------------------------------------------------------
8. ¿Cuál es el grado de un Grafo?
o En un grafo no dirigido el grado de un nodo v, grado (v), es el número de
arcos que contiene a v.
o En un grafo dirigido podemos distinguir entre grado de entrada y grado de
salida.
-----------------------------------------------------------------------------------------------------
9. ¿Qué es Grado de entrada?
El grado de entrada de un nodo v, es el número de arcos que llegan a v
------------------------------------------------------------------------------------------------------
10. ¿Qué es Grado de Salida?
El grado de salida de un nodo v, es el número de arcos que salen de v.
11. ¿Qué se le conoce como Camino en un Grafo?
o Es la secuencia de vértices por los que se tiene que pasar para moverse
desde un vértice inicial hasta un vértice destino.
o Se pueden encontrar más de un camino entre dos vértices.
o Matemáticamente el camino se representa por P=(v0, v1, v2, … , vn).
12. ¿Qué es la longitud del camino?
o La longitud del camino es el número de arcos que conectan los vértices que
lo forman.
o En un grafo valorado, la longitud del camino con pesos es la suma de los
pesos de los arcos en el camino.
o
13. Defina Grafo Dirigido Acíclico
Tipo de grafo dirigido en donde sus recorridos no relacionan los mismos vértices,
es decir no existen ciclos en sus caminos.
-----------------------------------------------------------------------------------------
#include <stdlib.h>
#include <conio.h>
#include <iostream>
using namespace std;

struct Nodo{
int numCliente;
Nodo *siguiente;	
};
void insertar(Nodo *&, Nodo *&, int);
bool colaVacia(Nodo *);
void eliminar(Nodo *&, Nodo *&, int &);
	
int main()
{
Nodo *inicio = NULL;
Nodo *fin = NULL;
int n, opcion, dato;
cout<<"\n\tMenu del Banco\n1. Introducir cliente a la cola.";
cout<<"\n2. Retirar cliente de la cola.";
cout<<"\n3. Salir.";

do{
cout<<"\n\nIntroduzca una opcion (1-3): ";
cin>>opcion;
// Inicio del switch
switch (opcion){
case 1: 
cout<<"\nDigite el numero del cliente: ";
cin>>dato;
insertar(inicio, fin, dato);
break;

case 2:
if (inicio != NULL){
cout<<"\nEl elemento que sale de la cola: ";
eliminar(inicio, fin, dato);
cout<<dato<<".";
} else{
cout<<"\n\tLa cola esta vacia.\n";
}
break;
} // Fin del switch
} while ( opcion != 3 );
return 0;
}

void insertar(Nodo *&inicio, Nodo *&fin, int n){ //funcion para insertar elementos a la cola.
Nodo *nuevo = new Nodo();
nuevo -> numCliente = n;
nuevo -> siguiente = NULL;
if (colaVacia(inicio)){
inicio = nuevo;
}else{
fin ->siguiente = nuevo;
}
fin = nuevo;
cout<<"ELemento insertado correctamente"<<endl;
}
bool colaVacia(Nodo *inicio){ //funcion que comprueba si la cola esta vacia.
return (inicio == NULL)? true : false;
}
void eliminar(Nodo *&inicio, Nodo *&fin, int &n){ //funcion para eliminar elementos a la cola.
n = inicio -> numCliente;
Nodo *aux = inicio;
if(inicio == fin){
inicio = NULL;
fin = NULL;	
}else{
inicio = inicio -> siguiente;
}
delete aux;
}
-------------------------------------------------------------------------------------------------------------

Lista para determinar mayor y menor
//# include<iostream>
# include<conio.h>
# include<stdlib.h>
using namespace std:
struct Nodo(
int dato:
nodo*siguiente;
):
void insetarLista(Nodo *&,int);
void mostrarLista(Nodo *);
void calcularMayorMenor(Nodo *);
int main(){
Nodo *lista=NULL;
int dato;
char respuesta;
do {//el usuiario define los elementos
cout<<"Digite un numero:";
cin <<dato;
ingresarLista(Lista,dato);
cout<<"Desea agregar otro numero?(s/n): ";
cin <<respuesta;
} while (respuesta=='s' || respuesta=='S' );
cout<<"\n Los Elementos de la lista son: ";
mostrarLista(lista);
calcularMayorMenor(lista)
return 0;
}
void inserLista(Nodo *&lista,n)
 Nodo *nuevo_nodo= new Nodo ();
 Nodo *aux:

//Para rellenar los campos de nuevo nodo
 nuevo_nodo -> dato = n;
 nuevo_nodo -> siguiente = NULL;
 if (lista==NULL){ //INDICA QUE ESTA VACIA LA LISTA

 lista = nuevo_nodo;
}
else {
aux=lista;
while (aux -> siguiente != NULL;
 aux -> aux = siguiente;
}
aux -> aux = nuevo nodo;
}
cout<<"\t El Elemento "<<n<<" ha sido almacenado a la lista con exito\n";
}
}
void mostrarLista(Nodo *lista) {
while (lista != NULL;{
cout<<lista -> dato<<""->";
lista=lista -> siguiente;
}
}
void calcularMayotMenor(Nodo *lista) {
int Mayor=0,memor=99999;
while (lista != NULL;{
if((lista-> dato)>mayor){
mayor=lista-> dato;
}
if if((lista-> dato)>menor){
menor=lista -> dato;
}
lista=lista -> siguiente;
}
cout<<"\t El mayor Elemento es : "<<mayor<<endl;
cout<<"\t El menor Elemento es : "<<menor<<endl;
return 0;
}
---------------------------------------------------------------------------------------------
#include <iostream>
using namespace std;
 
class nodo {
   public:
    nodo(int v, nodo *sig = NULL)
    {
       valor = v;
       siguiente = sig;
    }

   private:
    int valor;
    nodo *siguiente;
        
   friend class lista;
};
 
typedef nodo *pnodo;
 
class lista {
   public:
    lista() { primero = actual = NULL; }
    ~lista();
    
    void Insertar(int v);
    void Borrar(int v);
    bool ListaVacia() { return primero == NULL; } 
    void Mostrar();
    void Siguiente() { if(actual) actual = actual->siguiente; }
    void Primero() { actual = primero; }
    void Ultimo() { Primero(); if(!ListaVacia()) while(actual->siguiente) Siguiente(); }
    bool Actual() { return actual != NULL; }
    int ValorActual() { return actual->valor; }
    
   private:
    pnodo primero;
    pnodo actual;
};
 
lista::~lista() {
   pnodo aux;
   
   while(primero) {
      aux = primero;
      primero = primero->siguiente;
      delete aux;
   }
   actual = NULL;
}

void lista::Insertar(int v) {
   pnodo anterior;
 
   // Si la lista está vacía
   if(ListaVacia() || primero->valor > v) {
      // Asignamos a lista un nuevo nodo de valor v y
      // cuyo siguiente elemento es la lista actual                    
      primero = new nodo(v, primero);
   } else {
      // Buscar el nodo de valor menor a v 
      anterior = primero;
      // Avanzamos hasta el último elemento o hasta que el siguiente tenga 
      // un valor mayor que v 
      while(anterior->siguiente && anterior->siguiente->valor <= v) 
         anterior = anterior->siguiente;
      // Creamos un nuevo nodo después del nodo anterior, y cuyo siguiente
      // es el siguiente del anterior
      anterior->siguiente = new nodo(v, anterior->siguiente);
   }
}

void lista::Borrar(int v) {
   pnodo anterior, nodo;
   
   nodo = primero;
   anterior = NULL;
   while(nodo && nodo->valor < v) {
      anterior = nodo; 
      nodo = nodo->siguiente;
   }
   if(!nodo || nodo->valor != v) return;
   else { // Borrar el nodo 
      if(!anterior) // Primer elemento 
         primero = nodo->siguiente;
      else  // un elemento cualquiera
         anterior->siguiente = nodo->siguiente;
      delete nodo;
   }   
}

void lista::Mostrar() {
   nodo *aux;
   
   aux = primero;
   while(aux) {
      cout << aux->valor << "-> ";
      aux = aux->siguiente;
   }
   cout << endl;
}

int main() {
   lista Lista;
   
   Lista.Insertar(20);
   Lista.Insertar(10);
   Lista.Insertar(40);
   Lista.Insertar(30);

   Lista.Mostrar();

   cout << "Lista de elementos:" << endl;
   Lista.Primero();
   while(Lista.Actual()) {
      cout << Lista.ValorActual() << endl;
      Lista.Siguiente();
   }
   Lista.Primero();
   cout << "Primero: " << Lista.ValorActual() << endl;
   
   Lista.Ultimo();
   cout << "Ultimo: " << Lista.ValorActual() << endl;
   
   Lista.Borrar(10);
   Lista.Borrar(15);
   Lista.Borrar(45);
   Lista.Borrar(30);
   Lista.Borrar(40);
   
   Lista.Mostrar();

   return 0;
}
-----------------------------------------------------------------------------------------------------------------------
#include<iostream>
#include<cstdlib>
#include<string.h>
#define maxchar 50

using namespace std;
struct nodo{

    int codigo;     // campo codigo
    char nombres[maxchar]; // campo que almacena el nombre
    char apellidos[maxchar];// campo que almacena el apellido
    char direccion[maxchar];// campo que almacena la direccion
    int telefono;// campo que almacena el telefono
    struct nodo *sgte;

};
typedef struct nodo *PLista;
/*--------------------- FUNCION MENU PRINCIPAL --------------------*/
void menu(void){

    cout<<"\n\t\t[    REGISTRO DE PACIENTES    ]\n";
    cout<<"\t\t----------------------------\n\n";
    cout<<" 1. REGISTRAR PACIENTE                          "<<endl;
    cout<<" 2. ELIMINAR DATOS DE PACIENTE                  "<<endl;
    cout<<" 4. MOSTRAR LISTADO                             "<<endl;
    cout<<" 5. COPIAR DATOS DE UN PACIENTE A OTRO          "<<endl;
    cout<<" 6. SALIR                                       "<<endl;
    cout<<"\n Ingrese opcion : ";
}
/*-------------------- FUNCION REGISTRAR PACIENTES ------------------*/
void registrar_pacientes(PLista &lista){
    PLista t,q = new(struct nodo);
    cout<<"\n\n\t\t[  REGISTRO  ]\n";
    cout<<"\t\t------------";
    cout<<"\n\tDATOS DEL PACIENTE ";
    cin.ignore();cout<<"\n\n\tCODIGO:"; cin>>q->codigo;
    cin.ignore();cout<<"\n\tNOMBRES:"; cin.getline(q->nombres,maxchar);
    cin.ignore();cout<<"\tAPELLIDOS:"; cin.getline(q->apellidos,maxchar);
    cin.ignore();cout<<"\tDIRECCION:"; cin.getline(q->direccion,maxchar);
    cin.ignore();cout<<"\n\tTELEFONO:"; cin>>q->telefono;
    system("cls");
    q->sgte = NULL;
    if(lista==NULL){
        lista = q;
    } else {
        t = lista;
        while(t->sgte!=NULL){
                t = t->sgte;
        }
        t->sgte = q;
    }
}

/*------------------------ FUNCION ELIMINAR PACIENTE ---------------------*/
void eliminar_paciente(PLista &lista){

    int cod;
    PLista q,t;
    q=lista;

    cout<<"\n\n\n\tELIMINAR UN PACIENTE";
    cout<<"\n\n\tINGRESE CODIGO:"; cin>>cod;

    while(q!=NULL){

            if(q->codigo==cod){

                if(q==lista)
                    lista=lista->sgte;

                else
                    t->sgte=q->sgte;

                delete(q);

                cout<<"\n\n\tREGISTRO ELIMINADO...!!!!!\n";

                return;

            }else {

                t=q;
                q=q->sgte;

        }

    }
    if(q==NULL)
        cout<<"\n\tCODIGO INCORRECTO...!!\n";

}
/*---------------------- FUNCION MOSTRAR PACIENTE -------------------*/
void mostrar_pacientes(PLista q){

    int i=1;

    while(q!=NULL){

        cout<<"\n\tDATOS DEL PACIENTE ["<<i<<"] ";
        cout<<"\n\t------------------------";
        cout<<"\n\n\tCODIGO   : "<<q->codigo<<endl;
        cout<<"\n\tNOMBRES  : "<<q->nombres<<endl;
        cout<<"\tAPELLIDOS: "<<q->apellidos<<endl;
        cout<<"\tDIRECCION: "<<q->direccion<<endl;
        cout<<"\tTELEFONO : "<<q->telefono<<endl;

        q=q->sgte;

        i++;
    }

}
/*------------------------- FUNCION PRINCIPAL -------------------*/
int main(void){

   // system("color 0a");

    PLista lista=NULL;

    int opcion;

    do{
            menu();
            cin>>opcion;

            switch(opcion){

                case 1: registrar_pacientes(lista);
                        break;

                case 2: if(lista==NULL){

                            cout<"\n\tNo Hay Pacientes Registrados.....!!!!\n";

                        }else{

                            eliminar_paciente(lista);

                        }
                        break;

                case 4: if(lista==NULL){

                            cout<"\n\tNo Hay Pacientes Registrados.....!!!!\n";

                        }else {

                            mostrar_pacientes(lista);

                        }
                        break;

                case 6: return 0;


                default: cout<<"\nINGRESE UNA OPCION VALIDA...\n"; break;

            }

            system("pause");  system("cls");

        }while(opcion!=6);

    system("pause");

    return 0;
}
-------------------------------------------------------------------------------------------------------------------------------
arbol
#include <iostream>
#include <cstdlib>
using namespace std;

struct nodo{
     int nro;
     struct nodo *izq, *der;
};

typedef struct nodo *ABB;
/* es un puntero de tipo nodo que hemos llamado ABB, que ulitizaremos
   para mayor facilidad de creacion de variables */

ABB crearNodo(int x)
{
     ABB nuevoNodo = new(struct nodo);
     nuevoNodo->nro = x;
     nuevoNodo->izq = NULL;
     nuevoNodo->der = NULL;

     return nuevoNodo;
}
void insertar(ABB &arbol, int x)
{
     if(arbol==NULL)
     {
           arbol = crearNodo(x);
     }
     else if(x < arbol->nro)
          insertar(arbol->izq, x);
     else if(x > arbol->nro)
          insertar(arbol->der, x);
}

void preOrden(ABB arbol)
{
     if(arbol!=NULL)
     {
          cout << arbol->nro <<" ";
          preOrden(arbol->izq);
          preOrden(arbol->der);
     }
}

void enOrden(ABB arbol)
{
     if(arbol!=NULL)
     {
          enOrden(arbol->izq);
          cout << arbol->nro << " ";
          enOrden(arbol->der);
     }
}

void postOrden(ABB arbol)
{
     if(arbol!=NULL)
     {
          postOrden(arbol->izq);
          postOrden(arbol->der);
          cout << arbol->nro << " ";
     }
}

void verArbol(ABB arbol, int n)
{
     if(arbol==NULL)
          return;
     verArbol(arbol->der, n+1);

     for(int i=0; i<n; i++)
         cout<<"   ";

     cout<< arbol->nro <<endl;

     verArbol(arbol->izq, n+1);
}

int main()
{
    ABB arbol = NULL;   // creado Arbol

    int n;  // numero de nodos del arbol
    int x; // elemento a insertar en cada nodo

    cout << "\n\t\t  ..[ ARBOL BINARIO DE BUSQUEDA ]..  \n\n";

    cout << " Numero de nodos del arbol:  ";
    cin >> n;
    cout << endl;

    for(int i=0; i<n; i++)
    {
        cout << " Numero del nodo " << i+1 << ": ";
        cin >> x;
        insertar( arbol, x);
    }

    cout << "\n Mostrando ABB \n\n";
    verArbol( arbol, 0);

    cout << "\n Recorridos del ABB";

    cout << "\n\n En orden   :  ";   enOrden(arbol);
    cout << "\n\n Pre Orden  :  ";   preOrden(arbol);
    cout << "\n\n Post Orden :  ";   postOrden(arbol);

    cout << endl << endl;

    system("pause");
    return 0;
}
------------------------------------------------------------------------------------------------------------------------------------------