Proyecto​ ​Final

David​ ​Hernán​ ​Torres​ ​Antiquera

Estructura​ ​de​ ​Datos

Instituto​ ​IACC

05​ ​de​ ​noviembre​ ​de​ ​2016

 Desarrollo

Utilizando DStool: Herramienta para la programación con estructuras de datos o una herramienta
similar​ ​realice​ ​las​ ​siguientes​ ​actividades.

1. Construya la siguiente lista enlazada de 10 nodos (5, 8, 2, 3, 23, 12, 34, 32, 11, 17) e
indicar​ ​claramente​ ​que​ ​sucede​ ​con​ ​la​ ​lista​ ​cuando:
a. Se​ ​elimina​ ​el​ ​nodo​ ​23
b. Se​ ​inserta​ ​el​ ​nodo​ ​7​ ​entre​ ​el​ ​nodo​ ​34​ ​y​ ​32

Para dar respuesta a la primera pregunta primero debemos confeccionar nuestra lista enlazada la
cual fue dada anteriormente y mediante la herramienta DStool lo graficaremos, en la cual nuestra
lista​ ​queda​ ​de​ ​la​ ​siguiente​ ​manera:

en la siguiente imagen muestra como queda nuestra lista enlazada, en donde si nos damos cuenta
nuestro nodo de inicio el nodo con valor 5, donde luego se comienza con insertar los demás
nodos, pero estos se van desplazando hacia la derecha haciendo que el último nodo de la lista sea
el nodo con valor 8, entonces nuestra lista queda en el siguiente orden: 5, 17, 11, 32, 34, 12, 23,
3,​ ​8.
Eliminar​ ​el​ ​nodo​ ​23
Para eliminar el nodo 23 de nuestra lista enlazada, lo que debemos hacer es pinchar en el icono
que dice Borrar, en donde nos aparecerá una lista con todos los nodos que tenemos hechos, como
se​ ​muestra​ ​en​ ​la​ ​siguiente​ ​imagen:

Luego seleccionamos el nodo a eliminar el cual es el 23 y le damos aceptar, una vez que
hacemos este paso el software nos preguntará si deseamos realmente eliminar el nodo 23, como
se muestra en la siguiente imagen:

Si estamos seguros que es el nodo a eliminar pinchamos en sí, y nos eliminará el nodo con valor
23,​ ​el​ ​cual​ ​es​ ​el​ ​que​ ​deseamos,​ ​y​ ​quedaría​ ​de​ ​la​ ​siguiente​ ​manera:
nos damos cuenta que ya nos elimino el nodo 23 y la lista se acomoda según sea el orden que se
necesite después de eliminar el nodo el orden obtenido es el siguiente: 5, 17, 11, 32, 34, 12, 3, 2,
8.

Insertar​ ​el​ ​nodo​ ​7​ ​entre​ ​el​ ​nodo​ ​34​ ​y​ ​32

En las listas enlazadas al momento de realizar un inserto lo realiza al lado derecho de la del nodo
inicial , entonces procedemos a pinchar el botón que dice insertar el cual no da la opción de
ingresar​ ​un​ ​valor,​ ​como​ ​lo​ ​muestra​ ​la​ ​siguiente​ ​imagen:

en la cual le damos el valor que nosotros deseamos el cual es el 7, por ende como habíamos
dicho queda al lado derecho del nodo inicial el cual es el 5, en la siguiente imagen se refleja lo
dicho

Entonces una vez creada nuestro nodo nuevo valor 7, para poder ubicarlo entre el nodo 32 y
nodo 34 debemos modificar los enlaces que se ubican en lo nodos nombrados, en donde debemos
ubicar​ ​el​ ​nodo​ ​7,​ ​en​ ​donde​ ​queda​ ​de​ ​la​ ​siguiente​ ​manera:
Por​ ​lo​ ​tanto​ ​esos​ ​son​ ​los​ ​pasos​ ​para​ ​que​ ​insertemos​ ​nuestros​ ​nodos​ ​entre​ ​medio​ ​de​ ​otros​ ​nodos.

2. Construya la siguiente pila de 10 elementos (c, d, r, t, j, y, t, y, u, m). Explique de qué

