1.

Algoritmos de cadena

1.1. Bsqueda lineal o secuencial

Supongamos una coleccin de registros organizados como una lista

lineal. El algoritmo bsico de bsqueda secuencial consiste en empezar
al inicio de la lista e ir a travs de cada registro hasta encontrar la llave
indicada (k), o hasta al final de la lista.

Posicin = 0;
while posicin < tamao {
if vector[posicin] == dato {
Retorna verdadero y/o posicin;q
} else {
Posicin = posicin +1;
}
}

1.2. Bsqueda binaria o dicotmica

Se utiliza cuando el vector en el que queremos determinar la existencia
de un elemento est previamente ordenado. Este algoritmo reduce el
tiempo de bsqueda considerablemente, ya que disminuye
exponencialmente el nmero de iteraciones necesarias. En el peor de los
casos el nmero mximo de comparaciones es {\textstyle \lfloor \log
_{2}n+1\rfloor } {\textstyle \lfloor \log _{2}n+1\rfloor }, donde
{\displaystyle n} n es el nmero de los elementos en el vector. Por
ejemplo, en uno conteniendo 50.000.000 elementos, el algoritmo realiza
como mximo 26 comparaciones.

Datos de entrada:
vec: vector en el que se desea buscar el dato
tam: tamao del vector. Los subndices vlidos van desde 0 hasta
tam-1 inclusive.
dato: elemento que se quiere buscar.

Variables
centro: subndice central del intervalo
inf: lmite inferior del intervalo
sup: lmite superior del intervalo

inf = 0
sup = tam-1

Mientras inf <= sup:

centro = ((sup - inf) / 2) + inf // Divisin entera: se trunca la
fraccin
Si vec[centro] == dato devolver verdadero y/o pos, de lo contrario:
Si dato < vec[centro] entonces:
sup = centro - 1
En caso contrario:
inf = centro + 1
Fin (Mientras)
Devolver Falso

