EstructurasDatosLigadas

ALUMNO: ROLANDO ORTIZ HERBAS – CARRERA: LIC.
MATEMATICAS UNADM
Materia: Computación I
Alumno: Rolando Ortiz Herbas
e-mail: maasher7@hotmail.com
rolandoortiz@nube.unadmexico.mx
Grupo: MT-MCOM1-1902-B2-001
Matricula: ES1821014044
Maestra: José Luis Mondragón Diego
Fecha: 05-Oct-2019
Unidad 1 A2 Estructuras de datos ligadas
Carrera: Lic. en Matemáticas
Página 1 de 15
ALUMNO: ROLANDO ORTIZ HERBAS – CARRERA: LIC. MATEMATICAS UNADM
Actividad 3. . Estructuras de datos.

A partir de la página 37 en el contenido nuclear de la unidad 1 te dan ejemplos
de las diferentes estructuras de datos como:
• Listas ligadas
• Colas
• Pilas
• Arboles
Se considera que el trabajo cumpla con:

• Portada, limpieza, fuentes de consulta, captura de pantalla de la evidencia de
la compilación de cada estructura de datos(Listas ligadas, Colas, Pilas, Arboles),
conclusión que describa la diferencia entre cada estructura de datos.
1. Listas ligadas .-
Página 2 de 15
El esqueleto del programa es :
Página 3 de 15
Programa fuente de Lista encadenada en Python

# Lista encadenada , Alumno: Rolando Ortiz Herbas , Carrera de Matemáticas , Fecha: 14 de Oct 2019
# Definiremos un nodo que contiene información y un apuntador o pointer
# Creamos la clase nodo
class nodo:
def __init__(self, regdato = None, siguientenodo = None):
self.regdato = regdato
self.siguientenodo = siguientenodo
Página 4 de 15
# Creamos la clase lista_encadenada
class lista_encadenada:
def __init__(self):
self.head = None
# Método para agregar elementos en el frente de la lista encadenada
def agregar_al_frente(self, regdato):
self.head = nodo(regdato=regdato, siguientenodo=self.head)
# Método para verificar si la lista esta vacia
def is_empty(self):
return self.head == None
# Método para agregar elementos al final de la lista
def agregar_al_final(self, regdato):
if not self.head:
self.head = nodo(regdato=regdato)
return
curr = self.head
while curr.siguientenodo:
curr = curr.siguientenodo
curr.siguientenodo = nodo(regdato=regdato)
# Método para imprimir la lista de nodos
def imprime_lista( self ):
nodo = self.head
while nodo != None:
print(nodo.regdato,end=" --> ")
nodo = nodo.siguientenodo
# Método para eliminar nodos de la lista
def eliminar_nodo(self, key):
Página 5 de 15
curr = self.head
prev = None
while curr and curr.regdato != key:
prev = curr
if prev is None:
self.head = curr.siguientenodo
elif curr:
prev.siguientenodo = curr.siguientenodo
curr.siguientenodo = None
# Método para obtener el ultimo nodo
def obtener_ultimo_nodo(self):
temp = self.head
while(temp.siguientenodo is not None):
temp = temp.siguientenodo
return temp.regdato
ls = lista_encadenada() # Instancia de la clase
# Agregamos elementos al frente de la lista
print("\n Se va a agregar nodos al final de la lista \n")
ls.agregar_al_frente(79)
ls.imprime_lista() # Imprimimos la lista de nodos
print("\n")
# Agregamos elementos al final de la lista
print("\n Se va a agregar nodos al principio de la lista \n")
ls.agregar_al_final(81)
Página 6 de 15
# Imprimimos la lista de nodos
ls.imprime_lista()
print("\n")
# eliminamos nodo con info = 797
print("\n Se va a eliminar un nodo cualquiera de la lista \n")
x = int(input("Dar numero que se eliminará : "))
ls.eliminar_nodo(x)
print("\n\n Lista despues de eliminar :", x, "\n")
ls.imprime_lista()
print("\n")
2. Colas.-
Una Cola de tipo FIFO (First Input First Output) , opera de tal manera que lo
primero que entra a la lista es lo primero que sale.
El programa para Colas es el anterior con 2 funciones adicionales, que son las
siguiente:
2.1) eliminar_fifo , que elimina nodo al principio de la lista.
2.2) agregar_fifo , que agrega un nodo al final de la lista
# eliminar FIFO
def eliminar_fifo(self, key):
curr = self.head
prev = None
while curr and curr.regdato != key:
prev = curr
Página 7 de 15
if prev is None:
elif curr:
prev.siguientenodo = curr.siguientenodo
curr.siguientenodo = None
# Agregar FIFO
def agregar_fifo(self, regdato):
La parte principal es:
Página 8 de 15
3. Pilas.-
Una Pila es del tipo LIFO (Last Input First Output) , ultimo en entrar es el
primero en salir. A este tipo de estructura también se le llama Stack.
Las operaciones básicas que se implementó son:
3.1) agregar_lifo
3.2) pop_lifo
El código para estas funciones es la siguiente:

Página 9 de 15
# Método para agregar LIFO

def agregar_lifo(self, regdato):
# metodo pop LIFO

def pop_lifo(self):
curr = self.head
if curr.siguientenodo is not None:
Página 10 de 15
Página 11 de 15
Página 12 de 15
4. Arboles.-
Se va a enfocar en arboles binarios y solo voy a hacer 2 funciones
4.1) Formación de un árbol binario (función agregar)
4.2) Recorrido del árbol en inorden (función inorden)
Continua siguiente pagina………….
Página 13 de 15
Página 14 de 15
Bibliografía (formato APA):

• Apuntes UnadM, Computación I, 2019, UNADM.
• J. Hopcroft - R. Motwani - J. Ullman, Teoría de Autómatas, Lenguajes y
Computación, 2007, Pearson
• D. Knuth, El arte de programar ordenadores Vol. I,1990, Reverté
• N. Wirth, Algoritmos + Estructura de Datos = Programas, 1993, Prentice Hall
Página 15 de 15

EstructurasDatosLigadas

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

EstructurasDatosLigadas

Загружено:

Авторское право:

Доступные форматы

ALUMNO: ROLANDO ORTIZ HERBAS – CARRERA: LIC.

Alumno: Rolando Ortiz Herbas

Maestra: José Luis Mondragón Diego

Unidad 1 A2 Estructuras de datos ligadas

Carrera: Lic. en Matemáticas

Actividad 3. . Estructuras de datos.

Se considera que el trabajo cumpla con:

El esqueleto del programa es :

Programa fuente de Lista encadenada en Python

# Definiremos un nodo que contiene información y un apuntador o pointer

# Creamos la clase nodo

def __init__(self, regdato = None, siguientenodo = None):

# Creamos la clase lista_encadenada

# Método para agregar elementos en el frente de la lista encadenada

def agregar_al_frente(self, regdato):

self.head = nodo(regdato=regdato, siguientenodo=self.head)

# Método para verificar si la lista esta vacia

return self.head == None

# Método para agregar elementos al final de la lista

def agregar_al_final(self, regdato):

# Método para imprimir la lista de nodos

def imprime_lista( self ):

while nodo != None:

print(nodo.regdato,end=" --> ")

# Método para eliminar nodos de la lista

def eliminar_nodo(self, key):

while curr and curr.regdato != key:

# Método para obtener el ultimo nodo

while(temp.siguientenodo is not None):

ls = lista_encadenada() # Instancia de la clase

# Agregamos elementos al frente de la lista

print("\n Se va a agregar nodos al final de la lista \n")

ls.imprime_lista() # Imprimimos la lista de nodos

# Agregamos elementos al final de la lista

print("\n Se va a agregar nodos al principio de la lista \n")

# Imprimimos la lista de nodos

# eliminamos nodo con info = 797

print("\n Se va a eliminar un nodo cualquiera de la lista \n")

x = int(input("Dar numero que se eliminará : "))

print("\n\n Lista despues de eliminar :", x, "\n")

def eliminar_fifo(self, key):

while curr and curr.regdato != key:

def agregar_fifo(self, regdato):

self.head = nodo(regdato=regdato, siguientenodo=self.head)

La parte principal es:

El código para estas funciones es la siguiente:

# Método para agregar LIFO

# metodo pop LIFO

Continua siguiente pagina………….

Bibliografía (formato APA):

Вам также может понравиться

def init(self, regdato = None, siguientenodo = None):