forma se insertan y se sacan elementos de la pila. En ambos caso muestre como quedaría
gráficamente​ ​la​ ​pila.

Comenzamos a construir nuestra pila con los 10 elementos que nos dieron, en la cual nos damos
cuenta que su filosofía se cumple en la cual es el primero en entrar es el último en salir (FIFO),
en​ ​donde​ ​nuestra​ ​pila​ ​queda​ ​de​ ​la​ ​siguiente​ ​manera:
Insertar​ ​(Push)
Para insertar un elemento a la pila nos damos cuenta que toma la primera posición o se apila al
último elemento por ejemplo vamos a insertar un nuevo elemento en pila el cual va hacer el
elemento​ ​s,​ ​entonces​ ​este​ ​ocupa​ ​el​ ​último​ ​lugar​ ​de​ ​la​ ​pila​ ​como​ ​se​ ​a​ ​continuación:
Eliminar​ ​(POP)
esta operación consiste en eliminar el elemento mas cercano de la pila, en la cual vamos a utilizar
el mismo ejemplo dado anteriormente en la cual el elemento “s” de la pila será eliminado al
momento​ ​de​ ​hacer​ ​click​ ​en​ ​el​ ​icono​ ​de​ ​Pop,​ ​y​ ​nuestra​ ​pila​ ​queda​ ​de​ ​la​ ​siguiente​ ​manera:
 3. Considere los siguientes elementos (5, 7, 9, 12, 16, 21, 23, 28, 31, 33). Explique de qué
forma se insertan y se sacan estos elementos de manera que el primero en entrar sea el
primero​ ​en​ ​salir.​ ​Identifique​ ​que​ ​estructura​ ​de​ ​datos​ ​es​ ​y​ ​cómo​ ​quedaría​ ​gráficamente.

Este tipo de estructura en la cual consiste en que el primero en entrar es el primero en salir este
concepto es llamado cola en donde su filosofía es la nombrada anteriormente, una vez que
tenemos identificada la estructura, la cual es cola procederemos a insertar los valores dados,
entonces​ ​nuestra​ ​cola​ ​queda​ ​de​ ​la​ ​siguiente​ ​manera:

una vez con nuestra cola ya hecha procederemos a realizar una inserción de un nuevo elemento
en este caso insertaremos el nodo con valor 44, en donde apretamos el botón insertar y nos
aparecerá otra ventana preguntándonos por el valor del nodo ha agregar, como se muestra en la
siguiente​ ​imagen:

una
vez agregada nuestro nuevo elemento, toma la ubicación del último en la fila y queda ubicado al
lado derecho del último nodo el cual es el 33, entonces ahora nuestro último nodo es el valor 44,
como​ ​muestra​ ​en​ ​la​ ​siguiente​ ​imagen:
una vez que insertamos el nuevo elemento donde el nodo 44 , queda como último elemento de la
cola,​ ​ahora​ ​procederemos​ ​a​ ​eliminar​ ​el​ ​nodo.Este paso consiste eliminar un nodo y según el
concepto de colas nombrados anteriormente el primer nodo como fue el primero en ingresar debe
ser​ ​el​ ​primero​ ​en​ ​salir,​ ​en​ ​este​ ​caso​ ​es​ ​el​ ​nodo​ ​valor​ ​5,​ ​como​ ​nos​ ​muestra​ ​la​ ​siguiente​ ​imagen:

nos damos cuenta que si se cumple lo dicho anteriormente en donde presionamos el botón
eliminar y nos retira el nodo 5 el cual fue el primero en entrar y es el primero en salir,
cumpliendo​ ​el​ ​concepto​ ​de​ ​las​ ​colas.

4. Implemente un algoritmo utilizando arreglos que permitan ordenar de números de mayor

a​ ​menor

Algoritmo​ ​de​ ​Mayor​ ​a​ ​Menor:

