Documentos de Académico
Documentos de Profesional
Documentos de Cultura
3.- La declaración
struct NODO
{
char NOMBRE [20];
int CONTADOR;
struct NODO *IZQUIERDO;
struct NODO *DERECHO;
};
a. Está mal porque hace referencia a si misma (x)
b. Tiene un error de sintaxis (x)
c. No tiene la lógica (x)
d. Es una estructura válida y se aplica a la hoja de un árbol ( )
e. Puede producir un abrazo mortal ( )
15.- Un descriptor:
a. Puede ser reconocido o interpretado por un autómata de estados finitos (x)
b. Describe los campos de una estructura de datos (x)
c. Es una estructura de datos usual en aplicaciones de manejo de archivos y/o objetos
en sistemas operativos ( )
d. Es un concepto que aplica en el área de sistemas ERP y CRM ( )
e. Permite hacer búsquedas inteligentes en el archivo ( )
Tabla de métodos:
assign asigna elementos a la lista
back devuelve una referencia a el último componente de la lista
begin devuelve un iterator al principio de la lista
clear elimina todos los componentes de la lista
empty true si la lista está vacía
end devuelve un iterator al final de la lista
erase elimina componentes de la lista
front devuelve una referencia al primer componente de la lista
insert inserta componentes en la lista
max_size devuelve el número máximo de elementos soportados por la lista
merge une dos listas
pop_back elimina el último componente de la lista
pop_front elimina el primer componente de la lista
push_back añade un componente al final de la lista
push_front añade un componente al frente de la lista
rbegin devuelve un reverse_iterator hacia el final de la lista
remove elimina componentes de la lista
remove_if elimina condicionalmente componentes de la lista
rend devuelve un reverse_iterator hacia el inicio de la lista
resize cambia el tamaño de la lista
reverse pone al revés los componentes de la lista
size devuelve el número de componentes en la lista
sort ordena la lista
splice unión de dos listas
swap intercambia el contenido de una lista con el de otra
unique elimina componentes duplicados
INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA
Curso: Estructuras y Bases de Datos
Guía de Estudio – Segundo parcial
Dr. Felipe Rolando Menchaca García
class PilaArreglo
{
private Object[] arreglo;
private int tope;
private int MAX_ELEM=100; // maximo numero de elementos en la pila
public PilaArreglo()
{
arreglo=new Object[MAX_ELEM];
tope=-1; // inicialmente la pila esta vacía
}
public void apilar(Object x)
{
if (tope+1<MAX_ELEM) // si esta llena se produce OVERFLOW
{
tope++;
arreglo[tope]=x;
}
}
public Object desapilar()
{
if (!estaVacia()) // si esta vacia se produce UNDERFLOW
{
Object x=arreglo[tope];
tope--;
return x;
}
}
public Object tope()
{
if (!estaVacia()) // si esta vacia es un error
{
Object x=arreglo[tope];
return x;
}
INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA
Curso: Estructuras y Bases de Datos
Guía de Estudio – Segundo parcial
Dr. Felipe Rolando Menchaca García
}
public boolean estaVacia()
{
if (tope==-1)
{
return true;
}
else
{
return false;
}
}
}
20.- Diseñe una lista enlazada cuyos nodos tengan los
datos de nombre y género de las personas que forman un
grupo; diseñe además un método que a partir de esta lista,
construya otra lista que solo contenga las personas de sexo
femenino. Desarrolle el programa en lenguaje C++ y
pruébelo.
#include <stdio.h>
#include <stdlib.h>
/* Apuntador al archivo de entrada salida para guardar la Lista*/
FILE *ARCHIVO;
struct Nodo
{
int IDentidad, Edad;
char *Nombre[30], *Apellidos[50],*genero[10];
struct Nodo *sig ;
} *Inicio=NULL,*Otro, *Anterior, *Actual ,*gen,*femenino=NULL;
void CrearNodo()
{
puts("Procedo a crear un nodo");
}
void Visualizar()
{
int ID;
printf("Identidad del elemento que quieres buscar: \n\t");
scanf("%d", &ID);
Buscar(ID);
if ((Actual->IDentidad == ID) && (Actual!=NULL))
{
printf("Identidad:\t%d\n", Actual->IDentidad);
printf("Nombre:\t\t%s\n", Actual->Nombre);
printf("Apellidos:\t%s\n", Actual->Apellidos);
printf("Genero:\t\t%s\n", Actual->genero);
}
else
printf("No se encuentra el elemento en la Lista\n");
getchar();
}
void Listar()
{
Actual = Inicio;
gen=femenino ;
printf("Identificador\t Nombre\t\t Apellidos\t Genero\n");
while (Actual != NULL)
{
INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA
Curso: Estructuras y Bases de Datos
Guía de Estudio – Segundo parcial
Dr. Felipe Rolando Menchaca García
getchar();
}
int main()
{
int Comando;
while (Comando != 'S')
{
printf("\n\n\tMENU DE MANEJO DE LA LISTA ENCADENADA SIMPLE\n\n");
printf("\tN. Crear un Nodo o Registro\n");
printf("\tI. Insertar Nodo\n");
printf("\tE. Eliminar Nodo\n");
INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA
Curso: Estructuras y Bases de Datos
Guía de Estudio – Segundo parcial
Dr. Felipe Rolando Menchaca García
}
}
struct nodo{
char dato;
struct nodo *sgte;
};
/* Crear Nodo
--------------------------------------------------------------------*/
TPila crearNodo(char x)
{
TPila newNodo = new(struct nodo);
newNodo->dato = x;
return newNodo;
}
/* Apilar
--------------------------------------------------------------------*/
void push(TPila &top, char x)
{
TPila aux = crearNodo(x);
aux->sgte = top;
top = aux;
}
/* Desapilar
---------------------------------------------------------------------*/
char pop(TPila &top)
{
int c ;
TPila aux;
aux = top ;
c = aux->dato; // asignamos el primer vamor de la pila
top = aux->sgte ;
delete(aux);
return c;
}
/* Palindroma
---------------------------------------------------------------------*/
void verificarPalindroma( TPila &p, string cad)
INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA
Curso: Estructuras y Bases de Datos
Guía de Estudio – Segundo parcial
Dr. Felipe Rolando Menchaca García
{
TPila aux;
if(cad[i]== aux->dato)
pop( p );
else
break;
}
if( p==NULL)
cout << "\n\t La frase ES PALINDROMA..." << endl;
else
cout << "\n\t La frase NO ES PALINDROMA..." << endl;
}
/* FUNCION PRNCIPAL
-------------------------------------------------------------------*/
int main()
{
TPila pila = NULL; // creando Pila
string cad;
cout<<"\n\n ";
system("pause");
return 0;
}
/ Archivo pila_parentesis.c
#include <stdio.h>
#include <stdlib.h>
#include <stdio.h>
typedef struct nodo_s
{
char dato;
struct nodo_s *siguiente;
} nodo_t;
/*
Agrega un nodo al inicio de la lista ligada
*pila es el apuntador que apunta al primer nodo de la lista ligada (la cima de la pila)
*/
void push(ptrPila *pila, char x)
{
// Crea un nuevo nodo
ptrNodo nodo;
nodo = (ptrNodo)malloc(sizeof(nodo_t));
if (nodo != NULL)
{
nodo->dato = x;
// El apuntador nodo->siguiente va a apuntar al primer nodo de la lista ligada
nodo->siguiente = *pila;
INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA
Curso: Estructuras y Bases de Datos
Guía de Estudio – Segundo parcial
Dr. Felipe Rolando Menchaca García
// pila va a apuntar al nuevo nodo, con esto hacemos que el nuevo nodo sea ahora el
primer nodo de la lista ligada
*pila=nodo;
}
}
/*
Elimina el primer nodo de la lista ligada
*pila es el apuntador que apunta al primer nodo de la lista ligada (la cima de la pila)
*/
char pop(ptrPila *pila)
{
// Crea un nuevo nodo
ptrNodo nodo;
char x;
/*
Regresa 1 si no hay nodos en la lista ligada y cero en caso contrario
*pila es el apuntador que apunta al primer nodo de la lista ligada (la cima de la pila)
*/
int pila_vacia(ptrPila *pila)
{
return (*pila == NULL ? 1:0);
}
/*
Muestra los datos de los nodos
*/
void nodos_pila(ptrNodo nodo)
{
if (nodo == NULL)
INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA
Curso: Estructuras y Bases de Datos
Guía de Estudio – Segundo parcial
Dr. Felipe Rolando Menchaca García
int main()
{
char cadena[]="2*[x+q(3s-2)]/[((x+1)*x+(s-2))]";
int i=0;
// Muestra la cadena
printf("La cadena a analizar es la siguiente:\n\n");
while (cadena[i] != '\0')
{
printf("%c", cadena[i]);
i++;
}
printf("\n\n");
// Verifica si los paréntesis están balanceados
if (verifica_balance(cadena, '(', ')') == 1)
printf("Los paréntesis están balanceados\n");
else
printf("Los paréntesis NO están balanceados\n");
return 0;
}
INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA
Curso: Estructuras y Bases de Datos
Guía de Estudio – Segundo parcial
Dr. Felipe Rolando Menchaca García
// Recorre la cadena
while (expresion[x] != '\0' && balanceados == 1)
{
// Si el elemento coincide con el caracter que abre, lo ingresa en la pila
if (expresion[x]==cabre)
push(&pila, expresion[x]);
else
// Si el elemento coincide con el caracter que cierra, lo saca de la pila
if (expresion[x]==ccierra)
{
/* Si la pila está vacía, significa que los caracteres no están balanceados
porque se encontró un caracter que cierra sin que exista antes un caracter que
abre
*/
if (pila_vacia(&pila) != 1)
pop(&pila);
else
balanceados = 0;
}
x++;
}
return balanceados;
}
INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA
Curso: Estructuras y Bases de Datos
Guía de Estudio – Segundo parcial
Dr. Felipe Rolando Menchaca García
47.- La recursividad
a. Consiste en anidar una función, acción o estructura como elemento de si misma (x)
b. No se aplica a la declaración de estructuras de datos ( )
c. No se aplica a consultas a bases de datos ( )
d. No es usual en los algoritmos de manejo de estructuras de datos ( )
e. Se aplica a algoritmos de búsqueda y ordenamiento (x)
49.- Un nodo
a. Puede representar un dato o un operador al construir un árbol para calcular una
expresión (x)
b. Es un artificio matemático (x)
c. Es mínimo con estructuras de datos ( )
d. Es uno de los elementos del grafo (x)
e. Se visita con el recorrido en postorden ( )
Arboles binarios distintos, árbol binario similar, árbol binario equivalentes, arboles AVL
(balanceado), arboles B, árbol B+, árbol B*
*
/
b
b
a a - a
INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA
Curso: Estructuras y Bases de Datos
Guía de Estudio – Segundo parcial
Dr. Felipe Rolando Menchaca García
En la notación polaca inversa es al revés: primero están los operandos y después viene el
operador que va a realizar los cálculos sobre ellos.
Mientras que un árbol binario es una estructura de datos en la cual cada nodo puede tener
un hijo izquierdo y un hijo derecho. No pueden tener más de dos hijos (de ahí el nombre
"binario").
Int main( )
INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA
Curso: Estructuras y Bases de Datos
Guía de Estudio – Segundo parcial
Dr. Felipe Rolando Menchaca García
{
char x;
cout<< “inserte el operador: ”<<endl;
cin>>x;
switch x{
case ‘&’:
{cout<<”x es operador and”;
Int a, b;
cout<<”inserte valor de a:”
cin>>a
cout<<”inserte valor de b:”
cin>>b
if(a<0 && b<0)
{cout<<”Verdadero”;}
else if(b=0; || a=0;)
{cout<<”falso”;}
break}
case ‘|’:
{cout<<”x es operador or”;
Int a, b;
cout<<”inserte valor de a:”
cin>>a
cout<<”inserte valor de b:”
cin>>b
if(a<0 && b<0)
{cout<<”Verdadero”;}
else if(b=0; || a=0;)
{cout<<”verdadero”;}
break}
else if (a=0; && b=0;)
{cout<<”Falso”;}
case ‘!’:
{cout<<”x es operador not”;
Int a, b;
cout<<”inserte valor:”
if(a<0)
{cout<<”falso”;}
else if(a=0)
{cout<<”verdadero”;}
break}
INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA
Curso: Estructuras y Bases de Datos
Guía de Estudio – Segundo parcial
Dr. Felipe Rolando Menchaca García
2.- La recursividad
a. Consiste en anidar una función, acción o estructura como elemento de si misma (V)
b. No se aplica a la declaración de estructuras de datos (F)
c. No se aplica a consultas a bases de datos (F)
d. No es usual en los algoritmos de manejo de estructuras de datos (F)
e. Se aplica a algoritmos de búsqueda y ordenamiento (V)
4.- Un nodo
a. Puede representar un dato o un operador al construir un árbol para calcular una
expresión (V)
b. Es un artificio matemático (F)
c. Es mínimo con estructuras de datos (F)
d. Es uno de los elementos del grafo (V)
e. Se visita con el recorrido en postorden (F)
^ *
2
2 5 5 5
2 2 2
+
5
2
dos
if(comparar(etHijo,FINAL)){
Hijo=creaRaiz(etHijo);
insertar_hijo_izqda(n,Hijo,T);
Lectura2(hizqdaAr(n,T),T);
}
if(comparar(etHermano,FINAL)){
Hermano=creaRaiz(etHermano);
insertar_hermano_drcha(n,Hermano,T);
Lectura2(herdrchaAr(n,T),T);
}
}
tArbol Lectura()
{
tArbol T;
tEtiqueta et;
En la notación polaca inversa es al revés: primero están los operandos y después viene el
operador que va a realizar los cálculos sobre ellos.
Mientras que un árbol binario es una estructura de datos en la cual cada nodo puede tener
un hijo izquierdo y un hijo derecho. No pueden tener más de dos hijos (de ahí el nombre
"binario").