//busqueda_binaria.c
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
int BusquedaBinaria(int datos[], int nelem, int clave);
int main()
{
int *pdatos, nelem, dbuscar,d,result;

printf("Cuantos elementos desea en el array? ");

scanf("%d",&nelem);
pdatos= (int *) malloc(nelem * sizeof(int));
if(pdatos==NULL)
{
printf("Insuficiente Espacio de Memoria");
exit(-1);
}

for(d=0; d < nelem;d++)

{
printf("Elemento[%d]: ",d);
scanf("%d",(pdatos+d));
}
printf("\nQue elemento desea buscar?");
scanf("%d",&dbuscar);
//Llamada a la Funcin que realiza la bsqueda
result = BusquedaBinaria(pdatos,nelem,dbuscar);
if (result != -1)
printf ("\n%d SE ENCUENTRA EN LA POSICION %d DEL
ARRAY\n",dbuscar,result);
else
printf ("\n %d NO SE ENCUENTRO\n",dbuscar);
}

int BusquedaBinaria(int lista[], int n, int clave)

{
int central, bajo, alto;
int valorCentral;
bajo = 0;
alto = n-1;

while (bajo <= alto)

{
central = (bajo+alto)/2; /* ndice de elemento central */
 valorCentral = lista[central]; /* valor del ndice central
*/

if (clave == valorCentral)
return (central); /* encontrado, devuelve posicin */
else if (clave < valorCentral)
alto = central-1; /* ir a sublista inferior */
else
bajo = central+1; /* ir a sublista superior */
}
return (-1); /* elemento no encontrado */
}

2. Algoritmos de grados
2.1. Pilas
2.1.1.crear
2.1.2.insertar
2.1.3.mostrar
2.1.4.eliminar

/********************** Pilas *********************/

// Referencia https://www.youtube.com/watch?v=7JTUaKIe7A8
// 1 Definir una estructura de cada uno de los elementos que componen
la pla.

typedef struct{
struct elemento* siguiente; //Este componente nos dira cualserael
proximo elemento para hacer una extraccin (Este elemento es el que
se convertir en la cima de esa pila)
char* nombre; // Este elemento nos va a servir para obtener el
nombre del elemento de la pila
} elemento;

// 2 Creamos el puntero que dirija al ultimo elemento.

elemento* ultimo = NULL;

// 3 Funcion para agregar a una pila que recibe como parametro un

puntero a un elemento PUSH
void agregar (elemento* _elemento){
_elemento -> siguiente = NULL; //INICIALIZAMOS LA VARIABLE
// Si la pila esta vacia
if (ultimo == NULL){ // 3.1 Verificamos si la pila esta vacia
 ultimo = _elemento;
} else { // si la pila no esta vacia
_elemeto -> siguiente = ultimo;
ultimo = elemento;
}
}

// 4 Extraer un elemento de una pila POP

// 4.1 Crear funcion que retorna un elemento a un puntero y no recibe
ningun parametro
elemento* extraer (){
// 4.2 verificar si la pila no esta vacia
if (ultimo == NULL){
return NULL;
} else {
elemento* elemento_retorno = ultimo; // Agregamos un
puntero que se llama puntero retorno el cual estar en el ltimo
ultimo = elemento_retorno -> siguiente; // no vamos al
elemento siguiente de la pila es decir el que esta en la cima ya no lo
apuntamos y apuntamos el que sigue
return elemento_retorno; // y retornamos el
elemento_retorno para posteriormente liberarlo de la memoria ram
}
}

int main(){
// 4.3 Vamoa poner cuatro punteros de tipo elemento, en el cual
utilizaremos la funcion malloc para almacenar en la memoria heap los
elementos
elemento* librouno = malloc(sizeof(elemento));
elemento* librodos = malloc(sizeof(elemento));
elemento* librotres = malloc(sizeof(elemento));
elemento* librocuatro = malloc(sizeof(elemento));

// 4.4 a cada uno de estos elementos le pondremos un nombre

librouno->nombre = "Titulo del libro uno";
librodos->nombre = "Titulo del libro dos";
librotres->nombre = "Titulo del libro tres";
librocuatro->nombre = "Titulo del libro cuatro";

// 4.5 Vamos a agregar un elemento

agregar(librouno);
agregar(librodos);
agregar(librotres);
agregar(librocuatro);
 elemento* i = extraer();

while(i != NULL){
printf("%s\n", i);
i = extraer();

return 0;
};

2.2. Colas
2.2.1.crear
2.2.2.insertar
2.2.3.mostrar
2.2.4.eliminar

// Simularemos una cola de pedidos en el cual solo procesaremos un

pedido a la vez
#include<stio.h>
#include<iostream.h>
//1.- Creamos un tipo
typedef struct NodoPedido{
Pedido*pedido;
struct NodoPedido*siguiente;
} NodoPedido;

/* Archivo TAD Cola Dinamica*/

#include <iostream>
#define null 0

using namespace std;

typedef int tipo_elemento;
typedef enum{FALSE=0, TRUE=1} boolean;

class Nodo{
public:
tipo_elemento dato;
Nodo *sig;
};

class Cola{
private:
Nodo *frente, *final;
public:
void insertar(tipo_elemento elemento);
tipo_elemento quitar();
boolean colaVacia();
Cola(){
frente=null;
final=null;
};
};

void Cola::insertar(tipo_elemento elemento){

Nodo *nuevo;
nuevo = new Nodo;
(*nuevo).dato=elemento;
(*nuevo).sig=null;
if (final==0){
frente=nuevo;
final=nuevo;
}
else{
(*final).sig=nuevo;
final=nuevo;
}
}

tipo_elemento Cola::quitar(){
tipo_elemento item;
item = (*frente).dato;
frente=(*frente).sig;
return item;
}

boolean Cola::colaVacia(){
return boolean(frente==null);
}

int main(){
int x=0;
Cola cola;

puts("Insercion de los elementos: \n");

for(x=1;x<6;x++){
//if (!cola.colaLlena()){
cola.insertar(x*2);
/*}else{
cout << "No se puden ingresar mas datos.\n";
x=11;
}*/
}
puts("Lista de elementos: \n");
for(x=1;x<6;x++){
if (!cola.colaVacia()){
cout << "Elemento en la posicion " << x << " es: " <<
cola.quitar() << "\n";
}else
x=11;
}

system("pause");
return 0;
}

2.3. Listas (Referencia)

http://listaencpasoapaso.blogspot.mx/
2.3.1.crear
2.3.2.insertar
2.3.3.mostrar
2.3.4.eliminar
Hola que tal amigos.

Hace unos das me mandaron a investigar el tema de lista en C++, estoy estudiando estructura de
datos pues en internet encontre informacion muy desorganizada prcticamente no entendi nada
como de las 3000 palabras que lei.

Bueno en este post les dare las bases firmes para que podais hacer el programa mas bacico de
programar listas en C++

Nota = Este programa esta echo bajo el compilador de DEV-CPP

Nota: El codigo esta desarrollado en C++ y hace parte de la programacion estructurada. Esto
quiere decir que no trabajamos con clases (como en programacion orientada a objetos) si no con
estructuras que es el ambiente de la programacion estructurada.

Asi que sigamos:

1)Lo primero hacer es mirar como se construye grficamente una lista en c++:

Para ello podis ver el siguiente vdeo por que yo solo te dar el cdigo pertinente a la creacin de
una lista simplemente encadenada en C++.
 Este vdeo te explica como crear el primer nodo y luego si ir creando los nodos siguientes pero a
modo de explicacin graficamente.

2)Ya aprendido la parte logica o el funcionamiento grafico de lo que es una lista entonces
procedere a ir revelando paso por paso cada linea de codigo que debeis poner en tu compilador
para crear una lista en c++.

1. Lo primero que debemos hacer es declarar las dos librerias necesarias para el proposito=

#include<iostream>
#include<stdlib.h>

Listo luego declaramos la estructura o el estruct donde vamos a guardar los nodo=

