Baldwin José Palencia Serrano

Profesor: John Jairo lodoño Pérez

(Ingeniero industrial/ingeniero de sistemas) [U- Distrital]
Especialista en redes AVD
Magíster en T.I
(docente U.C, pregrado 15 años docente U. Distrital, posgrados 15 años).
Correo: [email protected]

Libros:
1.Modelo Pseudo Matemático para el Diseño de las Bases de Datos
Relacionales ISBN

2. Planeación de Sistemas de Información - Aplicación Práctica.

3. Ingeniería de Software - Linealidad, Dispersión, Gestión ISBN

4. Teoría de Sistemas Enfoque para Ingenieros- Pensamiento Sistémico

ISBN

contenido temático
1
- concepto generales de las estructuras de Datos
- Breve repaso de las “estructuras de datos NO dinámicas” (vectores -
matrices)
- Introducción a las “estructuras de dinámicas” / Definición y arquitecturas de
las estructuras dinámicas
2
- Definición de las “listas de enlace simple” con estructuras dinámicas /
elaboración de código (lenguaje “c” / Lenguaje Java)
- Operaciones de adición, eliminación, modificación, lenguaje de “nodos” de
memoria dinámica
3
- Definición de “Listas de enlaces doble“ con estructuras Dinámicas -
elaboración del código (Lenguaje “c” / Lenguaje Java)
- Operaciones de adición, eliminación, modificación, lenguaje de “nodos” de
memoria dinámica
4
- Definición operativa de las “colas” en las listas de memoria dinámica
- Elaboración del código para la creación de una lista en modo “cola”
- Operaciones de insercion, modificacion y borrado de nodos dentro de los
conceptos de colas
5
- Definición operativa de las “Pilas” en las listas de memoria dinámica
- Elaboración del código para la creación de una lista de modo “Pila”
 Baldwin José Palencia Serrano

- Operaciones de insercion, modificacion y borrado de nodos dentro de los

conceptos de “Pilas”
6
- Definición y arquitectura de un “Grafo” a partir de las “matrices de
adyacencia”
- Elaboración del código para la creación, lecturas y otros, de un Grafo
7
- Definición y arquitectura de un “árbol” a partir de la creación de un algoritmo
estándar
- Elaboración del código para la creación, lectura y otros de un Árbol

8
- Productos para usuarios construidos en Java, de tipo ArrayList conceptos de
su fundamentación en las estructuras de datos
- Elaboración del código (Lenguaje Java) para el manejo de los datos
utilizando ArrayList
9
- Productos para usuarios construidos en java, de tipo Hashmap / conceptos
fundamentación en las sistemas de datos
- Elaboración del código (Lenguaje Java) para el manejo de los datos
utilizando Hashmap
10
- conceptos básicos de las “Tablas” de las bases de datos relacionales, a partir
del uso de las estructuras de datos dinámicas (nodos)
- Introducción al manejo de bases de datos a través del uso de un motor B.D
como MysQL

colección de palabras claves de la memoria:

- Vectores, Matrices - Colas - Árbol - Tablas
- Listas enlace simple -Pilas - ArrayList
- Listas enlace dobles -Grafo - Hashmod

Forma de calificación:
40% Elaboración del documento de la materia: Tema de clase / Talleres, Trabajos
en clase, en casa / una conclusión en 5 líneas por cada tema tratado por clase
30% Parcial o prueba individual de evaluación del corte
20% Talleres, ejercicios, trabajos en clase, casa
10% Apreciativa (actitud, participación)
100% cada corte

Compromiso en clase:
- pre esencialidad, cumplimiento de horario, puntualidad
- Respeto bi unívoco: trato, disciplina, tacto, sana tolerancia
- Responsabilidad con la materia: Trabajos, talleres, estudios.
 Baldwin José Palencia Serrano

Capítulo 1
1.1 Repaso de las estructuras de datos “No Dinámica”:
Los vectores y matrices, son estructuras de datos “no dinámicas”, en razón a que su
tamaño inicialmente definido, “NO” podrá ser modificado posteriormente, ejemplos:
Vector a
i 0 1 2
este vector “a[4]” no podrá ser aumentado a “a[5]”, en caso de sucederse, se estará
haciendo referencias a un nuevo vector, es decir, se están redefiniendo,
ocasionando que los datos antes almacenados, se pierdan

Si: a[4]
Inicialment
a 10 5 7
e definido
12
0 1 2 3
Entonces: a[5] posteriormente redefinido

a x x5 7x
10
los datos
x 1 2
0 3
iniciales
“desaparecen,
se comprende”
Matriz:
j

a 3 1
j
7 1
filas columnas

igual, esta matriz a[2][2], no podrá ser aumentado a a[3][3], en caso de sucederse,
se estará haciendo referencia a una nueva matriz, es decir, se estará redefiniendo
ocasionando que los datos antes almacenados se pierdan.

