1
NOMBRE DEL ALUMNO: FRANCISCO DUEÑAS MONSIVAIS
NUMERO DE CUENTA: 10199034
MATERIA: ESTRUCTURA DE DATOS
PROFESOR: DULCE ANGELICA SALAS SALINAS
FECHA DE LA ACTIVIDAD: 02/12/18
TITULO DE LA ACTIVIDAD: ENTREGABLE 2
Cuestionario 2 Estructuras de datos
2
CUESTIONARIO 2
A. Complete los espacios en azul del siguiente cuadro sinóptico relacionado con
los métodos(o algoritmos) de búsqueda más comunes:
Método de búsqueda Describa en qué consiste Ejemplo de código en C++
donde se utilice el método
de búsqueda
Búsqueda secuencial Nos permitirá recorrer una //Librerias #include
lista o un arreglo desde el "stdafx.h" #include using
inicio hasta el fin y para namespace std; int main() {
hasta que se pueda //Declarando variables. int
encontrar el elemento clave,encontrado, n, i, j;
buscado o que se arribe el //Pedir tamaño del arreglo.
final de la estructura, lo cual cout << "Ingrese dimensión
indicará que no se ha del arreglo: "; cin >> n;
encontrado nada Cout<< n;i++) { cout <<
"Ingrese dato [" << i << "]: ";
cin >> arreglo[i]; } //Pedir
dato o clave a buscar. cout
<< "Ingrese dato que desea
buscar: " << endl; cin >>
clave; //Declarar variable de
éxito de búsqueda.
encontrado = 0; //Buscar
clave o dato en el arreglo.
for (j = 0;j < n;j++) { //Si el
elemento de la posición
actual del arreglo es similar
a la clave de búsqueda,
despliega mensaje de
encontrado. if (arreglo[j] ==
clave) { 6 cout << "Se
encontro el " << clave << "
en la posicion [" << j << "]"
<< endl; encontrado = 1; } }
//Libera arreglo dinámico en
memoria. delete[] arreglo;
//Si no se encontró la clave
despliega el mensaje de no
Cuestionario 2 Estructuras de datos
3
encontrado. if (encontrado
!= 1) cout << "No se
encontro el dato" << endl;
system("pause"); return 0; }
Búsqueda Binaria Consiste en realizar una //Librerias #include
búsqueda de un arreglo "stdafx.h" #include using
mas eficiente de números el namespace std; int main() {
cual sin embargo debe //Declarando variables. int
estar ordenado de manera clave,encontrado, n, i, j;
ascendente para que //Pedir tamaño del arreglo.
funcione cout << "Ingrese dimensión
del arreglo: "; cin >> n;
Cout<< n;i++) { cout <<
"Ingrese dato [" << i << "]: ";
cin >> arreglo[i]; } //Pedir
dato o clave a buscar. cout
<< "Ingrese dato que desea
buscar: " << endl; cin >>
clave; //Declarar variable de
éxito de búsqueda.
encontrado = 0; //Buscar
clave o dato en el arreglo.
for (j = 0;j < n;j++) { //Si el
elemento de la posición
actual del arreglo es similar
a la clave de búsqueda,
despliega mensaje de
encontrado. if (arreglo[j] ==
clave) { 6 cout << "Se
encontro el " << clave << "
en la posicion [" << j << "]"
<< endl; encontrado = 1; } }
//Libera arreglo dinámico en
memoria. delete[] arreglo;
//Si no se encontró la clave
despliega el mensaje de no
encontrado. if (encontrado
!= 1) cout << "No se
encontro el dato" << endl;
system("pause"); return 0; }
Cuestionario 2 Estructuras de datos
4
B. Investigue un ejemplo de código en C++ que haga uso de PILAS e inclúyalo
a continuación (diferente al ejemplo mostrado en el Programa14_Pilas):
#include "iostream.h"
// Pila hecha con un vector fijo de 50 posiciones
class Pila {
int vector[50];
// indicePila: -1 -> pila vacia 0 -> posicion del dato
int indicePila;
public:
Pila() { indicePila = -1; }; // constructor
// funciones analizadoras
void mostrarDatos();
int cuantosDatos();
// funciones modificadoras
void entrarDato(int dato);
int sacarDato();
};
// Esta función sale del cuerpo de la clase porque usa un ciclo.
void Pila::mostrarDatos() {
cout << endl << "DATOS EN LA PILA" << endl;
for (int i=0; i<=indicePila; i++)
cout << "Dato No. " << i << " : " << vector[i] << endl;
cout << endl;
}
int Pila::cuantosDatos() {
return indicePila + 1;
}
void Pila::entrarDato(int dato) {
if (indicePila < 49) {
indicePila ++;
vector[indicePila] = dato;
} else
cout << "Pila desbordada: no se añadio valor" << endl;
}
int Pila::sacarDato() {
if (indicePila > -1) {
Cuestionario 2 Estructuras de datos
5
indicePila --;
return vector[indicePila + 1];
}
return -1;
}
Hay que notar que todas las funciones con excepción del constructor se sacaron del
cuerpo de la clase y su nombre se resolvió usando los dos pares de dos puntos::. Esto
permite implementar una función miembro por fuera del cuerpo de la clase.
De esta forma por ejemplo, la función que dentro del cuerpo de la clase se llama:
void entrarDato(int dato);
Afuera del cuerpo de la clase se llama
void Pila::entrarDato(int dato) {
Esa es la misma función solo que el primero es el prototipo que se le pasa a la clase para
que sepa que hay una función con ese nombre que será implementada más adelante.
Ahora hace falta un cuerpo del programa o main que sepa como manejar esta estructura.
Para eso implementaremos una función menú que se encargará de pedir al usuario que
indique cual función desea ejecutar, usando una estructura while.
Se ha creado una función adicional que maneja el menú:
int menu() {
cout << endl << endl;
cout << "Bienvenido al programa manejador de Pila de enteros" << endl;
cout << "Escoja una opción" << endl;
cout << "**************************************" << endl;
cout << "0. Salir del Programa" << endl;
cout << "1. Adicionar entero" << endl;
cout << "2. Sacar entero" << endl;
cout << "3. Ver cuantos datos tiene la pila" << endl;
cout << "4. Mostrar datos en la pila" << endl;
cout << "**************************************" << endl;
int opcion;
cin >> opcion;
return opcion;
}
main () {
Pila pila1;
Cuestionario 2 Estructuras de datos
6
int respuesta,opcion;
opcion = -1;
while (opcion != 0) {
opcion = menu();
switch (opcion) {
case 0:
cout << "Gracias por usar nuestro software" << endl;
break;
case 1:
cout << "indique valor a entrar:";
cin >> respuesta;
pila1.entrarDato(respuesta);
break;
case 2:
cout << "Dato obtenido:" << pila1.sacarDato() << endl;
break;
case 3:
cout << "Hay " << pila1.cuantosDatos() << " en la pila" << endl;
break;
case 4:
pila1.mostrarDatos();
}
}
return 0;
}
El programa completo será obviamente la parte que define e implementa la clase con la
segunda que usa la función menú y el main.
El switch es usado para atender cada una de las opciones que son ofrecidas al usuario en
el menú
Explique para qué sirve y cómo funciona el código del inciso B. Si hay comandos
nuevos investíguelos e incluya una descripción de su funcionamiento:
Cuestionario 2 Estructuras de datos
7
Vamos a crear una clase llamada Pila que manejará una estructura de este tipo a través
de una clase. La definición inicial será así:
#include "iostream.h"
class Pila {
int vector[50];
public:
Pila() { }
}
Pero en este caso al crear este objeto no hace nada porque el constructor está vacío y no
hay forma de llegar a su vector interno.
Las estructuras tienen funciones que se agrupan funcionalmente de la siguiente forma.
Constructores
Destructores
Funciones analizadoras: que permiten observar los datos
Funciones modificadoras: que modifican la estructura
Para una pila entonces deberemos tener un constructor, funciones de análisis
(mostrarDatos,verPrimerValor), y modificadoras (entrarDato,sacarDato). Como no
usaremos apuntadores la función destructora no será necesaria.
Es necesario recordar que en la pila el dato que sale fue el último que se metio en la
estructura.
Para la pila se usará un vector estático de 50 posiciones y un índice que se encargará de
indicar donde está la cabeza de la pila. Cuando indicePila sea -1, la pila estará vacía.
Cuando sea 0, indicará que en la pila hay un dato en la posición 0, y así sucesivamente.
C. Investigue un ejemplo de código en C++ que haga uso de COLAS e
inclúyalo a continuación(diferente al ejemplo mostrado en el
Programa15_Colas):
#include<stdio.h>
#include<stdlib.h>
Typedef int tipodato;
Struct nodo
{
Tipodato el;
Struct nodo* sig;
};
Typedef struct
Cuestionario 2 Estructuras de datos
8
}
Nodo* frente;
Nodo * final;
}cola;
Void vaciaC(cola* C);
Void añadeC(cola* C. tipodato el);
Void eliminarC(cola*C);
Void borrarC(cola* C);
Tipodato primeroC (cola C);
Int esvaciaC(cola C);
Nodo* crearnodo(tipodato el);
Void vaciarC(cola* C)
{
C->frente = null;
C->final = null;
}
Nodo*crearnodo(tipodato el)
{
Nodo* nn;
Nn = (nodo*) malloc(sizeof(nodo));
nn->el = el;
nn->sig = null;
return nn;}
int esvaciaC(Cola C)
return (C.frente == null);
}
Voyd añadeC(cola* C,tipodato el)
{
Nodo* a;
A = crearnodo(el);
If (esvaciaC(*C))
C->frente = a;
Else
C->final->sig = a;
C->final = a;
}
Void borrarC(cola*C)
{
Nodo *a;
If (esvaciaC(*C))
{
A = C->frente;
Cuestionario 2 Estructuras de datos
9
C->frente = C->frente->sig;
If(C->frente == null)
C->final ==null;
Free(a);
}
Else
{
Puts(“error eliminacion de una cola vacia”);
Exit(-1);
}
}
Topodato primeroC(cola C)
{
If (esvaciaC(C))
{
Puts(“error: cola vacia”);
Exit(-1);
}
Return (C.frente->el);
}
Void eliminaC(Cola* C)
{
For (;C->frente;)
{
Nodo* n;
N =C->frente;
C->frente = C->frente->sig;
Free(n);
}
}
D. Explique para qué sirve y cómo funciona el código del inciso D. Si hay
comandos nuevos investíguelos e incluya también su descripción.
Se declaran en primer lugar todos los tipos de datos necesarios para una lista enlazada.
Una cola será una estructura con dos punteros a la lista frente que apuntara al primer
elemento de la cola y final que apuntara al último elemento.
• VaciarC. Crea una cola vacia, para lo cual basta con poner en frente y el final a null.
• EsvaciaC. Decide si la cola esta vacía. Es decir si frente y final valen null
• EstallenaC. Esta función no es ahora necesaria ya que teóricamente no hay límite.
• PrimeroC. Extrae el primer elemento de la cola que se encuentra en el nodo frente.
Cuestionario 2 Estructuras de datos
10
Previamente a esta operación ha de comprobarse que la cola no este vacia.
• AñadeC. Añade un elemento a la cola.este elemento se añade en un nuevo nodo que
será el siguiente de final en el caso de que la cola no este vacia. Si la cola esta vacia el
frente debe apuntar a este nuevo nodo. En todo caso el final siempre debe moverse al
nuevo nodo.
• BorrarC. Elimina el primer elemento de la cola. Para hacer esta operación la cola no debe
estar vacia. El borrado se realiza avanzando frente al nodo siguiente y liberando la
memoria correspondiente .
• EliminarC. Esta primitiva libera toda la memoria que tenga una cola ya creada. Se realiza
mediante un bucle controlado por el final de la lista. Liberando la memoria ocupada por
cada nodo en cada una de las interacciones del bucle
Bibliografía
https://www.programacion.com.py/escritorio/c/colas-en-c
fuente consultada el 02 de diciembre de 2018.
http://arbolescolaspilas.blogspot.com/2012/07/programacion-pilas.html
fuente consultada el 02 de diciembre de 2018.
https://www.programacion.com.py/escritorio/c/pilas-en-c
fuente consultada el 02 de diciembre de 2018.
Cuestionario 2 Estructuras de datos