struct nodo{
int info; // En la variable info guardaremos el contenido de los nodos.
struct nodo *sgt; // El puntero siguiente sera para crear los nodos de la lista.
};

Si hasta aqu no as entendido tranquilo sigue leyendo.

Bueno seguimos como el main()

En le main declaramos los dos punteros que nos van a servir en la creacion de los nodos:
 struct nodo *cabe; // este para la cabeza del nodo
struct nodo *nuevo; //este para los nuevos nodos que se creen.

Procedemos a declarar la cabeza como NULL

cabe=NULL;

Este valor de Null lo abras visto en el video por lo tanto ya sabras para que sirve.
Importante si no declaras la cabeza del nodo como NULL posiblemente obtendras un error
en tiempo de ejecucion

Ahora vamos a declarar tres variables tipo entero que nos ayudaran en la creacin de
nodos.

int dato; // Esta variable para almacenar los datos que se le vallan a introducir a los
nodos.
int i=1; //Esta es la variable del contador para crear los nodos.
int cant; //Esta para la cantidad de nodos que el usuario desee.

Ahora imprimimos un mensaje para pedir la cantidad de nodos que desea el usuario=

cout<<"Entrar cantidad de nodos=";

cin>>cant;

Como viste ya aviamos declarado la variable "cant" que es la que nos permite saber cuantos nodos
desea el usuario.

Ahora vamos a realizar el proceso mas engorroso y que requiere la mayo atencin posible,
por favor pon atencin en cada paso de esto porque son lo mas vitales.

1. Abrimos un ciclo while que yegara hasta donde lo especifico el usuario con la sentencia
anterior escrita.
Este ciclo while dependera de dos variables las variables i y cant anteriormente declaradas
 La variable cant es el final del ciclo por ejemplo si la variable cant contiene el valor de 5
entonces este sera el numero de repeticiones del ciclo o mejor dicho sera la cantidad de vueltas
que dara el ciclo.

Con esta variable controlamos los nodos que vamos a crear.

while(i<=cant){ //Aqui se inicia el ciclo while.

nuevo=(struct nodo *)malloc(sizeof(struct nodo)); //Crea un nodo nuevo
nuevo->sgt=cabe;
cout<<"Entre dato=";
cin>>dato;
nuevo->info=dato;
cabe=nuevo;
i++;
}

Especificare las lineas que he creado en el ciclo=

nuevo=(struct nodo *)malloc(sizeof(struct nodo)); = esta linease usa para crear el nuevo
nodo que vamos a usar en la primera vuelta del ciclo.
La parte de (struct nodo *)malloc(sizeof(struct nodo)) se usa para asignar memoria
dinamicamente cuando se este ejecutando el programa.

nuevo->sgt=cabe; = Esta linea es para que el nuevo nodo se le el valor de cabeza. Y asi ir
creando los demas nodos de forma ordenada. Importante ver video para mirar graficamente este
proceso donde el enlace del nodo original pasa al enlace del nodo nuevo.
Entonces el nodo original pasa a ser el nodo de atras como en el video. Y el nuevo nodo
pasa a ser el primero, y asi sucesivamente en la repeticion del ciclo.

cout<<"Entre dato=";
cin>>dato;
Aqui solicitamos los datos que vamos a entrar en el nuevo nodo.

nuevo->info=dato; Entonces ahora hacemos que la informacion pedida anteriormente

pase a la variable "info" que sera el contenido del nodo nuevo.
 cabe=nuevo; aqui damos al apuntador cabeza la direccion de nuevo quedando asi el
apuntador cabeza que apuntaba a el nodo original, apuntando al nodo nuevo.

Ahora procedemos a imprimir los nodos con la siguientes linea.

while(nuevo!=NULL){ //El apuntador nodo ira siguiendo los nodos ya para hasta encontrar NULL
cout<<"\nDATO="<<nuevo->puntos; //Imprimimos los datos de cada nodo
nuevo=nuevo->sgt; //Importante y no olivadar con esta sentencia corremos el apuntador al
siguiente
} //nodo
system("pause>>null");
}

Listo hasta aqu el programa mas fcil y entendible de listas en C++.

Ahora te dejo el cdigo completo y sin alteraciones para que lo ejecutes y pruebes.
=

#include<iostream>
#include<stdlib.h>
using namespace std;
//*******************************
struct nodo{
int info;
struct nodo *sgt;
};
//************************************
main(){
struct nodo *cabe;
struct nodo *nuevo;
struct nodo *aux;
cabe=NULL;
int dato;
int cant, i=1, cont;
cout<<"Entrar cantidad de nodos=";cin>>cant;
while(i<=cant){
nuevo=(struct nodo *)malloc(sizeof(struct nodo));
nuevo->sgt=cabe;
cout<<"Entre dato=";
cin>>dato;
nuevo->info=dato;
cabe=nuevo;
 i++;
}

while(nuevo!=NULL){
cout<<"\nDATO="<<nuevo->info;
nuevo=nuevo->sgt;
}

system("pause>>null");
}