Verdadero o falso
2-1-1
Para una lista lineal almacenada secuencialmente de longitud N, las complejidades de tiempo para la consulta y la inserción son O (1) y O (N), respectivamente.
Traducción: para una lista lineal de almacenamiento secuencial de longitud N, la complejidad temporal de la consulta y la inserción son O (1) y O (N) respectivamente.
T F
Las tablas lineales almacenadas secuencialmente admiten el acceso aleatorio, por lo que el tiempo de consulta es un tiempo constante, pero la inserción necesita ajustar la posición de cada elemento subsiguiente, por lo que es un tiempo lineal.
Sin embargo, el libro de texto P27-28 dice: La complejidad de tiempo promedio del algoritmo de búsqueda de la tabla de secuencia por valor es O (n), y la complejidad de tiempo promedio del algoritmo de inserción de la tabla de secuencia es O (n)
.
2-1-2
Si las operaciones más comúnmente utilizadas son visitar una posición aleatoria e insertar y eliminar el último elemento en una lista lineal, entonces el almacenamiento secuencial funciona más rápido.
Traducción: si la operación más común es acceder a una ubicación aleatoria e insertar y eliminar el último elemento de una lista lineal, el almacenamiento secuencial es el más rápido.
T F
Verifique y elimine con frecuencia el último elemento, la tabla de secuencia es completamente competente.
2-1-3
En una lista enlazada de N nodos, las complejidades de tiempo para la consulta y la inserción son O (1) y O (N), respectivamente.
Traducción: en una lista enlazada de N nodos, la complejidad temporal de la consulta y la inserción son O (1) y O (N) respectivamente.
T F
La búsqueda es O (N), porque necesita bajar el siguiente puntero. La inserción es O (1) y solo necesita cambiar el puntero.
Pero el libro de texto P33-35: La complejidad de tiempo promedio del algoritmo de búsqueda de listas de enlaces simples por valor es O (n), y la complejidad de tiempo promedio del algoritmo de inserción de listas de enlaces únicos es O (n);
solo me pregunto ...
2-1-4
Si una lista lineal está representada por una lista enlazada, las direcciones de los elementos en la memoria deben ser consecutivas.
Traducción: si la lista vinculada lineal está representada por la lista vinculada, las direcciones de los elementos en la memoria deben ser continuas.
T F
Si una lista lineal está representada por una lista enlazada, entonces la dirección de los elementos en la memoria: puede ser continua o puede no ser continua;
Libro de texto P29: La estructura de almacenamiento de la cadena de lista lineal se caracteriza por: un conjunto de unidades de almacenamiento arbitrarias para almacenar la tabla lineal Elementos de datos de (este grupo de unidades de almacenamiento puede ser continuo o discontinuo);
Libro de texto P32: En una lista enlazada individualmente, la ubicación de almacenamiento de cada elemento es arbitraria;
2-1-5
organiza y almacena N datos en una lista enlazada individualmente en orden ascendente. Si se utiliza una búsqueda binaria, la complejidad de tiempo promedio de la búsqueda es O (logN).
T F
La complejidad promedio de la búsqueda binaria de la matriz es O (logN). No tiene nada de malo, pero la búsqueda binaria no se puede almacenar en una lista vinculada. Esto está determinado por las características de la lista enlazada. La lista enlazada es una estructura típica de acceso secuencial. La posición de los datos en la lista enlazada sólo puede recuperarse desde el principio hasta el final. Incluso si está ordenada, uno de los datos debe operarse desde el principio. Esto es fundamentalmente diferente de las matrices. Los elementos de la matriz están determinados por el subíndice. Siempre que conozca el subíndice, puede almacenar directamente todo el elemento, como un [5], que es sencillo. La lista vinculada no tiene esto, por lo que la búsqueda binaria solo se puede realizar en la matriz.
Libro de texto P32: La lista enlazada individualmente es una estructura de almacenamiento de acceso no aleatorio. Para obtener el elemento de datos i-ésimo, se debe buscar desde el puntero principal a lo largo de la cadena, que también se denomina estructura de acceso secuencial;
Opción multiple
2-2-1
Para una tabla lineal de longitud N almacenada secuencialmente, la complejidad temporal de acceder a los nodos y agregar nodos es:
A: O (1), O (1)
B: O (1), O (N)
C: O (N), O (1)
D: O (N), O (N)
El almacenamiento secuencial puede lograr un "acceso aleatorio", por lo que la complejidad temporal del acceso a los nodos es O (1), mientras que la inserción y eliminación de nodos implica una gran cantidad de elementos móviles, por lo que la complejidad temporal es O (n);
Libro de texto P26 -28: La complejidad de tiempo promedio del algoritmo de valor de la tabla de secuencia es O (1), la complejidad de tiempo promedio del algoritmo de búsqueda de la tabla de secuencia por valor es O (n) y la complejidad de tiempo promedio del algoritmo de inserción de la tabla de secuencia es O (n) ；
Nodo de acceso == valor?
Las características que no tiene la lista enlazada 2-2-2 son:
R: Insertar y eliminar no necesita mover elementos
B: Para facilitar el acceso aleatorio a cualquier elemento.
C: No es necesario estimar el espacio de almacenamiento con anticipación
D: El espacio requerido es proporcional a la longitud lineal
2-2-3
¿En qué circunstancias es adecuada la tabla lineal L para la implementación utilizando una estructura de cadena?
R: Necesita continuar eliminando e insertando L
B: Necesidad de modificar con frecuencia el valor del nodo en
L C: L contiene una gran cantidad de nodos
D: La estructura del nodo en L es compleja
2-2-4
Si la mesa lineal adopta la estructura de almacenamiento en cadena, se requiere la dirección de la unidad de almacenamiento disponible en la memoria
A: debe ser continuo
B: puede ser continuo o discontinuo
C: parte de la dirección debe ser continua
D: debe ser discontinua
2-2-5
En la tabla de secuencia de N nodos, la complejidad temporal del algoritmo es O (1) operación es:
R: Visite el i-ésimo nodo (1≤i≤N) y encuentre el predecesor inmediato del i-ésimo nodo (2≤i≤N)
B: Insertar un nuevo nodo después del i-ésimo nodo (1≤i≤N)
C: Eliminar el i-ésimo nodo (1≤i≤N)
D: Ordenar N nodos de pequeño a grande
A. Suponiendo que la tabla de secuencia L, longitud n, encuentre el i-ésimo nodo L [i], el predecesor directo L [i-1], por lo que es O (1);
B necesita mover ni nodos, por lo que es O (n);
C también necesita mover ni nodos;
D es el O (n ^ 2) más lento y el O (nlogn) más rápido, según el método de clasificación;
2-2-6
Conecte las tablas lineales La y Lb de cabeza a cola, requiriendo una complejidad temporal de O (1) y ocupando el menor espacio auxiliar posible. ¿Qué estructura se debe utilizar?
A: lista enlazada única
B: lista enlazada circular única
C: lista enlazada circular única con puntero de cola
D: lista enlazada circular doble con nodo principal
La complejidad temporal de las opciones C y D son ambas O (1), pero C tiene menos punteros y ocupa menos espacio auxiliar;
Libro de texto P38:
Lista circular enlazada individualmente:
en algunos casos, si el puntero de cola está configurado en la lista enlazada circular No configure un puntero principal, que puede simplificar algunas operaciones;
2-2-7
adopta la representación de almacenamiento de collar diferente de cero de polinomios. Si los términos distintos de cero de los dos polinomios son N1
y N 2, y el índice de término más alto es M 1 y M2, entonces dos La complejidad temporal de la suma de polinomios es:
A: O (N 1 + N 2)
B ： O (M 1 + M 2)
C ： O (N 1 × N2)
D ： O (M 1 × M 2)
Libro de texto P49: Suponiendo que el número de términos de los dos polinomios es myn, respectivamente, la complejidad temporal del algoritmo de adición de polinomios es O (m + n) y la complejidad espacial es O (1);
no hay prueba sitio aquí;
2-2-8
En una lista enlazada individualmente, si el nodo apuntado por pno es el último nodo, entonces para insertar un nodo apuntado por sdespués p, debemos hacer:
Traducción: en una lista enlazada individualmente, si el nodo apuntado por p no es el último nodo, entonces para insertar un nodo apuntado por s después de p, debe hacer:
A ： s-> siguiente = p; p-> siguiente = s;
B ： s-> siguiente = p-> siguiente; p = s;
C ： s-> siguiente = p-> siguiente; p-> siguiente = s;
D ： p-> siguiente = s; s-> siguiente = p;
Libro de texto P37: Inserte el nuevo nodo * s después del nodo * p;
2-2-9
Para una lista circular enlazada individualmente no vacía, con hy papuntando a sus nodos de cabeza y cola, respectivamente, la declaración VERDADERA es:
Traducción: para una lista enlazada circular de cadena única no vacía, donde h y p apuntan a su nodo principal y al nodo final respectivamente, la proposición verdadera es:
A ： p-> siguiente == h
B ： p-> siguiente == NULL
C ： p == NULL
D ： p == h
¿No estás seguro de la respuesta?
2-2-10
La siguiente tabla muestra cómo se almacena una lista vinculada en el espacio de memoria con el nodo principal c:
Traducción: La siguiente tabla muestra cómo se almacenan los c para el primer nodo de la lista enlazada en el espacio de memoria:
Ahora fse almacena a 1014Hy se añade lo en el ligados Lista ENTRE ay eLa entonces el "Enlace" Los campos de. a, eY fson __, respectivamente.
Traducción: Ahora f se almacena en 1014H y se inserta en la lista vinculada entre ay e. Entonces, los campos de "enlace" de a, eyf son __.
A: 1010H, 1014H, 1004H
B: 1010H, 1004H, 1014H
C: 1014H, 1010H, 1004H
D: 1014H, 1004H, 1010H
Preguntas de programación
2-7-1 El establecimiento y recorrido de la tabla de secuencia (20 puntos)
#include <stdio.h>
#include <stdlib.h>
#include<algorithm>
using namespace std;
#define MAXSIZE 100
typedef int ElemType;/*宏定义int型*/
typedef struct
{
ElemType *elem;
int length;
} SqList;
int n;
void InitList(SqList &L,int n)
{
L.elem=(ElemType*)malloc(sizeof(MAXSIZE));/*开辟空间:（数据类型*）malloc（长度）*/
L.length=0;
ElemType q;
for(int i=0; i<n; i++)
{
scanf("%d",&q);
L.elem[L.length++]=q;
}
for(int i=0; i<L.length; i++)
printf("%d%c",L.elem[i],i==L.length-1?'\n':' ');
return;
}
int main()
{
scanf("%d",&n);
SqList L;
InitList(L,n);
return 0;
}
2-7-2 Creación y recorrido de una lista enlazada individualmente (20 puntos)
#include<iostream>
using namespace std;
#define OK 1
#define ERROR 0
typedef int Status;
typedef int ElemType;
typedef struct LNode{
ElemType data; //数据域
struct LNode *next; //指针域
} LNode, *LinkList;
Status InitList(LinkList &L); //函数声明
void CreateList( LinkList &L,int n); //函数声明
void DisplayList( LinkList ); //函数声明
void DestroyList( LinkList ); //函数声明
int main()
{
LinkList L; //值传递
InitList( L ); //调用函数InitList
int n;
cin >> n;
CreateList( L, n );
DisplayList( L );
DestroyList( L );
return 0;
}
Status InitList(LinkList &L)
{
//构造一个空的单链表L
L = new LNode ; //生成新结点作为头结点，用头指针L指向头结点
L->next = NULL ; //头结点的指针域置空
return OK;
}
void CreateList( LinkList &L,int n )
//尾插法建立带头结点的有n个元素的链表
{
LNode *p, *r; //定义p与r指针
r = L ; //尾指针r指向头结点
for( int i=0; i<n; ++i ){
p = new LNode ; //生成新结点*p
cin >> p->data; //输入元素值赋给新结点*p的数据域
p->next= NULL;
r->next = p ; //将新结点*p插人尾结点*r之后
r = p; //r指向新的尾结点*p
}
}
void DisplayList( LinkList L )
//遍历带头结点的单链表
{
LNode *p =L->next ;
while ( p ){
if(p->next==NULL){
cout<<p->data;
}else{
cout <<p->data<<" ";
}
p=p->next;
}
}
void DestroyList( LinkList L )
{
//回收L的所有结点的空间
LNode *p = L, *q;
while ( p ){
//当p指向结点不为空
q = p->next; //q指向p的下一结点
delete p; //回收p指向的结点空间
p = q; //p指向q指向的结点
}
}
2-7-3 Array rotar a la izquierda (20 puntos)
#include<stdio.h>
#include<stdlib.h>
typedef struct Node *NodePtr;
struct Node
{
int Val;
NodePtr Next;
};
int main()
{
int n,m;
int i;
NodePtr Head,Rear,Tmp,Pre;
Head=Rear=(NodePtr)malloc(sizeof(struct Node));
Head->Next=NULL;
scanf("%d %d",&n,&m);
for(i=0;i<n;i++)
{
Pre=(NodePtr)malloc(sizeof(struct Node));
Pre->Next=NULL;
scanf("%d",&Pre->Val);
Rear->Next=Pre;
Rear=Pre;
}
for(i=0;i<m;i++)
{
Tmp=(NodePtr)malloc(sizeof(struct Node));
Tmp->Val=Head->Next->Val;
Tmp->Next=NULL;
Rear->Next=Tmp;
Rear=Tmp;
Head=Head->Next;
}
Tmp=Head->Next;
printf("%d",Tmp->Val);
for(Tmp=Tmp->Next;Tmp!=NULL;Tmp=Tmp->Next)
printf(" %d",Tmp->Val);
return 0;
}