Unidad Profesional Interdisciplinaria
en Ingeniería y Tecnologías
Avanzadas
Alumno
Orozco Rojas Francisco
Unidad de Aprendizaje
Estructura de Datos
Profesor
M. en C. Niels Henrik Navarrete Manzanilla
Práctica 1
Listas Simples.
Ciudad de México; 19 de septiembre de 2023
ÍNDICE
CONTENIDO
INTRODUCCIÓN 3
DESARROLLO 3
DESCRIPCIÓN 3
ANÁLISIS 3
REQUERIMIENTOS FUNCIONALES 3
REQUERIMIENTOS NO FUNCIONALES 3
DIAGRAMAS 3
CÓDIGO 3
RESULTADOS 3
CONCLUSIONES 3
REFERENCIAS BIBLIOGRÁFICAS 4
Ciudad de México; 19 de septiembre de 2023
INTRODUCCIÓN
Las estructuras de datos, junto con el estudio de algoritmo, hacen
parte de los fundamentos de la programación y se escucha mucho
sobre la importancia de estudiar este tema. En este documento
vamos a hablar acerca de algunos problemas relacionado a pilas.
DESARROLLO
Descripción
--Pilas--
1. Escribir una función, copiar Pila, que copie el contenido de una pila en otra. La función
tendrá dos argumentos de tipo pila, uno para la pila fuente y otro para la pila destino.
Utilizar las operaciones definidas en una estructura tipo Pila.
2. Escribir un programa que construya una Pila de caracteres y esta misma procese cada
uno de los caracteres de una expresión que viene dada en una línea de caracteres. La
finalidad es verificar el equilibrio de paréntesis, llaves y corchetes.
Por ejemplo:
a) una expresión con paréntesis equilibrados.
(( a+ b) * 5 ) - 7
b) una expresión le falta un corchete:
2*[ ( a + b ) / 2.5 + x - 7 * y
Nota: El programa debe de dar como resultado si esta equilibrado los paréntesis en caso
contrario que diga que esta desequilibrado y que paréntesis falta
3. Se tiene un archivo de texto del cual se requiere determinar las frases que son
palíndromo. Para lo cual se ha de seguir la siguiente estrategia:
a) Considerar cada linea del texto una frase.
b) Añadir cada carácter de las frase a una pila y a la vez a una cola.
c) Extraer carácter a carácter y simultáneamente de la pila y de la cola. Su comparación
determina si es palíndromo o no.
4. Escribir una función que tenga como argumento dos colas del mismo tipo. Devuelva
cierto si las dos colas son idénticas.
Ciudad de México; 19 de septiembre de 2023
Código
EJERCICIO1 // Función para copiar una pila en otra
void copiarPila(Nodo* pilaFuente, Nodo**
#include <stdio.h> pilaDestino) {
#include <stdlib.h> Nodo* temp = NULL;
while (pilaFuente != NULL) {
// Estructura de la pila
push(&temp, pop(&pilaFuente));
typedef struct nodo {
int dato;
struct nodo* sgte;
} Nodo;
}
// Función para crear un nuevo nodo while (temp != NULL) {
Nodo* nuevonodo(int dato) { push(pilaDestino, pop(&temp));
Nodo* nodo = (Nodo*)malloc(sizeof(Nodo)); }
nodo->dato = dato; }
nodo->sgte = NULL;
return nodo; // Función principal
}
int main() {
// Función para agregar un nodo a la pila Nodo* pilaFuente = NULL;
void push(Nodo** cima, int dato) { Nodo* pilaDestino = NULL;
Nodo* nodo = nuevonodo(dato);
nodo->sgte = *cima; // Agregar elementos a la pila fuente
*cima = nodo; push(&pilaFuente, 1);
} push(&pilaFuente, 2);
push(&pilaFuente, 3);
// Función para eliminar un nodo de la pila
int pop(Nodo** cima) {
if (*cima == NULL) { // Copiar la pila fuente en la pila destino
printf("La pila está vacía\n"); copiarPila(pilaFuente, &pilaDestino);
return -1;
} // Imprimir la pila destino
int dato = (*cima)->dato; printf("Pila Fuente:\n");
Nodo* temp = *cima; imprimirpila(pilaFuente);
*cima = (*cima)->sgte;
printf("Pila Destino:\n");
free(temp);
return dato; imprimirpila(pilaDestino);
}
void imprimirpila(Nodo* cima){ }
printf("Pila:");
while(cima!=NULL){
printf("%d",cima->dato);
cima = cima->sgte;
}
printf("\n");
Ciudad de México; 19 de septiembre de 2023
Ejercicio2
#include <stdio.h> // Función para verificar el equilibrio de paréntesis, llaves y corchetes
#include <stdlib.h> void verificarEquilibrio(char* expresion) {
Node* pila = NULL;
// Estructura de la pila
typedef struct node { for (int i = 0; expresion[i] != '\0'; i++) {
char data;
if (expresion[i] == '(' || expresion[i] == '{' || expresion[i] == '[') {
struct node* next;
push(&pila, expresion[i]);
} Node;
} else if (expresion[i] == ')' || expresion[i] == '}' || expresion[i] ==
// Función para crear un nuevo nodo ']') {
Node* new_node(char data) { char caracter = pop(&pila);
Node* node = (Node*)malloc(sizeof(Node)); if ((expresion[i] == ')' && caracter != '(') ||
node->data = data; (expresion[i] == '}' && caracter != '{') ||
node->next = NULL; (expresion[i] == ']' && caracter != '[')) {
return node;
printf("La expresion esta desequilibrada. Falta el caracter
}
'%c'\n", caracter);
// Función para agregar un nodo a la pila return;
void push(Node** top, char data) { }
Node* node = new_node(data); }
node->next = *top; }
*top = node;
} if (pila == NULL) {
printf("La expresion esta equilibrada\n");
// Función para eliminar un nodo de la pila
char pop(Node** top) { } else {
if (*top == NULL) { printf("La expresion esta desequilibrada. Falta el caracter '%c'\n",
printf("La pila esta vacia\n"); pila->data);
return '\0'; }
} }
char data = (*top)->data;
Node* temp = *top;
// Función principal
*top = (*top)->next;
int main() {
free(temp);
return data; char expresion[100];
}
printf("Ingrese una expresion: ");
fgets(expresion, sizeof(expresion), stdin);
verificarEquilibrio(expresion);
return 0;
}
Ciudad de México; 19 de septiembre de 2023
Ejercicio3
#include <stdio.h> // Función principal
#include <stdlib.h> int main() {
#include <string.h> FILE* archivo;
char linea[100];
// Estructura de la pila
typedef struct node {
// Abrir el archivo de texto
char data;
archivo = fopen("[Link]", "r");
struct node* next;
} Node; if (archivo == NULL) {
printf("No se pudo abrir el archivo\n");
// Función para crear un nuevo nodo return 1;
Node* new_node(char data) { }
Node* node = (Node*)malloc(sizeof(Node));
node->data = data; // Leer cada línea del archivo
node->next = NULL;
while (fgets(linea, sizeof(linea), archivo)) {
return node;
} // Eliminar el salto de línea al final de la línea
linea[strcspn(linea, "\n")] = '\0';
// Función para agregar un nodo a la pila
void push(Node** top, char data) { // Verificar si la línea es un palíndromo
Node* node = new_node(data); if (esPalindromo(linea)) {
node->next = *top; printf("La frase '%s' es un palindromo\n", linea);
*top = node;
} else {
}
printf("La frase '%s' no es un palindromo\n", linea);
// Función para eliminar un nodo de la pila }
char pop(Node** top) { }
if (*top == NULL) {
printf("La pila está vacía\n"); // Cerrar el archivo
return '\0'; fclose(archivo);
}
char data = (*top)->data;
return 0;
Node* temp = *top;
*top = (*top)->next; }
free(temp);
return data;
}
// Función para verificar si una frase es palíndromo
int esPalindromo(char* frase) {
Node* pila = NULL;
int longitud = strlen(frase);
// Añadir cada carácter de la frase a la pila
for (int i = 0; i < longitud; i++) {
push(&pila, frase[i]);
}
// Extraer carácter a carácter y comparar con la frase original
for (int i = 0; i < longitud; i++) {
char caracter = pop(&pila);
if (caracter != frase[i]) {
return 0; // No es palíndromo
}
}
return 1; // Es palíndromo
}
Ciudad de México; 19 de septiembre de 2023
// Función para comparar dos colas y verificar si son idénticas
int sonColasIdenticas(Queue* cola1, Queue* cola2) {
Ejercicio4 if (estaVacia(cola1) && estaVacia(cola2)) {
return 1; // Ambas colas están vacías, son idénticas
}
#include <stdio.h>
#include <stdlib.h>
if (estaVacia(cola1) || estaVacia(cola2)) {
// Estructura de un nodo return 0; // Una de las colas está vacía, no son idénticas
typedef struct node { }
int data; Node* temp1 = cola1->front;
struct node* next; Node* temp2 = cola2->front;
} Node; while (temp1 != NULL && temp2 != NULL) {
if (temp1->data != temp2->data) {
// Estructura de la cola
return 0; // Los elementos son diferentes, no son
typedef struct {
Node* front; idénticas
Node* rear; }
} Queue; temp1 = temp1->next;
temp2 = temp2->next;
// Función para crear una nueva cola vacía }
Queue* crearCola() {
Queue* cola = (Queue*)malloc(sizeof(Queue));
if (temp1 == NULL && temp2 == NULL) {
cola->front = NULL;
cola->rear = NULL; return 1; // Ambas colas tienen los mismos elementos,
return cola; son idénticas
} } else {
return 0; // Las colas tienen diferente cantidad de
// Función para verificar si una cola está vacía elementos, no son idénticas
int estaVacia(Queue* cola) { }
return (cola->front == NULL);
}
}
// Función para agregar un elemento al final de la cola // Función principal
void enqueue(Queue* cola, int data) { int main() {
Node* newNode = (Node*)malloc(sizeof(Node)); Queue* cola1 = crearCola();
newNode->data = data; Queue* cola2 = crearCola();
newNode->next = NULL;
// Agregar elementos a la cola 1
if (estaVacia(cola)) {
enqueue(cola1, 1);
cola->front = newNode;
enqueue(cola1, 2);
cola->rear = newNode;
} else { enqueue(cola1, 3);
cola->rear->next = newNode;
cola->rear = newNode; // Agregar elementos a la cola 2
} enqueue(cola2, 1);
} enqueue(cola2, 2);
// Función para eliminar el primer elemento de la cola enqueue(cola2, 3);
int dequeue(Queue* cola) {
if (estaVacia(cola)) { // Comparar las colas y verificar si son idénticas
printf("La cola esta vacia\n"); if (sonColasIdenticas(cola1, cola2)) {
return -1; printf("Las colas son identicas\n");
} } else {
Node* temp = cola->front; printf("Las colas no son identicas\n");
int data = temp->data; }
cola->front = cola->front->next;
if (cola->front == NULL) { return 0;
cola->rear = NULL; }
}
free(temp);
return data; }
Ciudad de México; 19 de septiembre de 2023
RESULTADO
Ejercicio1
Ejercio2
Ejercicio3
Ejercicio4
Ciudad de México; 19 de septiembre de 2023
CONCLUSIONES
REFERENCIAS BIBLIOGRÁFICAS
Ciudad de México; 19 de septiembre de 2023