String[Mayor​ ​a​ ​Menor]​ ​args)​ ​{ 

​ ​ ​Scanner​ ​lector​ ​=​ ​new​ ​Scanner(System.in); 
​ ​ ​int​ ​arreglo[]​ ​=​ ​new​ ​int[30]; 
​ ​ ​int​ ​limite,i,j,aux; 
System.out.println(“Ingrese​ ​el​ ​limite​ ​de​ ​la​ ​lista”); 
Limite=lector.nextInt(); 
 
for(i=0;i<limite;i++){ 
​ ​ ​System.out.print(“X[“+(i+1)+”]=”); 
​ ​ ​Arreglo[i]=lector.nextInt(); 
 } 
 
for​ ​(i=0;i<limite;i++){ 
​ ​ ​ ​ ​ ​ ​ ​for​ ​(j=i+1;j<limite;j++){ 
​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​if​ ​(arreglo[i]<arreglo[j]){ 
​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​aux=arreglo[i]; 
​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​arreglo[j]=arreglo[i]; 
​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​arreglo[j]=aux; 
​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​} 
​ ​ ​ ​ ​ ​ ​ ​ ​ ​} 
} 
 
System.out.print(“Arreglo={“); 
for(i=0;i<limite;i++){ 
​ ​ ​ ​System.out.print(arreglo[i]+”,”); 
} 
System.out,print(“}”); 
} 
 
5. Implementar​ ​un​ ​algoritmo​ ​de​ ​una​ ​función​ ​para​ ​recorrer​ ​un​ ​árbol​ ​binario​ ​en
inorden.

Recorrido​ ​Árbol​ ​Binario​ ​en​ ​Inorden

#include  
#include  
#include  
#include  
  
struct​ ​nodoArbol​ ​{ 
 ​ ​ struct​ ​nodoArbol​ ​*ptrIzq; 
 ​ ​ int​ ​dato; 
 ​ ​ struct​ ​nodoArbol​ ​*prtDer; 
}; 
  
typedef​ ​struct​ ​nodoArbol​ ​NodoArbol; 
typedef​ ​NodoArbol​ ​*ptrNodoArbol; 
  
/*​ ​prototipos​ ​*/ 
void​ ​insertaNodo(​ ​ptrNodoArbol​ ​*ptrArbol,​ ​int​ ​valor​ ​); 
void​ ​inOrden(​ ​ptrNodoArbol​ ​ptrArbol​ ​); 
void​ ​preOrden(​ ​ptrNodoArbol​ ​ptrArbol​ ​); 
void​ ​postOrden(​ ​ptrNodoArbol​ ​ptrArbol​ ​); 
  
int​ ​main(){ 
 ​ ​ int​ ​i;​ ​/*​ ​contador​ ​para​ ​el​ ​ciclo​ ​de​ ​1​ ​a​ ​10​ ​*/ 
 ​ ​ int​ ​elemento;​ ​/*​ ​variable​ ​para​ ​almacenar​ ​valores​ ​al​ ​azar​ ​*/ 
 ​ ​ ptrNodoArbol​ ​ptrRaiz​ ​=​ ​NULL​; 
  
 ​ ​ srand(​ ​time(​ ​NULL​​ ​)​ ​); 
 ​ ​ ​printf​(​ ​"Los​ ​numeros​ ​colocados​ ​en​ ​el​ ​arbol​ ​son:n"​ ​); 
  
 ​ ​ ​/*​ ​inserta​ ​valores​ ​al​ ​azar​ ​entre​ ​1​ ​y​ ​15​ ​en​ ​el​ ​arbol​ ​*/ 
 ​ ​ for​ ​(​ ​i​ ​=​ ​1;​ ​i​ ​dato​ ​=​ ​valor; 
 ​ ​ ​ ​ ​ ​ ​ ​ (​ ​*ptrArbol​ ​)-&gt;ptrIzq​ ​=​ N ​ ULL​; 
 ​ ​ ​ ​ ​ ​ ​ ​ (​ ​*ptrArbol​ ​)-&gt;prtDer​ ​=​ N ​ ULL​; 
 ​ ​ ​ ​ ​ ​}​ ​/*​ ​fin​ ​de​ ​if​ ​*/ 
 ​ ​ ​ ​ ​ ​else​ ​{ 
             ​printf​(  "no  se  inserto  %d.  No  hay  memoria 
disponible.n",​ ​valor​ ​); 
 ​ ​ ​ ​ ​ ​} 
 ​ ​ } 
 ​ ​ else​ ​{​ ​/*​ ​el​ ​arbol​ ​no​ ​esta​ ​vacio​ ​*/ 
  
         ​/*  el  dato  a  insertar  es  menor  que  el  dato  en  el  nodo 
actual​ ​*/ 
 ​ ​ ​ ​ ​ ​if​ ​(​ ​valor​ ​dato​ ​)​ ​{ 
             insertaNodo(  &amp;(  (  *ptrArbol  )-&gt;ptrIzq  ),  valor 
); 
 ​ ​ ​ ​ ​ ​} 
         ​/*  el  dato  a  insertar  es  mayor  que  el  dato  en  el  nodo 
actual​ ​*/ 
 ​ ​ ​ ​ ​ ​else​ ​if​ ​(​ ​valor​ ​&gt;​ ​(​ ​*ptrArbol​ ​)-&gt;dato​ ​)​ ​{ 
             insertaNodo(  &amp;(  (  *ptrArbol  )-&gt;prtDer  ),  valor 
); 
 ​ ​ ​ ​ ​ ​} 
 ​ ​ ​ ​ ​ ​else​ ​{​ ​/*​ ​ignora​ ​el​ ​valor​ ​duplicado​ ​del​ ​dato​ ​*/ 
 ​ ​ ​ ​ ​ ​ ​ ​ ​printf​(​ ​"#​ ​"​ ​);​ ​ ​//​ ​Imprime​ ​en​ ​valores​ ​duplicados 
 ​ ​ ​ ​ ​ ​} 
 ​ ​ } 
}​ ​/*​ ​fin​ ​de​ ​la​ ​funcion​ ​insertaNodo​ ​*/ 
  