a[2][2] inicialmente definido

si :
a 3 1
7 1

entonces: a[3][3] posteriormente definido

a x3 x los datos
x 1 x inicialmente
7 1 desaparecen, se
comprenden como
 Baldwin José Palencia Serrano

Reflexión: Todo lo anterior, para vectores y matrices acontece, si se está trabajando

dentro del mismo programa.

1.2 Prototipos de programación para “cargar y mostrar” un vector y una matriz ,

utilizando lenguaje java y lenguaje c++

&: siempre irá asociado al formato de la variable

%d: formato para variables tipo int

(vector) (vector)
Java: C++

import java.util.Scanner; #include <iostream>

public class Vector { int main() {
public static void main(String[] args) {
int a[2][2];
int[][] a = new int[2][2];
int i, j, valor; int i, j, valor;
Scanner vector = new Scanner(System.in); std::cout << "Ingrese los valores para la
for (i = 0; i < 2; i++) { matriz 2x2:" << std::endl;
for (j = 0; j < 2; j++) { for (i = 0; i < 2; i++) {
System.out.println("Ingrese un valor: ");
for (j = 0; j < 2; j++) {
valor = vector.nextInt();
a[i][j] = valor; std::cout << "Ingrese un valor: ";
} std::cin >> valor;
} a[i][j] = valor;
System.out.println("Matriz ingresada:"); }
for (i = 0; i < 2; i++) {
}
for (j = 0; j < 2; j++) {
System.out.print(a[i][j]+ " "); std::cout << "Matriz ingresada:" <<
} std::endl;
System.out.printf("\n"); for (i = 0; i < 2; i++) {
} for (j = 0; j < 2; j++) {
}
std::cout << a[i][j] << " ";
}
}
std::cout << std::endl;
}
return 0;
}
 Baldwin José Palencia Serrano

Sea una matriz o vector definido, A esta no se le podrá modificar el tamaño en

razón a que su extensión inicialmente está definido. En caso de hacerlo este
perderá todos sus datos que se encuentren almacenados ya que al modificar
cambiará el tamaño de la matriz o el vector logrando así una nueva definición de
nuevos datos, sobreescribiendo y conllevando una modificación pero sin los datos
ya almacenados.

1.2 Introducción a las estructuras de datos Dinámicas (nodos de memoria)

