Sie sind auf Seite 1von 9

ESTRUCTURA DE DATOS - SEGUNDO PARCIAL

RESOLUCION DEL SEGUNDO PARCIAL

1) Modifique la implementación básica del TDA bicola (con salida restringida) de modo que se construya
únicamente con 3 arreglos (MÁX 7 c/u). Considere que los indicadores de la cola se almacenarán en las
primeras posiciones del tercer arreglo y que se priorizará el espacio de almacenamiento. Defina las
estructuras de datos solicitadas e implemente únicamente las operaciones iniciar_bicola, agregar_bicola,
bicola_llena y anterior.

const int MAX=7;


typedef int contenedor[MAX];
typedef struct bicola{
contenedor datos1;
contenedor datos2;
contenedor datos3;
};

void iniciar_bicola(bicola &q)


{
q.datos3[0]=MAX*3-1;//Final
q.datos3[1]=MAX*3-1;//Frente
q.datos3[2]=0;//Contador
}

void agregar_bicola(bicola &q, int nuevo, bool final)


{
if(bicola_llena(q)==true)
cout<<"No hay espacio"<<endl;
else{
if(final==true){
q.datos3[0]=next(q.datos3[0]);
if(q.datos3[0]<MAX)
q.datos1[q.datos3[0]]=nuevo;
else if(q.datos3[0]<MAX*2)
q.datos2[q.datos3[0]-MAX]=nuevo;
else
q.datos3[q.datos3[0]-MAX*2]=nuevo;
}
else{
if(q.datos3[1]<MAX)
q.datos1[q.datos3[1]]=nuevo;
else if(q.datos3[1]<MAX*2)
q.datos2[q.datos3[1]-MAX]=nuevo;
else
q.datos3[q.datos3[1]-2*MAX]=nuevo;
q.datos3[1]=anterior(q.datos3[1]);
}
q.datos3[2]++;
}
}

bool bicola_llena(bicola q)
{
return q.datos3[2]==MAX*3-3;
}

1
ESTRUCTURA DE DATOS - SEGUNDO PARCIAL

int anterior(int indice)


{
if(indice==0)
indice=MAX*3-1;
else{
if(indice==17)
indice=14;
indice--;
}
return indice;
}

2) Aplicando las operaciones básicas del TDA cola diseñe un algoritmo que calcule la suma de los dígitos
de un valor entero ingresado por el usuario. Para ello considere que un número entero puede
descomponerse en sus dígitos dividiéndolo sucesivamente por 10 (cada cociente obtenido vuelve a
dividirse por 10, guardándose los restos). Defina las estructuras de datos utilizadas, y recuerde que no
debe desarrollar las operaciones del TDA cola sólo invocarlas.

const int MAX=20;


typedef int contenedor[MAX];
typedef struct tcola{
contenedor datos;
int frente;
int final;
};

int algoritmo(int n)
{
tcola p;
init_queue(q);
while(n>0){
push_queue(q,n%10);
n/=10;
}
while(empty_queue(q)==false)
n+=pop_queue(q);
return n;
}

3) Dado el siguiente árbol:


a) defina las estructuras de datos que permitan
representarlo
b) obtenga la representación parentizada del árbol
c) implemente la operación altura que calcule la altura
del árbol
d) implemente la operación contar_nodos que calcule
la cantidad de nodos del árbol

a)
typedef struct tarbol *arbol;
typedef struct tarbol{
int dato;
arbol izq;
arbol medio;
arbol der;
};

2
ESTRUCTURA DE DATOS - SEGUNDO PARCIAL

b)
Parentizada: 6(2(5,1,9),3,4(8(11,10,7)))

c)
int altura(arbol a)
{
int izquierda, medio, derecha;
if(a==NULL)
return 0;
else{
izquierda=altura(a->izq);
medio=altura(a->medio);
derecha=altura(a->der);
if(izquierda>medio && izquierda>derecha)
return izquierda+1;
else if(medio>izquierda && medio>derecha)
return medio+1;
else
return derecha+1;
}
}

d)
int contar_nodos(arbol a)
{
if(a!=NULL)
return 1+contar_nodos(a->izq)+contar_nodos(a->medio)+contar_nodos(a->der);
}

4) Dada la secuencia numérica 19, 32, 24, 9, 22, 13, 16, 12, 6, 10 desarrolle gráficamente la inserción de
los valores en un árbol AVL. Indique los casos de rebalanceo aplicados y el intercambio de punteros
realizado.

Insertar 19 Insertar 32 Insertar 24(Desbalanceado)


Caso RL
2 p p->der=r->izq;
0 1 q->izq=r->der;
19 19 19 r->izq=p;
-1 q r->der=q;
0 p=r;

32 32

0 r
24

Insertar 9 Insertar 22 Insertar 13(Desbalanceado)

-1 -1 p -2
0
24 24 24
q
-1 0 0 -1 0
0 0 19 32 32
19 32 19

0 0 1 0
0 22
9 9 9 22

0 Caso LL
p->izq=q->der;
13 q->der=p;
p=q;
3
ESTRUCTURA DE DATOS - SEGUNDO PARCIAL

Insertar 16(Desbalanceado) Insertar 12

0 -1
19 Caso RR 19
0 p->der=q->izq;
12 q->izq=p; -1 0
p 9 24 p=q; 13 24
1
0 0 0 1 0 0 0
q
13 22 32 9 16 22 32

0
0
12
16