/*​ ​comienza​ ​el​ ​recorrido​ ​inorden​ ​del​ ​arbol​ ​*/ 
void​ ​inOrden(​ ​ptrNodoArbol​ ​ptrArbol​ ​){ 
 ​ ​ ​/*​ ​si​ ​el​ ​arbol​ ​no​ ​esta​ ​vacio,​ ​entonces​ ​recorrelo​ ​*/ 
 ​ ​ if​ ​(​ ​ptrArbol​ ​!=​ ​NULL​​ ​)​ ​{  
 ​ ​ ​ ​ ​ ​inOrden(​ ​ptrArbol-&gt;ptrIzq​ ​); 
 ​ ​ ​ ​ ​ ​printf​(​ ​"%3d",​ ​ptrArbol-&gt;dato​ ​); 
 ​  ​ ​ ​ ​ ​inOrden(​ p​ trArbol-&gt;prtDer​ ​); 
 ​   ​ } 
}​ ​/*​ ​fin​ ​de​ ​la​ f​ uncion​ ​inOrden​ ​*/

Bibliografía

IACC​ ​(2014).​ ​Listas​ ​Enlazadas.​ ​Estructura​ ​de​ ​Datos.​ ​Semana​ ​2.

IACC​ ​(2014).​ ​Pilas.​ ​Estructura​ ​de​ ​Datos.​ ​Semana​ ​4.

IACC​ ​(2014).​ ​Colas.​ ​Estructura​ ​de​ ​Datos.​ ​Semana​ ​5.

IACC​ ​(2014).​ ​Árboles​ ​Binarios​ ​de​ ​Búsqueda​ ​(ABB).​ ​Estructura​ ​de​ ​Datos.​ ​Semana​ ​7.

IACC​ ​(2014).​ ​Arreglos.​ ​Estructuras​ ​de​ ​Datos.​ ​Semana​ ​8.

Universidad de Chile (s. f.). Ordenamiento de Arreglos. Consultada viernes 4 de noviembre de

2016.​ ​https://users.dcc.uchile.cl/~lmateu/Java/Transparencias/Compl/sort.htm

Victor D.L.R (Mayo, 2009). Crea un árbol binario y lo recorre en preorden, inorden, y en

posteorden. Consultada jueves 3 de noviembre de 2016.

http://ejemplos.mis-algoritmos.com/crea-un-arbol-binario-y-lo-recorre-en-preorden-inord

en-y-en-postorden