C ++, la memoria se divide en cinco zonas: Pila, Montón, tienda libre, área global / estática de almacenamiento y el área de almacenamiento constante.
- Pila: asignado automáticamente por el compilador cuando sea necesario, desactive automáticamente el área de almacenamiento variable cuando no se necesita. Por lo general almacenar las variables locales, los parámetros de función.
- Montón: nuevo bloque de memoria asignada, es liberado por el programador (sin tener en cuenta el compilador), una corresponde en general a una nueva eliminación, un nuevo [] y [] corresponden borrado. Si un programador no es liberado, el sistema operativo se recuperará automáticamente los recursos al final del programa.
- tienda libre: un bloque de memoria asignada por malloc y similares, y es muy similar a la pila, con conexión a liberar.
- / Área de almacenamiento estático global: Global y variables estáticas se asignan al mismo bloque de memoria (en C, las variables globales se divide en inicializado y sin inicializar, C ++ no es esa distinción).
- área de almacenamiento constante: Esta es un área de almacenamiento especial dentro de las constantes de tienda no puede ser modificado.
(Nota: El montón y la tienda de forma gratuita, pero en realidad es la misma área, las nuevas llamadas de código de aplicación subyacentes malloc, nueva versión avanzada de malloc puede ser visto como inteligente)
Un montón y pila
La diferencia entre (1) el montón y pila
- Gestión: la pila recurso controlado por el programador (pérdida de memoria propensa), la pila se gestiona automáticamente por el compilador de recursos, sin control manual.
- Acción del Sistema: Para un montón, el sistema debe ser consciente de que hay una lista enlazada de dirección de memoria libre del registro, cuando el sistema recibe el programa de aplicación, recorrer la lista enlazada, el primer nodo de encontrar un espacio de pila es mayor que el espacio de aplicación, la lista de nodos libres para borrar la el nodo y asignar el nodo a los programas espaciales (la mayoría de los sistemas de este tamaño serán registrados en la primera asignación de este espacio de direcciones de memoria, por lo que eliminar el derecho de liberar este espacio de memoria, además del exceso de parte del sistema volverá a la liberación en la lista libre). Para la pila, la pila, siempre y cuando el espacio es mayor que las aplicaciones espaciales restantes, el sistema proporciona memoria para el programa, o informe una excepción en la pila.
- Espacio: área de memoria montón discontinua (debido a que el sistema se utiliza para almacenar la lista enlazada de dirección de memoria libre, por supuesto, no continua), el sistema de ordenador está limitada por el tamaño del montón en una memoria virtual eficiente (sistema de 32 bits teóricamente 4G), por lo espacio de montón es relativamente flexible, relativamente grande. La pila es una zona de memoria contigua, el tamaño predeterminado es un buen sistema operativo, las ventanas tamaño de la pila es de 2M (hay 1M, determinado en tiempo de compilación, VC puede ser proporcionada).
- problema de los desechos: Para un montón, frecuentes nuevo / borrado hará que un montón de escombros, por lo que la reducción de la eficacia del procedimiento. Para la pila, es después de un último en salir de colas, y fuera de la correspondencia, sin residuos.
- Dirección de crecimiento: se acumulan, hasta las direcciones más altas. Abajo de la pila, hasta las direcciones más bajas.
- Distribución: montón se asigna dinámicamente (no asignado estáticamente montón). Pila de asignación estática y la asignación dinámica, la asignación estática por el compilador se completa (por ejemplo, las variables locales asignadas), asignadas dinámicamente asignados por alloca función, pero la asignación dinámica de la pila de recursos para ser liberados por el compilador, la necesidad de programador no alcanzado.
- Distributiva eficiencia: Montón proporcionada por las bibliotecas de la C / C ++, el mecanismo es muy complejo. Por lo tanto la eficiencia montón es muy inferior a la pila. se proporciona sistema de estructura de datos extremadamente pila, en la parte inferior de la pila para proporcionar soporte informático, asignado específicamente registro de pila de almacenamiento de direcciones, una instrucción de operación de bloque dedicado.
(2) Operación del Programa
- Pila (stack) : el último en salir (FILO)
stack<int> stk;
stk.empty() 如果栈为空返回true，否则返回false；
stk.size() 返回栈内元素的大小；
stk.pop() 从栈顶弹出一个成员；
stk.push() 向栈内压入一个成员；
stk.top() 返回栈顶，但不删除成员；
- Cola (cola) : First In First Out (FIFO)
queue<int> que;
que.empty() 如果队列为空返回true，否则返回false；
que.size() 返回队列内元素的大小；
que.pop() 从队列弹出一个成员；
que.push() 向队列压入一个成员；
que.front() 返回到队首，但不删除成员；
que.back() 返回到队尾，但不删除成员；
- Montón (montón) : árbol binario ( https://blog.csdn.net/u014182411/article/details/69831492/ )
El árbol es un conjunto de nodos, los bordes entre nodos con enlaces entre nodos no puede tener un bucle. El nodo superior se llama un nodo padre, el nodo inferior se llama un nodo secundario. nodo superior se llama el nodo raíz.
Binary Tree es un árbol especial. Para cada nodo, un nodo secundario conectado directamente con la misma no más de dos (puede ser 0). El nodo hijo izquierdo llama el subárbol izquierdo, el nodo secundario a la derecha llamado el subárbol derecho. Un árbol binario se muestra a continuación:
Algunos conceptos relacionados con el árbol:
- Leaf (nodo hoja): no nodos de los nodos hijo.
- Profundidad: Para cualquier nodo N, la profundidad se refiere a un único camino desde el nodo raíz N de longitud. Profundidades de 0. La profundidad del nodo hoja profunda de la profundidad del árbol. Se puede entender como: una entrada de la raíz es, cuanto más lejos de las raíces, más profundo. Como muestra la Figura: profundidad de A, B, C es 1, D, E es una profundidad de 2.
- Alta: Para cualquier nodo N, a una longitud N de las hojas más alejadas de la trayectoria como la altura N. (Sólo de arriba a abajo no se puede pasar desde la parte inferior hasta el nodo.) Hojas alta es de 0. Alta raíz del árbol es alto. Como se muestra arriba, la altura de la raíz de 2. A 1 es la altura, la altura de los otros nodos 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)
En segundo lugar, la lista
unidad de almacenamiento de lista es una estructura de almacenamiento físicamente no contiguas, no secuencial, el orden lógico de los elementos de datos se consigue por el puntero de enlace en el orden de la lista enlazada. Cadena por una serie de nodos (cada elemento de nodo se denomina una lista enlazada), con el nodo puede ser generado dinámicamente en tiempo de ejecución. Los diferentes nodos se pueden dividir en contenido de la lista que comprende unidireccionales y lista doblemente enlazada.
- Código implementa una lista enlazada (Transferencia de: https://www.cnblogs.com/byonecry/p/4458821.html )
Camino lista de nodos vinculados:
- Campo de datos: un valor para el almacenamiento de los elementos de datos.
- campo de puntero (cadena dominio): para almacenar un siguiente dirección de nodo o punto de sus punteros nodo sucesor directo.
struct Node{
int value;
Node * next;
};Doblemente lista de nodos vinculados:
- Campo de datos: un valor para el almacenamiento de los elementos de datos.
- El campo izquierdo puntero (dominio de cadena izquierda): una dirección de nodo para el almacenamiento o apuntando directamente un puntero a un nodo predecesor.
- El campo de puntero derecho (cadenas del jardín derecho): para almacenar un siguiente dirección de nodo o punto de sus punteros a nodos sucesores directos.
struct DNode{
int value;
DNode * left;
DNode * right;
};Campo de datos: un valor para el almacenamiento de los elementos de datos.
campo de puntero (cadena dominio): para almacenar un siguiente dirección de nodo o punto de sus punteros nodo sucesor directo. las operaciones más comunes:
//插入节点（单向链表）
//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 implementación de la biblioteca utilizando la 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中重复的元素
referencia
https://blog.csdn.net/u013846293/article/details/79410293?utm_source=blogxgwz1
Montón y pila de referencia: https://blog.csdn.net/yangyong0717/article/details/78001609
Lista de referencias: https://www.cnblogs.com/byonecry/p/4458821.html
Binario Referencia: https://blog.csdn.net/u014182411/article/details/69831492/