está claro, que cuando se trabaja con memoria “NO” dinámicas(vectores / matrices)
no es posible agregar una nueva casilla al arreglo (array) cuando previamente su
tamaño ha sido definido:
int
.
. 0 1 2
-
-
for(
5 10 8
Apare

int 5 8

Desaparec
en:
Cuando se trabaja con “memoria dinámica”, los nombres de vectores y matrices
reciben el nombre de “listas”, y estas se crean con base en pequeñas secciones,
denominadas “nodos”.
con base a lo anterior, cuando se “alcanza los nodos” se crean las “listas” y estas
tienen de particular que dentro del mismo programa podrá “adicionarse nodos” a
una “lista” inicial, sí que se pierdan los datos guardados en nodos anteriores:

sección
para sección para guardar la
guardar “dirección” del nodo siguiente,
un dato permitiendo el enlace

50 30 10 For (0 hasta

nod nod nod

o o o
0 1 2

Entonces:
 Baldwin José Palencia Serrano

Se
sigue

50 30 10 80 60 For (0
1 2 3 4
Nuevo for
No se Se
A lo contrario de memorias NO dinámicas, las memorias dinámicas que es diferente
a lo anterior no se pierden ni borran sus datos, si no que que crea otro “for” para
crear nuevos nodos con base a los que ya estaban creados así mismo siguen
enlazados que son los vectores y matrices recibiendo el nombre de listas. lo que las
hace flexibles y adecuadas para programar donde se requiera una gestión dinámica
de datos.

Capítulo 1:
1.3 Arquitecturas basicas de programacion en java y en c++, para el manejo de
“nodos” de memoria dinámica:

C++ Java

#include <conio.h> Package,__;

#include <stdio.h> import java.io.*;
n import java.util.Scanner; n
Dato
o Dato
o
main()
enlace
d enlace
d
{ class nodo
struct nodo ubicació o { ubicació o
{ n dentro int dato; n dentro
int dato; del nodo enlace; del
struct nodo *enlace; progra } program
ma a
} “siempr public class,__; “siempr
{ e”
e”
Cuerpo del public static void main(String[]args)
programa para el {
manejo de “nodos”
Cuerpo del
programa para
} el manejo de
nodos

}
}
Tipos de nodos
 Baldwin José Palencia Serrano

-Monovalor:
solo un valor
podría
ser :numérico o
alfanumérico
dato enlace

-Multivalor simple
datos datosdatosenlace

: podrán ser
numéricos,
alfanuméricos o mixtos

varios valores

Multivalor “Tipo Vector”

Varios valores

enlac
e
:Podrá ser
0 1 2 3 numérico o
alfanumérico

Multivalor “Tipo Matriz” dato[][]:

Varios valores

enlace

C++ Java

Struct nodo class nodo

{ {
 Baldwin José Palencia Serrano

int dato; int dato;

Struct nodo enlace; nodo enlace;
} }

Struct nodo class nodo

{ {
int datos; int datos;
int datos; int datos;
int datos; int datos;
Struct nodo enlace; nodo enlace;
} }

Struct nodo class nodo

{ {
int dato[4]; int dato[]=new int[4];
Struct nodo enlace; nodo enlace;
} }

Struct nodo class nodo

{ {
int dato[3][3]; int dato[][]=new int[3][3];
Struct nodo enlace; nodo enlace;
} }

El manejo de nodos tanto como en java y C + +, tienen pequeñas diferencias como

que el nodo en C + + va dentro del main y que en java va por fuera del public class.
Aun así estos comparten más similitudes que puedes observar a la hora de
programarlos en dichos lenguajes. sabiendo esto, también logramos decir que
existen muchos tipos de nodos el cual tiene una función diferente uno del otro
logrando almacenar los datos de diferentes formas dentro del nodo y con diferencia
de variables.

Capítulo 2:
2.1 Elemento esenciales de un nodo de memoria dinámica:
p: Podra ser cualquier otra letra o nombre, que tendrá la
propiedad para “crear un nodo de memoria dinámica”
Apuntador de Cab: podrá ser cualquier otro nombre,”indica cabecera”, se
una nueva utiliza para guardar el nodo de inicio creado dentro de
dirección de
un ejercicio de enlaces de nodos
la “memoria”
q: Podrá ser cualquier otra letra o nombre, se utiliza para guardar
el “p” anterior, cuando se sucede un nuevo “p”

Abstracción:
 Baldwin José Palencia Serrano

guardar la “direccion”
o ubicacion de un
nodo siguiente

dato enlace

p
nodo p
cab inicial
q

Lo anterior aplica para lenguajes java y lenguaje C++

Cuerpo Programa lenguaje java

Enlace de nodos - creación de una lista:
cap,p,q: Apuntadores de memoria de nodos

Nodo p= new nodo ();

Nodo cap= new nodo ();
Nodo q= new nodo ();

for (int I=0; i<2;i++){

nodo

p=new nodo();
Dirección en la ram donde
p se creó el nodo (ASCII)
system. out. println(“ingrese el valor”);
valor=tc.nextInt;

Nombre del teclado

}
 Baldwin José Palencia Serrano

Java
import java.util.Scanner;
class nodo{
int dato;
nodo enlace;
}
public class Nodos {
public static void main(String[] args) {

Scanner tc=new Scanner(System.in);

int valor,i;

nodo p=new nodo();

nodo cab=new nodo();
nodo q=new nodo();

for (i = 0; i < 2; i++) {

p=new nodo();
System.out.print("Ingrese el valor: ");
valor=tc.nextInt();
p.dato=valor;

if (i==0) {
cab=p;
q=p;
}
else {
q.enlace=p;
q=p;
}
}
p=cab;
for (i = 0; i < 2; i++) {
System.out.println("Valor es: "+p.dato);
p=p.enlace;
}
}
}

Un nodo de memoria dinámica es una estructura fundamental, se utiliza para

gestionar datos de manera flexible en la memoria. Consiste en un campo de datos
para almacenar información y una referencia o puntero que conecta los nodos entre
sí, permitiendo el enlace como listas, los elementos esenciales de un nodo de
memoria son p,cab,q. los cuales son los apuntadores de la nueva dirección de la
memoria.
 Baldwin José Palencia Serrano

dato enlac
apuntadores a la
“memoria”
llamada nodo p
Java
nodo
q
Package ___; cab
import ___;
import ___;

class nodo
{
int dato;
nodo
enlace;
}
public class ___;
1→ {
public static void main(String[]args)
2→{
int valor, i;
Scanner tc=new Scanner
(System.in);
nodo p=new nodo();
nodo q=new nodo();
nodo cab=new nodo();
for(i=0; i<4; i++)
{
p=new nodo();
System.out.println(“va
lor..”)
valor= tc.nextInt();
p.dato=valor;
if(i==0)
{
cab=p;
q=p;
}
else
{
q.enlace=p;
q=p;
}
}
p=cap
for(i=0; i<4; i++)
{
System.out.println(“Valor
es..”+p.dato);
p=p.enlace;
2→}
1→ }
 Baldwin José Palencia Serrano

apuntadore dat enl

s a la C++
“memoria” p
nodo #include <Stdio.h> for(i=0; i<4; i++)
qc #include <conio.h> {
main() p=(struct
→{ nodo*)malloc(sizeof(struct nodo));
Struct nodo printf(“valor..”);
{ scanf(“%d”fravor);
int dato; p→dato=valor;
struct nodo
if(i==0)
{
cab=p;
int valor, i; q=p;
struct nodo*p; }
else
{
q→ enlace
=p;
q=p;
}
}
p=cab;

En java y C + +, se centra en la creación y visualización de una lista que consta de

4 nodos, en java. se recurre a un clase denominada “nodo” que es la que almacena
y vincula los valores lo cuales son enteros, mientras que en C + +, se emplea una
estructura similar haciendo uso de punteros. En ambos escenarios, se indica al
usuario que ingrese los valores con el fin de construcción de dicha lista, y
posteriormente se muestra su contenido.

2.2 Enlace de nodos / nodos monovalor, multivalor plano multivalor vector,

multivalor matriz:

Monovalor:
class nodo struct nodo
{ {
int dato; int dato;
nodo enlace; struct nodo *enlace;
} };

Java C++

Multivalor: A diferencia del “nodo monovalor”, en cada nodo ta no se tendrá un

solo dato, sino, varios datos la lógica para enlazar nodos “no cambia”,
sencillamente, cada vez que se cree un nodo, se deberá ingresar más de un valor,
acorde con lo definido en la arquitectura del nodo.
 Baldwin José Palencia Serrano

Aplicación:
Java: C++:
class nodo struct nodo
{ {
int dato1; int dato1;
int dato2; int dato2;
int dato3; int dato3;
nodo enlace; struct nodo *enlace;
} }

dato1 dato2dato3enlace

sección sección
datos enlace

Ejercicio para 4 nodos:

Java: C*++:
: :
: :
: :
for(i=0; i<4; i++){ for(i=0; i<4; i++){
p=new nodo (); p=((struct nodo*) malloc(sizeof)
System.out.println(“... valor 1”); (struct nodo));
valor1=tc.nextInt(); printf
System.out.println(“... valor 2”); scanf
valor2=tc.nextInt(); printf
System.out.println(“... valor 3”); scanf
valor3=tc.nextInt(); printf
scanf
p.dato1=valor1;
p.dato2=valor2; p→dato1=valor1;
p.dato3=valor3; p→dato2=valor2;
p→dato3=valor3;
if(I==0){
cap=p; if(I==0){
q=p cap=p;
} q=p
else{ }
Lo mismo de los programas else{
anteriores Lo mismo de los

Java
 Baldwin José Palencia Serrano

import java.util.Scanner;
class nodo{
int dato1;
int dato2;
int dato3;
nodo enlace;
}

public class Nodos {

public static void main(String[] args) {

Scanner tc=new Scanner(System.in);

int valor1,valor2,valor3,i;

nodo p=new nodo();

nodo cab=new nodo();
nodo q=new nodo();

for (i = 0; i < 4; i++) {

p=new nodo();
System.out.print("Ingrese el valor 1: ");
valor1=tc.nextInt();
System.out.print("Ingrese el valor 2: ");
valor2=tc.nextInt();
System.out.print("Ingrese el valor 3: ");
valor3=tc.nextInt();

p.dato1=valor1;
p.dato2=valor2;
p.dato3=valor3;

if (i==0) {
cab=p;
q=p;
}
else {
q.enlace=p;
q=p;
}
}
p=cab;
for (i = 0; i < 4; i++) {
System.out.print("Valor es: "+p.dato1+"\n"+
"Valor es: "+p.dato2+"\n"+
"Valor es: "+p.dato3+"\n");
p=p.enlace;
}
}
}

C++
 Baldwin José Palencia Serrano

#include <iostream>
using namespace std;
struct nodo {
int dato1;
int dato2;
int dato3;
nodo* enlace;
};
int main() {
int valor1, valor2, valor3, i;

nodo* p;
nodo* cab;
nodo* q;
for (i = 0; i < 4; i++) {
p = new nodo;
cout << "Ingrese el valor 1: ";
cin >> valor1;
cout << "Ingrese el valor 2: ";
cin >> valor2;
cout << "Ingrese el valor 3: ";
cin >> valor3;

p->dato1 = valor1;
p->dato2 = valor2;
p->dato3 = valor3;
p->enlace = nullptr;

if (i == 0) {
cab = p;
q = p;
} else {
q->enlace = p;
q = p;
}
}
p = cab;
for (i = 0; i < 4; i++) {
cout << "Valor es: " << p->dato1 << "\n"
<< "Valor es: " << p->dato2 << "\n"
<< "Valor es: " << p->dato3 << "\n";
p = p->enlace;
}
// Liberar memoria
p = cab;
while (p != nullptr) {
nodo* temp = p;
p = p->enlace;
delete temp;
}
return 0;
}
 Baldwin José Palencia Serrano

En este ejercicio tanto java como c + +, consta de 4 nodos los cuales cada uno
tendrá 3 valores enteros ingresado por el usuario, creando así una lista de 12
valores, el cual utilizando una clase llamado “nodo” que tiene campos para los
valores y un puntero al siguiente nodo. luego, itera a través de una lista y muestras
así los valores de cada nodo.

Segundo Semestre
Capítulo 2: Una lista es una concatenación o unión de “nodos” que cumple con
una orientación o un sentido determinado; la concatenación se puede orientar hacia
la izquierda o hacia la derecha del “nodo” que haya sido indicado como cabecera.

Abstracción:

Derech

: Si el “enlace” está
ca a la derecha del
dato enla
nodo, la “lista”

: Si el “enlace” está a
la izquierda del nodo,
Izquier la “lista” crecerá hacia
dato enla ca if(n==0)
{
Java C++ cab=p;
q=p;
class nodo{ Struct nodo{ }
Int dato; Int dato; else
nodo Struct nodo { q.enl
enlace; enlace*; ace=p;
q=p; “la lógica es la
misma”; quien
define el sentido por
class nodo{ Struct nodo{ if(n==0)
donde se enlaza, la
nodo Struct nodo {
enlace; enlace*; cab=p;
Int dato; Int dato; q=p;
}
else
{ q.enl
ace=p;
q=p;
 Baldwin José Palencia Serrano

● Repaso parcial primer cohorte

for(n=0; n<4; n++){
p=new nodo(); p=(Struct nodo*)malloc(sizeof(Struct
nodo));
for(i=0; i<2; i++){
for(j=0; j<2; j++){ p=(Struct nodo*)malloc(sizeof(Struct
valor=tc.nextInt(); nodo));
p.matriz[i][j]=valor; Scanf(“%d”,fvalor);
} p→matriz[i][j]=valor;
}
if(i==0){
cab=p;
q=p;
}
else
{
q.enlace=p;
q=p;
}
} q→enlace=p;

q
p
xp q

Class nodo { Struct nodo {

Java [2][2]; int matriz [][]=new int C++ int matriz [2][2];
Struct nodo *enlace;
nodo enlace; };
}
Después del Public Después del main()

Una lista es una estructura de datos compuesta por la unión de “nodos” que siguen
una dirección específica, ya sea hacia la izquierda (Colas) o hacia la derecha
(Pilas), partiendo del nodo principal denominado cabecera. Estos nodos se
conectan sucesivamente, creando una secuencia ordenada que permitirá el acceso
y manipulación de datos de acuerdo con la orientación establecida por el usuario.
Por otro lado, el parcial contaba con 4 nodos y el manejo de dos For para la matriz
2x2.
 Baldwin José Palencia Serrano

Capítulo 3: Listas de “doble enlace” o de “enlaces dobles”: Los “nodos” de

estas listas tiene de particular, que contienen “enlace” por izquierda y por la
derecha, con lo cual dependiendo de lo que se quiera, se definirá una prioridad para
los enlaces, que podrá ser alteradas (uno por derecha, otro por izquierda), o primero
todo por derecha y después por izquierda, o viceversa. Téngase en cuenta que en
cualquiera de los casos, es importante definir el “nodo cabecera”. En cualquiera de
los casos, la forma de “enlazar” es la misma, solo se deberá estar atentos al enlace
que corresponde.
enlace enlace
Abstracció
dat

Izquie Derec
p
ca
q
CIzquie
Java: ++:
class nodo struct nodo
{ {
nodo enlacei; struct nodo
int dato; *enlacei;
Derec
Explicación: crear una lista de doble enlace: cabecera, más 2 nodos por derecha, 2 nodos
por izquierda: → 5 nodos.
 Baldwin José Palencia Serrano

: int si conta <2:

: derecha de lo
for(n=0; n<5; n++)
{
p.dato=v p→dato=
p=new
nodo(); Jav C+
-ingrese
valor
if(n==0)
{ enlaza por C++
cab=p; derecha: Java
q=p;
} q→enlaced=p;
else se debe q.enlaced=p; q=p;
{ volver a q=p;
if(conta<2){ actualiza q C++

enlaza por
derecha
conta=conta+1;
}
else{

if(n==2){
cab.enlacei=p;
Listas de doble enlace.
enlace enlace
Izquierda derecha
(Recordando enlace 5
nodos)
dato

4 3 0 1 2

xp p
Enlace Derecha q Enlace
cab Izquierda
 Baldwin José Palencia Serrano

for(n=0; n<4; n++){

p=new nodo();
System.out.println(“nodo..”)
valor= tc.nextInt();
p.dato=valor;

if(n==0){
cab=p;
q=p;
}
else
{ Pregunta Clave:
if(n<3){ Verificar el instante en que
q.ed=p; se deja de enlazar por
q=p; derecha, para iniciar por
} izquierda
else{
if(n==3){
cab.ei=p;
q=p;
}
else{
q.ei=p;
q=p;
}
}
}
}
p=cab;{
derecha
}
p=cab;{
izquierda
}

import java.util.Scanner;
class nodo{
int dato;
nodo enlace,ed,ei;

public class Nodos {

public static void main(String[] args) {

Scanner tc=new Scanner(System.in);

int valor,n;

nodo p=new nodo();

nodo cab=new nodo();
nodo q=new nodo();
 Baldwin José Palencia Serrano

for (n = 0; n<5; n++) {

p=new nodo();
System.out.print("Nodo: ");
valor=tc.nextInt();
p.dato=valor;

if (n==0) {
cab=p;
q=p;
}
else {

if(n<3){
q.ed=p;
q=p;
}
else {
if(n==3) {
cab.ei=p;
q=p;
}
else {
q.ei=p;
q=p;
}
}
}
}
p=cab;
for (n = 0; n < 3; n++) {
System.out.print("Valores por derecha "+p.dato+"\n");
p=p.ed;
}

p=cab;
for (n = 0; n < 3; n++) {
System.out.print("Valores por izquierda: "+p.dato+"\n");
p=p.ei;
}
}
}
#include <stdio.h>
#include <stdlib.h>
struct Nodo {
int dato;
struct Nodo* enlace;
struct Nodo* ed;
struct Nodo* ei;
};

int main() {
int valor, n;
struct Nodo* p = NULL;
struct Nodo* cab = NULL;
struct Nodo* q = NULL;

for (n = 0; n < 5; n++) {

p = (struct Nodo*)malloc(sizeof(struct Nodo));
 Baldwin José Palencia Serrano

printf("Nodo: ");
scanf("%d", &valor);
p->dato = valor;

if (n == 0) {
cab = p;
q = p;
} else {
if (n < 3) {
q->ed = p;
q = p;
} else {
if (n == 3) {
cab->ei = p;
q = p;
} else {
q->ei = p;
q = p;
}
}
}
}
p = cab;
for (n = 0; n < 3; n++) {
printf("Valores por derecha: %d\n", p->dato);
p = p->ed;
}

p = cab;
for (n = 0; n < 3; n++) {
printf("Valores por izquierda: %d\n", p->dato);
p = p->ei;
}
p = cab;
while (p != NULL) {
struct Nodo* temp = p;
p = p->ed;
free(temp);
}
return 0;
}

Una lista de enlaces dobles es una estructura de datos que consta de “nodos”
conectados de manera bidireccional, lo que significa que cada nodo tiene
referencias tanto al nodo anterior como al siguiente en la secuencia, teniendo una
prioridad para los enlaces, ya que si esta no tiene datos correrá por la izquierda,
pero si tiene datos en ambos enlaces este irá por la derecha. Por otra parte, la pila
crece por la derecha y cola por la izquierda.

Colas:(Regla: Enlace por izquierda) una “cola” es una estructura de nodos,

enlazados hacia la izquierda del nodo denominado “cabecera ”. Con base en lo
anterior, el nodo deberá definirse con base en 2 secciones:

- sección de “enlaces por izquierda”

 Baldwin José Palencia Serrano

- Sección de “datos”

Se abstrae entonces, que la estructura de enlaces crece hacia atrás del “nodo
cabecera” y que respetando el concepto lógico de una “cola”, el primer nodo en ser
“atendido”, será el de cabecera, posteriormente en su orden los nodos que aparecen
detrás. Se dice que el manejo de “colas” se utiliza el siguiente principio:

Primero en entrar: First input

Segundo en entrar: First output
De donde se obtiene la sigla: FIFO

Para entender la mejor manera el manejo de las “colas”, es pertinente referirnos a la

operación: Eliminación de nodos, la cual se sucederá de la “cabecera” hacia la
izquierda, es decir, de la “cabeza” hacia atrás.

Siempre que se elimina el nodo de la cabecera, el siguiente nodo hacía atrás

asumirá la característica de “cabecera”.

La “Eliminación de un nodo” se sucede, cuando este se desenlaza de los demás

nodos

Aplicación:
- Crear un enlace de nodos por la izquierda de la cabecera (5 nodos)
- Mostrar los nodos
- Eliminar el primer nodo o cabecera según lo definido
- renombrar la nueva cabecera
- Mostrar nodos
for(n=0; n<5; n++){

p=new nodo();

valor=tc.nextInt();
p.matriz[i]
[j]=valor;
Nod
if(i==0){ e Dat
cab=p; q
q=p;
} Ca Ca
p p
else
{ q
q.ei=p;
q=p;
}
}
p=cab;

for(n…5..){
 Baldwin José Palencia Serrano

Con base a las reglas de aplicación de colas (enlaces por izquierda).“Primero en

entrar, primero en salir” también ya conocido como FIFO lo que ha dado a entender
que el primer elemento que se agrega es el primero que se retira. El mejor ejemplo
para entender esto es el de una fila de personas que esperan por un turno, que bien
se sabe que al primero que se encuentre en la cabecera se le atenderá ya que por
su estructura este se encuentra más cerca del mostrador.

Manejo de colas: Está claro que una “cola” se contribuye, haciendo los
“enlaces” por el lado izquierdo de los “nodos”, a partir de la “cabecera”

Cab Cab

La “Eliminación” de “nodos”, se sucede a partir de la “cabecera”, lo que implica

volver a asignar una “nueva” cabecera, cada vez que se elimina un nodo

La “Aplicación” de “nodos”, se sucederá a partir del último nodo incorporando,

con lo cual se hace necesario siempre identificar el “último” nodo adicionando,
siendo este parcialmente el “fin”; en consecuencia todo adición se ocurrirá después
del nodo denominado nodo “fin” y se volverá a asignar un nuevo “fin”, cada vez que
se suceda una adición

Fin Cab
adició
n

Fin Fin Cab

 Baldwin José Palencia Serrano

Aplicación
- Un primer “for” para crear una “cola” con 3 nodos
- Un segundo “for” para adicionar a la cola 3 nuevos nodos
import… n
…… primer for(....){
class nodo{ p=new nodo();
nodo ei; -ingrese valor
int dato; y asignar
}
if(n==0){ primer nodo de la
public class colas{ fin.ei=p; 2da tanda de
public… q=p;
} p }
: ca else{
: nod q.ei=p;
q q=p;
for(....){ fin }
primer crear cola }
} fin=p;
fin=p p=cab; p=cab;
for(){ for(...<6…){
mostrar }
} }cierra public static
}cierra public class

import java.util.Scanner;
class nodo{
nodo ei;
int dato;
}

public class Colas {

public static void main(String[] args) {

Scanner tc=new Scanner(System.in);

int valor,n;

nodo p=new nodo();

nodo cab=new nodo();
nodo q=new nodo();
nodo fin=new nodo();

for (n = 0; n<3; n++) {

p=new nodo();
 Baldwin José Palencia Serrano

System.out.print("Nodo: ");
valor=tc.nextInt();
p.dato=valor;

p=cab;
for (n = 0; n < 3; n++) {
System.out.print("Valores por derecha "+p.dato+"\n");
//p=p.ed;
}

p=cab;
for (n = 0; n < 3; n++) {
System.out.print("Valores por izquierda: "+p.dato+"\n");
p=p.ei;
}
}
}

CODIGO
El manejo de colas implica una estructura de datos (FIFO). Se utiliza para organizar
elementos en orden de llegada. Las operaciones que este realiza son la de agregar
elementos al final y eliminar el primer elemento. Las colas son eficaces para
garantizar el orden de procedimiento y fundamentales en para situaciones que
requieren ordenamientos secuenciales. Su aplicación se da por el último nodo
incorporado que guarda al siguiente en sucesión.

Capítulo 5
Estructura de “Pilas”
Recreando, una “cola”se construye de la “cabecera” hacia “atrás”, es decir, haciendo
“enlaces” por la izquierda; la “eliminación” de los nodos se sucede a partir de la
cabecera; la “adición” de “nodos”, se sucede a partir del último nodo, es decir, a
partir del nodo indicado como fin, el último a la derecha.

Todo lo anterior hace parte de lo que se conoce como “FIFO” First Input / First
Output (primero en entrar - primero en salir). Ahora, una pila se construye de la
“cabecera” hacia adelante, es decir, haciendo “enlaces” por la derecha; la
“eliminación” de nodo que se encuentre en la “cima”, es decir, el nodo que dentro
este escenario se identifique como “fin”; así mismo la “adición” de nodos, se
sucederá a partir del nodo identificado como fin, el último a la derecha.Todo lo
anterior hace parte de lo que se conoce como “LIFO”: Last Input / First Output
(Último en entrar - primero en salir).
 Baldwin José Palencia Serrano

Colas: bien, solo enlace por izquierda y funciona para adicionar y eliminar

Pilas: Requiere de “doble enlace”, para poder eliminar - adicionar solo lo haría con
enlaces simples por derecha

Abstracción

x
:
:Construcció
n

Cabecera Fin
(cima)

:Eliminación

Cabecera Fin xFin

Abstracción
:

:Adición

Fin Fin
(cima)
 Baldwin José Palencia Serrano

import…
……
class nodo{ for(....){
int dato; “superclav p=new nodo();
nodo ed; -ingrese
} valor y asignar

public class ___{ if(n==0){

public Static fin.ei=p;
void…..{ q=p;
: }
: else{
for(n=0; n<4; n++ ) q.ei=p;
{ q=p;
p=new nodo(); fin=p;
Ingrese valor y p=cab;
asignó for(...<6…){
}
qa= if(n==0){ if(n==3){ }cierra public static
cab=p; qa=q;
q=p; q.ed=p;
} q=p;
Clave else{ }
y else{

q.ed=p;

De acuerdo a lo entendido en clase, las pilas (enlaces por derecha)”último en entrar,

primero en salir” LIFO, lo que significa que el último elemento que se agrega es el
primero en ser retirado. Al igual que las colas también cuentan con nodos
enlazados, pero la diferencia es que este cuenta con un doble enlace para así poder
hacer las acciones requeridas, ya que de un solo enlace no podrá hacer dichas
acciones con más libertad. Es decir, en una pila no hay quien guarde el anterior

Por explicacion y comprension queda entendido, que las “colas” solo exigen de un
“enlace” para hacer posible su construcción enlazando nodos y su operación de
eliminación de nodos.

Las “pilas” en cambio, necesitan de “Doble Enlace” entre nodos, con lo cual después
de su construcción, se hace posible la operación de “Eliminación”, de lo contrario
sería posible
Guarda dirección del nodo
dato
e e
: Crear Nodos
: eliminar 2
fin
ca
Guarda dirección del nodo
 Baldwin José Palencia Serrano

Import Java.io.*; - Construir pilas

: for(n=0; n<4; n++ ){
:
class nodo{ p=new nodo();
nodo ei; - Ingrese valor y asignar o dato
int dato;
nodo ed; if(n==0){
} cab=p;
public class Pilas { q=p;
public Static void main(.....){ }
: else{
: q.ed=p;
- Construir pilas p.ei=q;
- Mostrar pilas q=p;
}
- Eliminar nodos, pilas }
- Mostrar pilas fin=p;
}
}

- Mostrar pilas
p=cab;
for (n = 0; n < 4; n++) {
System.out.print("......"+p.dato);
p=p.ed;
}

- eliminar dos nodos

p=fin;
for(n=0; n<2; n++){
q=p.ei;
q.ed=null;
p=q;
fin=q;
}
- Mostrar pilas
p=cab;
for (n = 0; n < 2; n++) {
System.out.print("......"+p.dato);
p=p.ed;
}

import java.util.Scanner;
class nodo{
nodo ei;
int dato;
nodo ed;
 Baldwin José Palencia Serrano

}
public class Pilas {
public static void main(String[] args) {

Scanner tc=new Scanner(System.in);

int valor,n;

nodo p=new nodo();

nodo cab=new nodo();
nodo q=new nodo();
nodo fin=new nodo();

for (n = 0; n < 4; n++) {

p=new nodo();
System.out.print("Nodo: ");
valor=tc.nextInt();
p=p.ed;

if (n==0) {
cab=p;
q=p;
}

else {
q.ed=p;
p.ei=q;
q=p;
}
}

fin=p;
p=cab;

for (n = 0; n < 4; n++) {

System.out.println("Mostrar: "+p.dato);
p=p.ed;
}

p=fin;

}
}
Terminar el código

Es importante destacar que las colas se construyen y operan de manera que utilizan
un enlace simple entre nodos, lo que facilita su compresión y funcionamiento, las
pilas requieren un doble enlace entre nodos para permitir la operación de
eliminación una vez construidas. En ambos casos, la elección del tipo de enlace es
crucial para la correcta implementación y funcionalidad
 Baldwin José Palencia Serrano

Capítulo 6
Grafos:
Un grafo es una “Estructura de datos cerradas”, con lo cual se diferencia de las
denominadas “Lista” que son abiertas y lineales, y que crecen a la izquierda o la
derecha.

Los grafos configuran “mallas de nodos” que se caracterizan por finalizar en un nodo
confluyente; los grafos para su construcción, siempre se apoyan en una “Matriz de
adyacencia”, que permiten con antelación definir el tipo de estructura que se quiere;
la característica particular de los nodos de un grafo es la de tener 2 enlaces, pues
siempre es partir de un nodo se tendrá la posibilidad de derivar 2 nodos para
construir el grafo que se quiere.

con base a lo anterior, el programa en Java o C++ que deberá elaborarse para
construir el grafo,incorporara la “Matriz de adyacencia” que indicará la lógica de
enlaces de los nodos
Abstracci
pensemos que se Java:
quiere construir el Nod :
:
p=new nodo();
1 q=p;
Cuando
Nod Nod cab=p;
enlazan
2 3 un nodo
for(i=1; i<5; i++){
4 for(j=1; j<5; j++){posterio
if(n[i][j]){
p=new
Nod nodo();
Para el grafo
anterior , la matriz
1 2
1 0 1 Int n[]
0 0 []={{0,1,1,0},
2 0 0
0 0

En resumen a lo entendido y visto en otras clases como lo es matemáticas

discretas(complementando), los grafos son estructuras de datos que representan
relaciones entre elementos mediante nodos (vértices) y las aristas, que pueden ser
dirigidos o no, asimismo tiene la peculiar característica de doble enlace, ya que se
tendrá la posibilidad de derivar a la izquierda o a la derecha.