Conocer la altura de un ABB da información sobre el número de datos que contiene. VERDADERO FALSO.
Dos árboles ABB equivalentes pueden tener diferente altura, raíz y hojas. VERDADERO FALSO.
Un árbol binario que representa expresiones matemáticas se resuelve mediante un recorrido en postorden. VERDADERO FALSO.
Para obtener los datos ordenados de un ABB se hace un recorrido en preorden. VERDADERO FALSO.
Todo proceso recursivo que opere un ABB se puede resolver de forma iterativa mediante una pila de punteros a nodos de tipo ABB. VERDADERO FALSO.
Al insertar la siguiente secuencia en un ABB: {4, 3, 7, 12, 2, 6, 5, 13}, el borrado del 12 implica una llamada a la función borraMin(). VERDADERO FALSO.
Para recorrer un árbol binario por niveles se necesita una cola. Este recorrido pasaría primero por la raíz, luego por raíz->izq, luego por raiz->der, raiz->izq->izq, raíz->izq->der, etc... VERDADERO FALSO.
Los recorridos recursivos Preorden, Inorden y Postorden permite iterar sobre los árboles hacia delante y hacia detrás. VERDADERO FALSO.
Implementar un heap mediante nodos y punteros al igual que el resto de árboles binarios tiene dos graves inconvenientes: consume mucha más memoria y la inserción en la siguiente posición libre del último nivel (durante los push) o el borrado de la última posición del último nivel (durante los pop) no podrían implementarse en tiempo constante. VERDADERO FALSO.
La operación pop() es más eficiente en un heap que en una cola con prioridad montada mediante una lista de listas. VERDADERO FALSO.
La siguiente tabla referente a la eficiencia de las distintas implementaciones de una cola con prioridad es correcta(n es el número de datos y p el número de valores de prioridad distintos). VERDADERO FALSO.
Un heap permite obtener el dato con menor prioridad en O(1). VERDADERO FALSO.
Un heap es un árbol binario equilibrado en altura. VERDADERO FALSO.
La unión de dos conjuntos disjuntos de tamaño n y m puede llevarse a cabo mediante una operación en O(1). VERDADERO FALSO.
La operación busca() en conjuntos disjuntos es O(n) y gamma(1). VERDADERO FALSO.
Un vector estático puede implementar eficientemente a pilas y colas estáticas. VERDADERO FALSO.
Una lista simplemente enlazada puede implementar eficientemente a pilas y colas dinámicas. VERDADERO FALSO.
Un deque puede implementar eficientemente a pilas y colas dinámicas. VERDADERO FALSO.
Se usa una pila para resolver aquellos procesos recursivos que agotan la pila. VERDADERO FALSO.
Una cola con prioridad siempre tendrá un push() en O(1) independientemente de la implementación concreta (vectores, vector listas o listas de listas) VERDADERO FALSO.
Una stack o una queue se implementa por defecto sobre un std:list pero se puede cambiar en ambos casos el contenedor. VERDADERO FALSO.
Para hacer que una priority_queue de STL considere como dato más prioritario al mayor, se debe definir con el operador greate. VERDADERO FALSO.
Necesito una pila para eliminar la recursividad de la sucesión de Fibonacci. VERDADERO FALSO.
El contenedor list<T> de STL implementa el operador [] para acceder directamente al dato almacenado en una posición arbitraria. VERDADERO FALSO.
Se ha pensado en implementar una matriz para almacenar todos los jugadores...... VERDADERO FALSO.
Para simular una lista circular en el que los datos entran siemprepor el mismo lugar pero salen en cualquier momento es igualmente eficiente utilizar una lista (list) que un vector de STL. VERDADERO FALSO.
Se ha utilizado la siguiente estructura de datos para implementar un editos de texto interactivo .... VERDADERO FALSO.
Sean dos conjuntos a y b de palabras, implementados usando dos vectores de STL instanciados al tipo string. Entonces obtener el vector c = a intersección b requiere tiempo cuadrático. VERDADERO FALSO.
La inserción de un dato d al principio de un vector v de STL mediante v.insert(v.begin(),d) requiere tiempo O(1). VERDADERO FALSO.
Una lista doblemente enlazada permite realizar búsquedas binarias en tiempo O(log n) si los datos se encuentran ordenados. VERDADERO FALSO.
Iterar sobre un vector dinámico es siempre más rápido que sobre una lista enlazada (simple o doble). VERDADERO FALSO.
El siguiente código insertar correctamente en un caso genérico (lista con datos), un nuevo nodo apuntado por p por delante de la posición del nodo apuntado por q en una lista doblemente enlazada y circular.
p->siguiente = q;
p->anterior = q->anterior;
q->anterior = p;
p->anterior->siguiente=q; VERDADERO FALSO.
Transferir todos los nodos de una lista doblemente enlazada l1 al final de otrs losta enlazada l2 requiere tiempo O(1). (l1 queda vacía después) VERDADERO FALSO.
El tiempo para eliminar un dato en una posición arbitraria de una lista es lineal. VERDADERO FALSO.
El tiempo para eliminar un dato en una posición apuntada por un iterador es lineal. VERDADERO FALSO.
Para eliminar e insertar un dato en posiciones intermedias de una lista se necesita un puntero a la posición anterior al dato que se va a insertar/borrar. VERDADERO FALSO.
Se puede realizar la operación merge_sort entre dos listas ordenadas en tiempo O(n+m), siendo n y m los tamaños respectivos de ambas listas. VERDADERO FALSO.
Un dato que permanece en una lista cambia su posición a veces al sufrir la lista inserciones y borrados. VERDADERO FALSO.
El operdaor de asignación de la clase Matriz<T>::operador= debe siempre destruir la matriz destino de la asignación. VERDADERO FALSO.
El operador de la clase Matriz<T>::operator+= devuelve el objeto resultado por copia. VERDADERO FALSO.
La implementación de conjuntos mediante vectores realiza las intersección en tiempo lineal. VERDADERO FALSO.
El problema que poseen los conjuntos de bits es que el ID de un elemnto debe ser un entero desde 0 hasta el tamaño del conjunto -1. Para convertir en un ID genérico se necesita otra EEDD. VERDADERO FALSO.
Para almacenar 3841 datos en un conjunto de bits, debo crear un buffer de 480 bytes. VERDADERO FALSO.
a.intersect(b+a) == a es correcto. VERDADERO FALSO.
El resultado de realizar esta operación: char mascara = 1 <<(500%8); es 0000100. VERDADERO FALSO.
Si esta sentencia es valida : Entonces micontainer puede tener esta definición: map<int, vector<int> >micontainer;
int nuevoValor=7;
it=miconatainer.find(clave);
(*it).second[i]=&nuevoValor VERDADERO FALSO.
El objeto mc se define como; map<int, miClase>mc; ¿Se podria realizar?
map<int, miClase>::iterator it = mc.begin(); +(it).first = 5; VERDADERO FALSO.
El contenedor de STL mas adecuado para un restaurantes es multimap<Fecha, Reserva> VERDADERO FALSO.
Definición matriz dispersa es: vector<list <int> > matrizDis; VERDADERO FALSO.
La siguiente sentencia: v[maria]=dato; es valida si v es un deque. VERDADERO FALSO.
Un mapa definido como:<int, ClaseA> puede sustituirse por set<ClaseA> si la ClaseA tiene sobrecargado el operador < y la clave entera forma parte dela clase ClaseA. VERDADERO FALSO.
Si en el caso anterior el operador < ya está usandose para otro tipo de ordenación sobre ClaseA, entonces se puede usar la definición: set <ClaseA, comparaClaseA>, siendo comparaClaseA una clase de comparación para ClaseA. VERDADERO FALSO.
Un vector dinámico es una estructura de datos básica que Puede ser utilizada en la implementación de asociaciones y composiciones múltiples cuando no hay restricciones o necesidades especiales en las mismas. VERDADERO FALSO.
Un dato almacenado en un vector dinámico que permanece en dicha estructura de datos a lo largo de todo su ciclo de vida nunca cambia su posición de memoria. VERDADERO FALSO.
La siguiente definición de vector estático necesita de constructor copia y operador de asignación:
template<typename T> class MiVect{
int tama;
T *v;
public:
MiVect(int n){ v=new T[tama=n]; }
...
}; VERDADERO FALSO.
La misma clase anterior debe definir así el operador corchete “[ ]” para que funcione correctamente (se obvian las comprobaciones de rango):
T operator[](unsigned i) { return v[i]; } VERDADERO FALSO.
] Si se ha instanciado en la clase Biblioteca a Mivect para implementar una relación de asociación con la clase Libro como:
MiVect<Libro*> estante;
Entonces el destructor de Biblioteca debe entonces eliminar estante ejecutando:
delete[] estante; VERDADERO FALSO.
Es posible eliminar una posición de un vector dinámico en tiempo O(1) si no es necesario preservar el orden de los datos. VERDADERO FALSO.
La implementación normal de un vector dinámico implementa una reducción del tamaño físico tamf a la mitad cuando el tamaño lógico taml cae por debajo de tamf/2. VERDADERO FALSO.
La siguiente declaración: int** p permite crear las siguientes estructuras de datos en memoria: VERDADERO FALSO.
Si la declaración del puntero anterior p se realiza como se muestra a continuación entonces p es creado como una variable residente en la pila de aplicación:
void f() {
int **p;
...
} VERDADERO FALSO.
Una matriz declarada como int a[3][5] se almacena en una zona contigua de memoria. VERDADERO FALSO.
Sea m1 una matriz declarada como int m1[10][20] y m2 un puntero declarado como int **m2 e iniciado mediante el siguiente código:
m2 = new int*[10];
for (int c = 0; c < 10; ++c) {
m2[c] = new int[20];
}
Entonces el elemento existente en la posición (3, 7) se accede de igual manera con ambas estructuras de datos:
m1[3][7] / m2[3][7]. VERDADERO FALSO.
El siguiente código presenta memory leaks:
int *p = new int[1000];
for (int c = 0; c <= 1000; ++c) {
p[c] = 0;
}
VERDADERO FALSO.
El siguiente código presenta heap overflows:
int *p;
for (int c = 0; c < 10; ++c) {
p = new int[100];
}
VERDADERO FALSO.
Una plantilla de clase instanciable para el tipo T = int puede que no lo sea para el tipo T = MiClase, es decir, que una plantilla puede no aceptar cualquier tipo como parámetro. VERDADERO FALSO.
A través el puntero int **m podemos manejar una matriz creada en memoria dinámica con un número de filas y columnas arbitrario. VERDADERO FALSO.
|
