lista enlazada Camino
lista manera enlazada es una lista lineal, un nodo es en realidad (Node) que consiste en una cadena tiene un número variable de nodos. Los datos almacenados en la memoria, que es discontinua, dispersa sus datos almacenados en la memoria, cada nodo sólo sabe que sólo la posición de almacenamiento del siguiente nodo. De n nodos (nodo) compuestas de lista enlazada, donde cada datos de nodo de nodo y presente la grabación de la siguiente nodo. Sólo un nodo principal (cabeza) hacia el exterior expuesta, enumeramos todas las operaciones se llevan a cabo directamente o indirectamente a través de su nodo principal.
La diferencia entre la lista y la matriz
Cuenta con una matriz de
- En la matriz de memoria es un área contigua.
- Matriz necesita reservar espacio, antes de usar el primer tamaño de la aplicación de contabilidad, la memoria puede ser desperdiciado espacio.
- Insertar y las ineficiencias de datos de eliminación de datos, al insertar los datos, los datos de localización a estar detrás de este movimiento hacia atrás en la memoria. Cuando usted los datos de borrado, los datos detrás de los datos deben moverse hacia adelante.
- Alta eficiencia de lectura aleatoria. Debido a que la matriz es continua, sabemos la dirección de memoria de cada uno de los datos se puede encontrar para hacer frente a los datos directamente.
- Para redefinir la definición de una matriz de matrices no hay suficiente espacio.
Lista de características
- Puede estar en cualquier lugar en la memoria, que no requiere continua.
- Cada dato se almacena direcciones de memoria de los siguientes datos para encontrar los siguientes datos a través de esta dirección.
- El aumento de los datos y los datos de eliminar fácilmente. Sólo se necesita cambiar la dirección apunta a la línea, no es necesario para mover los datos.
- Encuentre datos de baja eficiencia, ya que no tienen acceso al azar, acceso a datos a una ubicación debe comenzar a acceder a los datos de los primeros y segundos datos para encontrar la dirección de los próximos datos almacenados en los primeros datos que sucesivamente.
- No especifique un tamaño para una fácil expansión. Sin definir el tamaño de la lista, pueden agregar o eliminar datos.
Seleccione una lista enlazada y una serie de
Multi-consulta con un arsenal de más que el aumento eliminar una lista enlazada.
implementación en Java de los códigos de cadena sencilla son los siguientes:
class node{ //节点
int data; //数据
node next; //用来指向下一个地址 模仿指针
public node(){}
public node(int data){
this.data = data;
}
}
public class aa {
public static void main(String[] args) {
node head = null; //创建头节点
node t = null; //创建头节点
node n1 = new node(2); //创建其它节点并输入数据
//创建第一个节点时 next置空
n1.next = null;
node n2 = new node(4);
node n3 = new node(6);
List<node> list = new ArrayList();
list.add(n1);
list.add(n2);
list.add(n3);
int i ;
/*
//给链表中添加数据 尾插法
for( i = 0; i<list.size();i++){
if(head == null){
head= list.get(0);
}else{
list.get(i-1).next = list.get(i); //如果不是头节点则将上一个节点的next指向此节点地址
}
head = list.get(0); //将头节点指向第一个节点
}
*/
//给链表中添加数据 头插法
for( i = 0; i<list.size();i++){
if(head == null){
head = list.get(0); //把第一个节点赋值给头节点
}else{
list.get(i).next = list.get(i-1); //如果不是头节点则将此节点的next指向上一个节点地址
}
head = list.get(i); //把此节点的地址赋值给头节点
}
t = head; //从链表头部开始遍历
System.out.print("原始的数据：");
while (t!=null){ //如果头节点的next值不为空则输出头节点指向的地址数据
System.out.print(t.data);
t = t.next; //指向下一个节点
}
//增加节点
node n4 = new node(5);
t = head;
while (t!=null){ //如果头节点的next值不为空则输出头节点指向的地址数据
if(t.data<n4.data){ //如果第一个节点小于添加的节点，则把第一个节点添加到该节点的next
n4.next = t;
head = n4; //另该节点为开始节点
}
if(t == null || t.next.data < n4.data) { //如果该节点的下一个节点的值小于待插入数据时插入数据
n4.next = t.next; //把该节点的指向的下一个节点赋值给添加节点指向的下一个节点
t.next = n4; //把添加节点设置为该节点指向的节点
break;
}
t = t.next; //指向下一个节点
}
System.out.println();
System.out.print("添加数据5：");
t = head;
while (t!=null){ //如果头节点的next值不为空则输出头节点指向的地址数据
System.out.print(t.data);
t = t.next; //指向下一个节点
}
//删除节点n4节点也就是值为4的节点
t = head;
while (t!=null){ //如果头节点的next值不为空则输出头节点指向的地址数据
if(t.next.data == 5) { //如果下一个节点的值等于待删除数据时删除
t.next = t.next.next; //删除数据
break;
}
head = head.next; //指向下一个节点
}
System.out.println();
System.out.print("删除数据5：");
t = head;
while (t!=null){ //如果头节点的next值不为空则输出头节点指向的地址数据
System.out.print(t.data);
t = t.next; //指向下一个节点
}
}
}
Los resultados se muestran a continuación:
