estrutura de dados - um resumo de aprendizagem

1. Mind Map

2. Notas de Estudo

mesa linear

1. Conceito: O, estrutura linear mais utilizada mais simples.
2. A forma linear de estrutura de armazenamento sequencial

特点：逻辑上相邻，物理地址相邻。
     实现随机存储

Tabela 3. A estrutura de cadeia linear

节点=数据元素+指针
数据元素：存放数据
指针：存放该节点的下一个元素的存储位置

4. interpolação cabeça

void CreateListF(LikList*& L, ElemType a[], int n)
{
	LinkList* s;
	int i;
	L = new LNode;
	L->next = NULL;//创建头节点，其next域设为NULL
	for (i = 0; i < n; i++) {//循环建立数据节点
		s = new LNode;
		s->data = a[i];//创建数据节点*s
		s->next = L->next;//将*s插在原开始节点之前，头节点之后
		L->next = s;
	}
}

Pensando: geração de uma lista vazia, o novo nó irá continuar no cabeçalho da lista encadeada, o nó com a ordem lógica da lista em ordem inversa.
A interpolação cauda

void CreateListR(LinkList*& L, Elemtype a[], int n)
{
	LinkList* s, * r;
	int i;
	L = new LNode;//创建头节点
	r = L;//r始终指向尾节点，开始时指向头节点
	for (i = 0; i < n; i++) {//循环建立数据节点
		s = new LNode;
		s->data = a[i];//创建数据节点*s
		r->next = s;//将*s插入*r之后
		r = s;
	}
	r->next = NULL;//尾节点next域设置为NULL
}

Ideias: a lista ligada o novo nó é inserido no final sempre precisa de um ponteiro de cauda r. A ordem da lista ligada nó mesma ordem lógica

Stack (LIFO)

só pode ser inserido no parágrafo, eliminar a forma linear.
1. De acordo com o armazenamento na forma de: empilhar sequencialmente pilha ligação.
2. Empilhar a ordem

1.初始化栈：栈顶元素为-1；s->top=-1。
2.判断栈是否为空：判断栈顶指针是否为-1。
3.进栈：元素进栈前要判断栈顶是否满。
4.出栈：先确定栈不为空。
5.取栈：先确定栈不为空。
*顺序栈四要素：
栈空条件：s->toop=-1;
栈满条件：s->top=MaxSize=-1;
进栈操作：s->top++;
出栈操作：s->top--;

3. pilha Cadeia

1.栈的链式存储结构是单链表，包含指向下一个节点的指针域，数据域。
2.判断栈是否为空，只需要判断头节点next的值是否为空。
3.出栈：需先判断栈是否为空。
4.取栈：需先判断栈是否为空。
*链栈四要素：
栈空条件：s->next=NULL;
栈满条件：无需考虑；
进栈操作：将新数据节点插到头节点后；
出栈操作：取出头节点之后的节点数据域并删除；

Fila (FIFO)

Mesa linear pode ser inserido, e a outra extremidade da secção de excluir
1. De acordo com a estrutura de armazenamento é dividida em: as filas de espera, a cadeia fila.
2. as filas

1.由一块连续的存储区域，和两个分别指向队头，队尾位置的变量组成。
2.队空：front=rear
3.队满：（rear+1)%MaxSize=front
4.入队：rear=(rear+1)%MaxSize
5.出队：front=(front+1)%MaxSize

3. Equipe de Cadeia

1.单链表，由存储队列元素的数据节点，指向队头队尾指针的链队节点。
2.队空：q->rear=NULL
3.入队：将新的数据节点插到单链表表尾
3.出队:删除单链表的第一个数据节点

corda

1. ordenada seqüência de zero ou mais caracteres, o destino da operação é toda a cadeia, uma cadeia de caracteres de transformação só digitar
algoritmo de correspondência 2. cadeia padrão
a.BF algoritmo: ponteiro Mantenha para trás, complexidade de tempo variável, superior.
principal cadeia de b.KMP sem retrocesso algoritmo ponteiro i, a cadeia padrão para a direita por uma distância "correr" na medida do possível.

recursão

1. A necessidade de invocar auto.
2. Deve haver exportações recursiva.

3. problemas difíceis e soluções

Nextval conhecimento da próxima função e
método de resolução seguinte matriz:
a primeira é um 0 o outro, o segundo bit seguinte é 1, quando a solução do próximo valor de cada bit mais tarde, em comparação de acordo com o anterior. Em primeiro lugar, o primeiro com o seu próximo valor correspondente ao conteúdo, e se iguais, o valor do bit seguinte é o próximo valor da antiga acrescida de 1; se não igual, continuar a olhar para a frente o próximo valor correspondente ao conteúdo do anterior ao lado de um valor correspondente ao conteúdo são comparados em um pouco até encontrar o conteúdo de uma igualdade com a data anterior, em seguida, o valor do bit correspondente de 1 é o valor mais próximo demanda; se encontrado pela primeira vez e não ter encontrado um ex conteúdo iguais, então o valor do próximo bit é a demanda 1.
* Como encontrar o prefixo e sufixo
1. encontrar um prefixo, além de olhar para todos cadeia de caracteres sub-passado.
2. Ao olhar sufixo, além de olhar para todos primeira cadeia de caracteres filho.
Existem cordas P = abaabca, cada comum subsequência a duração máxima do prefixo e de sufixo na seguinte tabela:

com um problema para explicar a
cadeia padrão S: abaabcac

Análise seguinte matriz
1. De um modo geral, um próximo primeiro arranjo é zero, o primeiro 1 é dois, a terceira cadeia de bits padrão quando observamos os dois primeiros, é encontrado um, B
2. neste caso, o que precisamos fazer mais longos prefixos e sufixos correspondentes, o comprimento máximo calculado do elemento comum, e depois adicionar 1, é o valor deste bit seguinte.
3. um terço dos dois primeiros bits são um e B, o comprimento máximo do elemento comum é 0, o valor do bit seguinte é 1.
partes matriz nextval
1. Requisitos nextval [I] valor, temos que comparar String [ i] eo valor string [próximo [i]] de.
2. Se o valor String [I] e igual String [próximo [i]] caracteres, então nextval [i] é igual ao valor de nextval [próximo [i]] de.
3. Se a cadeia [i] e String [próxima [i]] não é igual a um, então nextval [i] é igual ao valor do próximo valor [i].