Verdadeiro ou falso
2-1-1
Para uma lista linear armazenada sequencialmente de comprimento N, as complexidades de tempo para consulta e inserção são O (1) e O (N), respectivamente.
Tradução: para uma lista linear de armazenamento sequencial de comprimento N, a complexidade de tempo de consulta e inserção são O (1) e O (N), respectivamente.
T F
Tabelas lineares armazenadas sequencialmente suportam acesso aleatório, então o tempo de consulta é um tempo constante, mas a inserção precisa ajustar a posição de cada elemento subsequente, portanto, é tempo linear.
No entanto, o livro P27-28 diz: A complexidade de tempo média da busca da tabela de sequência por algoritmo de valor é O (n), e a complexidade de tempo média do algoritmo de inserção da tabela de sequência é O (n)
.
2-1-2
Se as operações mais comumente usadas são visitar uma posição aleatória e inserir e excluir o último elemento em uma lista linear, o armazenamento sequencial funciona mais rápido.
Tradução: se a operação mais comum é acessar um local aleatório e inserir e excluir o último elemento em uma lista linear, o armazenamento sequencial é o mais rápido.
T F
Verifique e exclua frequentemente o último elemento, a tabela de sequência é totalmente competente.
2-1-3
Em uma lista unida de N nós, as complexidades de tempo para consulta e inserção são O (1) e O (N), respectivamente.
Tradução: em uma lista unida de N nós, a complexidade de tempo de consulta e inserção são O (1) e O (N), respectivamente.
T F
A busca é O (N), pois precisa ir para o próximo ponteiro. A inserção é O (1), e você só precisa mudar o ponteiro.
Mas o livro P33-35: A complexidade de tempo médio do algoritmo de busca de lista unida individualmente por valor é O (n), e a complexidade de tempo média do algoritmo de inserção de lista de ligação simples é O (n);
pergunte-se ...
2-1-4
Se uma lista linear for representada por uma lista encadeada, os endereços dos elementos na memória devem ser consecutivos.
Tradução: Se a lista ligada linear for representada pela lista ligada, os endereços dos elementos na memória devem ser contínuos.
T F
Se uma lista linear é representada por uma lista ligada, então o endereço dos elementos na memória: pode ser contínuo ou não;
Livro P29: Estrutura de armazenamento de cadeia de lista linear é caracterizada por: um conjunto de unidades de armazenamento arbitrárias para armazene os elementos de dados da tabela linear (este grupo de unidades de armazenamento pode ser contínuo ou descontínuo);
Livro didático P32: Em uma lista unicamente vinculada, o local de armazenamento de cada elemento é arbitrário;
2-1-5
organizar e armazenar N dados em uma lista unida em ordem crescente. Se uma pesquisa binária for usada, a complexidade de tempo média da pesquisa é O (logN).
T F
A complexidade média da pesquisa binária do array é O (logN). Não há nada de errado com isso, mas a pesquisa binária não pode ser armazenada em uma lista vinculada. Isso é determinado pelas características da lista vinculada. A lista vinculada é uma estrutura de acesso sequencial típica. A posição dos dados na lista vinculada só pode ser recuperada do início ao fim. Mesmo que seja ordenada, um dos dados deve ser operado desde o início. Isso é fundamentalmente diferente dos arrays. Os elementos do array são determinados pelo subscrito.Contanto que você conheça o subscrito, você pode armazenar diretamente o elemento inteiro, como a [5], que é simples. A lista vinculada não tem isso, portanto, a pesquisa binária só pode ser realizada na matriz.
Livro didático P32: A lista vinculada simples é uma estrutura de armazenamento de acesso não aleatório.Para obter o i-ésimo elemento de dados, ele deve ser pesquisado a partir do ponteiro principal ao longo da cadeia, que também é chamada de estrutura de acesso sequencial;
Múltipla escolha
2-2-1
Para uma tabela linear de comprimento N armazenada sequencialmente, a complexidade de tempo para acessar os nós e adicionar nós é:
A：O(1), O(1)
B: O (1), O (N)
C: O (N), O (1)
D: O (N), O (N)
O armazenamento sequencial pode alcançar "acesso aleatório", de modo que a complexidade de tempo de acesso aos nós é O (1), enquanto a inserção e exclusão de nós envolve um grande número de elementos móveis, então a complexidade de tempo é O (n);
Livro P26 -28: A complexidade de tempo médio do algoritmo de valor da tabela de sequência é O (1), a complexidade de tempo médio do algoritmo de busca da tabela de sequência por valor é O (n) e a complexidade de tempo média do algoritmo de inserção da tabela de sequência é O (n) ；
Nó de acesso == valor?
Os recursos que a lista vinculada 2-2-2 não possui são:
R: Inserir e excluir não precisam mover elementos
B: Para facilitar o acesso aleatório a qualquer elemento
C: Não há necessidade de estimar o espaço de armazenamento com antecedência
D: O espaço necessário é proporcional ao comprimento linear
2-2-3
Sob quais circunstâncias a tabela linear L é adequada para implementação usando uma estrutura em cadeia?
R: É necessário continuar a excluir e inserir L
B: Necessidade de modificar frequentemente o valor do nó em
L C: L contém um grande número de nós
D: A estrutura do nó em L é complexa
2-2-4
Se a tabela linear adota a estrutura de armazenamento em cadeia, o endereço da unidade de armazenamento disponível na memória é necessário
R: Deve ser contínuo
B: pode ser contínuo ou descontínuo
C: Parte do endereço deve ser contínua
D: deve ser descontínua
2-2-5
Na tabela de sequência de N nós, a complexidade de tempo do algoritmo é O (1) operação é:
R: Visite o i-ésimo nó (1≤i≤N) e encontre o predecessor imediato do i-ésimo nó (2≤i≤N)
B: Insira um novo nó após o i-ésimo nó (1≤i≤N)
C: Exclua o i-ésimo nó (1≤i≤N)
D: Classifique N nós de pequeno a grande
A. Assumindo a tabela de sequência L, comprimento n, encontre o i-ésimo nó L [i], o predecessor direto L [i-1], então é O (1);
B precisa mover ni nós, então é O (n);
C também precisa mover ni nós;
D é o O mais lento (n ^ 2) e o O mais rápido (nlogn) dependendo do método de classificação;
2-2-6
Conecte as tabelas lineares La e Lb cabeça a cauda, exigindo uma complexidade de tempo de O (1) e ocupando o mínimo de espaço auxiliar possível. Qual estrutura deve ser usada?
A: Lista única ligada
B: Lista única circular ligada
C: Lista ligada circular única com ponteiro de cauda
D: lista dupla circular ligada com nó principal
A complexidade de tempo das opções C e D são ambas O (1), mas C tem menos ponteiros e ocupa menos espaço auxiliar;
Livro P38: Lista
circular unida:
Em alguns casos, se o ponteiro final estiver configurado na lista ligada circular Não configure um ponteiro de cabeça, o que pode simplificar algumas operações;
2-2-7
adota a representação de armazenamento de colar diferente de zero de polinômios. Se os termos diferentes de zero dos dois polinômios forem N1
e N 2, e o índice de termo mais alto for M 1 e M2, então dois complexidade de tempo de adição polinomial é:
A: O (N 1 + N 2)
B: O (M 1 + M 2)
C: O (N 1 × N2)
D: O (M 1 × M 2)
Livro Didático P49: Supondo que o número de termos dos dois polinômios seja m e n, respectivamente, a complexidade do tempo do algoritmo de adição polinomial é O (m + n) e a complexidade do espaço é O (1);
não há teste site aqui;
2-2-8
Em uma lista unida individualmente, se o nó apontado por pnão for o último nó, então, para inserir um nó apontado por sdepois p, devemos fazer:
Tradução: em uma lista unida individualmente, se o nó apontado por p não for o último nó, então para inserir um nó apontado por s após p, você deve fazer:
A: s-> próximo = p; p-> próximo = s;
B: s-> próximo = p-> próximo; p = s;
C ： s-> próximo = p-> próximo; p-> próximo = s;
D ： p-> próximo = s; s-> próximo = p;
Livro Didático P37: Insira o novo nó * s após o nó * p;
2-2-9
Para uma lista circular não vazia unida individualmente, com he papontando para seus nós inicial e final, respectivamente, a instrução TRUE é:
Tradução: para uma lista ligada circular de cadeia única não vazia, onde h e p apontam para seu nó principal e nó final, respectivamente, então a verdadeira proposição é:
A ： p-> próximo == h
B ： p-> próximo == NULL
C ： p == NULL
D ： p == h
Não tem certeza da resposta?
2-2-10
A tabela a seguir mostra como uma lista vinculada é armazenada no espaço de memória com o nó principal c:
Tradução: A tabela seguinte mostra como o c para o primeiro nó da lista ligada é armazenada no espaço de memória:
Agora fé armazenado AT 1014He é aditado o no ligados Lista ENTRE ae eA então o "Link" Fields of. a, eE fsão __, respectivamente.
Tradução: agora f é armazenado em 1014H e inserido na lista vinculada entre a e e. Então, os campos "link" de a, e e f são __.
A: 1010H, 1014H, 1004H
B: 1010H, 1004H, 1014H
C: 1014H, 1010H, 1004H
D: 1014H, 1004H, 1010H
Questões de programação
2-7-1 O estabelecimento e travessia da tabela de sequência (20 pontos)
#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 Criação e passagem de lista unida individualmente (20 pontos)
#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 girar para a esquerda (20 pontos)
#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;
}