C ++, a memória é dividida em cinco zonas: Pilha, loja livre, área de armazenamento global / estática e a área de armazenamento constante.
- Stack: alocado automaticamente pelo compilador quando necessário, limpar automaticamente a área de armazenamento da variável quando não for necessário. Normalmente armazenar variáveis locais, parâmetros da função.
- Heap: novo bloco de memória é alocada, é liberado pelo programador (independentemente do compilador), um geralmente corresponde a uma nova exclusão, um novo [] e uma exclusão correspondem []. Se um programador não é liberada, o sistema operacional irá recuperar automaticamente os recursos no final do programa.
- loja Free: um bloco de memória alocada por malloc e similares, e é muito semelhante à pilha, com acesso para liberar.
- / Área de armazenamento estática global: Global e variáveis estáticas são atribuídos ao mesmo bloco de memória (em C, as variáveis globais é dividido em inicializado e não inicializadas, C ++ não é essa distinção).
- área de armazenamento constante: Esta é uma área de armazenamento especial dentro das constantes loja não pode ser modificado.
(Nota: A pilha ea loja livre, mas na verdade é a mesma área, novas chamadas código de implementação subjacentes malloc, nova versão avançada de malloc pode ser visto como inteligente)
A pilha e pilha
A diferença entre (1) da pilha e a pilha
- Gestão: a pilha recurso controlado pelo programador (vazamento de memória propensas), a pilha é gerida automaticamente pelo compilador de recursos, sem controle manual.
- Ação do Sistema: Para uma pilha, o sistema deve estar ciente de que há uma lista ligada de endereço de memória livre do registro, quando o sistema recebe o programa de aplicação, percorrer a lista ligada, o primeiro nó de encontrar um espaço de pilha é maior do que o espaço de aplicação, a lista de nós livre para apagar o o nó e atribuir o nó para os programas espaciais (a maioria dos sistemas deste tamanho será gravada na primeira atribuição deste espaço de endereçamento de memória, então excluir o direito de lançar este espaço de memória, além de a parte excedente do sistema será re-lançamento na lista livre). Para a pilha, a pilha enquanto o espaço é maior do que as aplicações espaciais restantes, o sistema fornece memória para o programa, ou relatar uma exceção na pilha.
- Espaço: área de memória heap descontínua (porque o sistema é usado para armazenar a lista ligada de endereço de memória livre, é claro, não contínua), o sistema de computador é limitado pelo tamanho da pilha em uma memória virtual eficiente (sistema de 32 bits, teoricamente, 4G), assim espaço de pilha é relativamente flexível, relativamente grande. A pilha é uma área de memória contíguo, o tamanho predeterminado é um bom sistema operativo, as janelas pilha tamanho é 2M (há 1M, determinada no momento de compilação, VC pode ser fornecido).
- problema detritos: Para uma pilha, frequente novo / exclusão fará com que um monte de escombros, reduzindo assim a eficiência do procedimento. Para a pilha, é depois de uma última-out fila, e fora de correspondência, sem detritos.
- direção de crescimento: se acumulam, até os endereços mais altos. Para baixo da pilha, até os endereços mais baixos.
- Distribuição: pilha é alocada dinamicamente (e não estaticamente alocado pilha). Pilha de alocação estática e alocação dinâmica, alocação estática pelo compilador é concluída (por exemplo, as variáveis locais atribuídas), atribuídos dinamicamente alocados por alloca função, mas a alocação dinâmica da pilha recurso a ser liberado pelo compilador, a necessidade programador não alcançado.
- Alocativa eficiência: Heap fornecida por bibliotecas de C / C ++, o mecanismo é muito complexo. Assim, a eficiência da pilha é muito menor do que a pilha. Sistema de estrutura de dados extremamente pilha é fornecido, na parte inferior da pilha para fornecer suporte de informática, especificamente dedicado registro de armazenamento de endereços de pilha, uma instrução de operação pilha dedicado.
(2) Funcionamento Programa
- Stack (Pilha) : last-out (FILO)
stack<int> stk;
stk.empty() 如果栈为空返回true，否则返回false；
stk.size() 返回栈内元素的大小；
stk.pop() 从栈顶弹出一个成员；
stk.push() 向栈内压入一个成员；
stk.top() 返回栈顶，但不删除成员；
- Queue (Fila) : First In First Out (FIFO)
queue<int> que;
que.empty() 如果队列为空返回true，否则返回false；
que.size() 返回队列内元素的大小；
que.pop() 从队列弹出一个成员；
que.push() 向队列压入一个成员；
que.front() 返回到队首，但不删除成员；
que.back() 返回到队尾，但不删除成员；
- Heap (pilha) : árvore binária ( https://blog.csdn.net/u014182411/article/details/69831492/ )
Árvore é uma coleção de nós, as bordas entre os nós com links entre nós não pode ter um loop. O nó superior é chamado um nó pai, o nó inferior é chamado de nó filho. Topmost nó é chamado o nó raiz.
Árvore binária é uma árvore especial. Para cada nó, um nó filho directamente ligado com o mesmo não mais do que dois (pode ser 0). O nó filho esquerdo chamado a subárvore esquerda, o nó filho à direita chamado de sub-árvore direita. Uma árvore binária é mostrado abaixo:
Alguns conceitos relacionados à árvore:
- Folha (nó folha): nenhum nó todos os nós filho.
- Profundidade: Para qualquer nó N, a profundidade refere-se a um caminho único a partir do nó raiz N de comprimento. Profundidades de 0. A profundidade do nó mais profundo folha da profundidade da árvore. Ele pode ser entendido como: a entrada de raiz é, quanto mais longe das raízes, mais profundo. Como a Figura: profundidade A, B, C é um, D, E é uma profundidade de 2.
- Alta: Para qualquer nó N, para um comprimento N das folhas mais afastadas do caminho como a altura N. (Só de cima para baixo você não pode passar do mais baixo para o nó.) De altura folhas é 0. raiz alta árvore é alta. Como mostrado acima, a altura da raiz de dois. Um 1 é a altura, a altura dos outros nós 0.
#include <algorithm>
make_heap: 根据指定的迭代器区间以及一个可选的比较函数，来创建一个heap. O(N)
push_heap: 把指定区间的最后一个元素插入到heap中. O(logN)
pop_heap: 弹出heap顶元素, 将其放置于区间末尾. O(logN)
sort_heap：堆排序算法，通常通过反复调用pop_heap来实现. N*O(logN)针。
c++11
is_heap: 判断给定区间是否是一个heap. O(N)
is_heap_until: 找出区间中第一个不满足heap条件的位置. O(N)
Em segundo lugar, a lista
unidade de armazenamento lista é, uma estrutura de armazenamento não sequencial fisicamente não contígua, a ordem lógica dos elementos de dados é conseguida através da ligação ponteiro na ordem da lista ligada. Cadeia por uma série de nodos (cada elemento de nó é chamado de uma lista ligada), com o nó pode ser gerada dinamicamente em tempo de execução. Os diferentes nós pode ser dividido em lista compreendendo unidirecionais conteúdos e listas duplamente ligadas.
- Código implementa uma lista ligada (Transferência de: https://www.cnblogs.com/byonecry/p/4458821.html )
Way lista de nós ligados:
- campo de dados: um valor para armazenar os elementos de dados.
- campo apontador (cadeia de domínio): para armazenamento de um endereço de nódulo próximo ou ponto de seus ponteiros nó sucessor directa.
struct Node{
int value;
Node * next;
};Duplamente lista de nós ligados:
- campo de dados: um valor para armazenar os elementos de dados.
- O campo esquerdo ponteiro (domínio de cadeia esquerda): o endereço de um nó para o armazenamento ou apontando directamente para um apontador num nó antecessor.
- O campo de ponteiro direito (cadeias campo direito): para armazenar um endereço de nó seguinte ou ponto de seus ponteiros nó sucessor direto.
struct DNode{
int value;
DNode * left;
DNode * right;
};campo de dados: um valor para armazenar os elementos de dados.
campo apontador (cadeia de domínio): para armazenamento de um endereço de nódulo próximo ou ponto de seus ponteiros nó sucessor directa. operações comuns:
//插入节点（单向链表）
//p节点后插入值为i的节点
void insertNode(Node *p, int i){
Node* node = new Node;
node->value = i;
node->next = p->next;
p->next = node;
}
//删除节点（单向链表）
void deleteNode(Node *p){
p->value = p->next->value;
p->next = p->next->next;
}- Lista de implementação da biblioteca usando a lista stl
//创建链表
list<int> lst1; //创建空list
list<int> lst2(5); //创建含有5个元素的list
list<int> lst3(lst2); //使用lst2初始化
list<int> lst4(lst2.begin(),lst2.end()); //使用lst2初始化
//基本操作
lst1.assign() 给list赋值
lst1.back() 返回最后一个元素
lst1.begin() 返回指向第一个元素的迭代器
lst1.clear() 删除所有元素
lst1.empty() 如果list是空的则返回true
lst1.end() 返回末尾的迭代器
lst1.erase() 删除一个元素
lst1.front() 返回第一个元素
lst1.get_allocator() 返回list的配置器
lst1.insert() 插入一个元素到list中
lst1.max_size() 返回list能容纳的最大元素数量
lst1.merge() 合并两个list
lst1.pop_back() 删除最后一个元素
lst1.pop_front() 删除第一个元素
lst1.push_back() 在list的末尾添加一个元素
lst1.push_front() 在list的头部添加一个元素
lst1.rbegin() 返回指向第一个元素的逆向迭代器
lst1.remove() 从list删除元素
lst1.remove_if() 按指定条件删除元素
lst1.rend() 指向list末尾的逆向迭代器
lst1.resize() 改变list的大小
lst1.reverse() 把list的元素倒转
lst1.size() 返回list中的元素个数
lst1.sort() 给list排序
lst1.splice() 合并两个list
lst1.swap() 交换两个list
lst1.unique() 删除list中重复的元素
referência
https://blog.csdn.net/u013846293/article/details/79410293?utm_source=blogxgwz1
Heap e referência de pilha: https://blog.csdn.net/yangyong0717/article/details/78001609
Lista de referência: https://www.cnblogs.com/byonecry/p/4458821.html
Binário Referência: https://blog.csdn.net/u014182411/article/details/69831492/