Insertar 6 Insertar 10(Desbalanceado)

-1 0
19 19

-1 0 2 0
13 24 p 13 24

0 0 0 0 1 0 0 0
q
9 16 22 32 9 16 22 32

0r -1
0 0 Caso LR
6 12 6 12 q->der=r->izq;
p->izq=r->der;
r->izq=q;
0 r->der=p;
10 p=r;

Arbol AVL

-1
19

0 0
12 24

0 1 0 0
9 13 22 32

0 0 0
6 10 16

4
ESTRUCTURA DE DATOS - SEGUNDO PARCIAL

5) Dada la serie de numérica 24, 50, 31, 21, 22, 18, 39, 42, 12, 41, 34, 26, 11, 15, 20, 28, 38, 52, 43, 47
construya el correspondiente árbol B de orden 2, indicando los casos en que se produzca desborde.

Insertar 24, 50, 31, 21, 22(Desborde de página)

21 24 31 50

22

División de página

24

21 22 31 50

Insertar 18, 39, 42, 12, 41(Desborde de página)

24

12 18 21 22 31 39 42 50
41
División de página

24 41

12 18 21 22 31 39 42 50

Insertar 34, 26, 11(Desborde de página)

24 41

12 18 21 22 26 31 34 39 42 50

11
División de página

18 24 41

11 12 21 22 26 31 34 39 42 50

5
ESTRUCTURA DE DATOS - SEGUNDO PARCIAL

Insertar 15, 20, 28(Desborde de página)

18 24 41

11 12 15 20 21 22 26 31 34 39 42 50

28

División de página

18 24 31 41

11 12 15 20 21 22 26 28 34 39 42 50

Insertar 38, 52, 43, 47(Desborde de página)

18 24 31 41

11 12 15 20 21 22 26 28 34 38 39 42 43 50 52

47

División de página(Desborde de página)

18 24 31 41
47

11 12 15 20 21 22 26 28 34 38 39 42 43 50 52

División de página

31

18 24 41 47

11 12 15 20 21 22 26 28 34 38 39 42 43 50 52

6
ESTRUCTURA DE DATOS - SEGUNDO PARCIAL

6) Dado el siguiente árbol B indique el orden del árbol y elimine los valores 45, 17 y 72, aplicando el
criterio MENOR DE MAYORES cuando corresponda. Además identifique los casos en los que se produzca
subocupación/desborde.

ELIMINAR 45

56

17 34 72 85

1 16 22 31 33 45 51 60 65 73 81 90 92 96
SUBOCUPACION-DESBORDE

ELIMINAR 17

56

17 33 72 85

1 16 22 31 34 51 60 65 73 81 90 92 96

MENOR DE MAYORES

SUBOCUPACION

56

22 72 85
SUBOCUPACION

1 16 31 33 34 51 60 65 73 81 90 92 96

ELIMINAR 72

22 56 72 85

1 16 31 33 34 51 60 65 73 81 90 92 96

MENOR DE MAYORES
SUBOCUPACION

7
ESTRUCTURA DE DATOS - SEGUNDO PARCIAL

Arbol B

22 56 73 90

1 16 31 33 34 51 60 65 81 85 92 96

7) El administrador de suministros del ejército nacional necesita un sistema informático que planifique el circuito
de distribución para 750 regimientos. El sistema debe planificar la distribución a partir de la siguiente
información: id de regimiento, ubicación (localidad, provincia), cantidad de soldados, proximidad de regimientos,
consumo mensual de suministros, cantidad de estaciones de reabastecimiento del camino y costo del transporte
usado. Por tanto, se solicita a) defina la estructura de datos que permita modelar la situación planteada y b)
implemente un algoritmo que inicialice la estructura.

const int MAX=250;


typedef struct ubicacion{
char localidad[32];
char provincia[32];
};
typedef struct arco *parco;
typedef struct arco{
int destino;
int cantidad_estaciones;
float costo_transporte;
parco sigarco;
};
typedef struct regimiento{
int id_regimiento;
ubicacion del_regimiento;
int cantidad_soldados;
float consumo_mensual;
parco lista_regimientos;
};
typedef regimiento ejercito[MAX];

void iniciar(ejercito &grafo)


{
for(int i=0;i<MAX;i++)
grafo[i].lista_regimientos=NULL;
}

8) Dado el siguiente grafo, realice el recorrido a profundidad a partir del nodo 3. Indique los pasos
realizados para el recorrido utilizando la estructura de datos auxiliar.

8
ESTRUCTURA DE DATOS - SEGUNDO PARCIAL

CRITERIO: IZQUIERDA, DERECHA, ARRIBA, ABAJO


Pila de Datos

Proceso: 1

Proceso: 2 3

Proceso: 3 3 4 8 1 11

Proceso: 3 11 4 4 8 1 10

Proceso: 3 11 10 5 4 8 1 9

Proceso: 3 11 10 9 6 4 8 1 6

Proceso: 3 11 10 9 6 7 4 8 1 5 7

Proceso: 3 11 10 9 6 7 8 4 8 1 5 2

Proceso: 3 11 10 9 6 7 2 9 4 8 1 5

Proceso: 3 11 10 9 6 7 2 5 10 4 8 1

Proceso: 3 11 10 9 6 7 2 5 1 11 4 8

Proceso: 3 11 10 9 6 7 2 5 1 8 12 4

Proceso: 3 11 10 9 6 7 2 5 1 8 4 13