La definición de una matriz es: un conjunto limitado de almacenamiento de variables del mismo tipo. Cada variable de la matriz se denomina elemento y cada elemento tiene su propio subíndice (a partir de 0). Los datos se almacenan secuencialmente en la memoria.
Implementación simple de matriz:
public class Array {
//数据元素
private int[] array;
//当前数组存储数的个数
private int size;
public Array(int capacity){
this.array = new int[capacity];
this.size = 0;
}
/**
* @Description
* @Param [num 添加的元素]
* @Date 2019-8-18 20:31
* @Version 1.0
*/
public void add(int num){
//对数组进行扩容
if(size > array.length){
resize();
}
//添加元素
array[size++] = num;
}
/**
* @Description 数组插入元素
* @Param [element 插入的数据, index 插入的位置]
* @Date 2019-8-18 19:35
* @Version 1.0
*/
public void insert(int element,int index){
//判断下表是否超出数组范围
if(index < 0 || index > size){
throw new IndexOutOfBoundsException("超出数组容量");
}
//对数组进行扩容
if(size > array.length){
resize();
}
for(int i = size - 1;i >= index;i--){
array[i+1] = array[i];
}
//插入元素
array[index] = element;
size++;
}
/**
* @Description 对数据进行扩容
* @Param null
* @Date 2019-8-18 19:43
* @Version 1.0
*/
private void resize() {
//数组扩容为原来的2倍
int[] newArray = new int[array.length * 2];
//将数据从旧的数组拷贝到新数组
System.arraycopy(array,0,newArray,0,array.length);
array = newArray;
}
/**
* @Description 获取数据
* @Param [index 获取数据的下标]
* @Date 2019-8-18 20:34
* @Version 1.0
*/
public int get(int index){
return array[index];
}
public static void main(String[] args){
Array array = new Array(10);
array.insert(3,0);
array.insert(2,1);
array.insert(5,2);
array.insert(6,3);
array.insert(7,1);
array.add(9);
for (int i = 0; i < array.size; i++) {
System.out.println(array.get(i));
}
}
Cabe señalar que la matriz tiene una capacidad inicial, cuando los elementos almacenados alcanzan la capacidad máxima, se crea una nueva matriz con una capacidad dos veces mayor que la actual, y luego los elementos de la matriz anterior se copian en la nueva matriz.
La definición de una lista enlazada: una estructura numérica que no es físicamente contigua y no se almacena secuencialmente y consta de nodos. Contiene dos partes, una son los datos almacenados y la otra es el puntero al siguiente nodo. El primer nodo de la lista vinculada se llama nodo principal y el último es el nodo final.
Implementación simple de lista vinculada:
public class Linked {
//链表头节点
private Node head;
//链表未节点
private Node last;
//链表长度
private int size;//默认值为0
/**
* @Description 链表末尾追加数据
* @Param [data 添加的数据]
* @Date 2019-8-18 21:38
* @Version 1.0
*/
public void add(Object data) {
Node inner = new Node(data);
if(size == 0){
head = inner;
last = inner;
}else{
/* 没有理解对象引用
Node node = get(size-1); //node==last
node.next = inner;
last = inner;*/
//Node node = get(size-1);
//System.out.println(node == last);//true
last.next = inner;
last = inner;
}
size++;
}
/**
* @Description 链表插入元素
* @Param [data 插入的数据, index 插入的位置]
* @Date 2019-8-18 21:01
* @Version 1.0
*/
public void insert(Object data,int index){
if(index < 0 || index > size){
throw new IndexOutOfBoundsException("下标越界");
}
Node inner = new Node(data);
if(size == 0 ){//链表为空
head = inner;
last = inner;
}else if(index == 0 ){//插入头部
//System.out.println(head == last);//true 操作head相当于操作last
inner.next = head;
head = inner;
//System.out.println(head.next == last);//true
//System.out.println(inner.next == last);//true
}else if(index == size){//尾部插入
last.next = inner;
last = inner;
}else {//插入中间
Node prevNode = get(index-1);
if(prevNode == null){
throw new NullPointerException("下标链表为空！");
}
inner.next = prevNode.next;
prevNode.next = inner;
}
size++;
}
/**
* @Description
* @Param [index 删除的下标]
* @Date 2019-8-18 21:28
* @Version 1.0
*/
public Node remove(int index) {
if(index < 0 || index >= size){
throw new IndexOutOfBoundsException("下标越界");
}
Node removeNode = null;
if(index == 0){//删除头部
removeNode = head;
head = head.next;
}else if(index == size){//删除尾部
Node lastNode = get(index-1);
removeNode = lastNode.next;
lastNode.next = null;
last = lastNode;
}else{//删除中间
Node pervNode = get(index-1);
pervNode.next = pervNode.next.next;
removeNode = pervNode.next;
}
return removeNode;
}
/**
* @Description 根据下标获取链表节点
* @Param [index 下标]
* @Date 2019-8-18 23:02
* @Version 1.0
*/
public Node get(int index) {
if(index < 0 || index >= size){
throw new IndexOutOfBoundsException("下标越界");
}
Node node = head;
for (int i = 0; i < index; i++) {
node = node.next;
if(node.next == null){
break;
}
}
return node;
}
/**
* @Description 输出链表数据
* @Param NULL
* @Date 2019-8-18 23:06
* @Version 1.0
*/
public void output(){
Node next = head;
while (next.next != null){
System.out.println(next.data);
next = next.next;
}
System.out.println(next.data);
}
/**
* @Description 链表节点
* @Date 2019-8-18 23:04
* @Version 1.0
*/
public static class Node {
//存储的数据
public Object data;
//下一节点
public Node next;
public Node(Object data){
this.data = data;
}
}
public static void main(String[] args){
Linked linked = new Linked();
linked.add("123");
linked.add(1234);
linked.add("ad");
linked.add("trt");
linked.insert("111",0);
linked.insert("222",2);
linked.insert("333",6);
linked.output();
System.out.println("**************************");
linked.remove(4);
linked.output();
}
}
Aquí debe prestar atención al almacenamiento y la referencia del objeto. El objeto se almacena en el montón y la pila es solo una copia de la referencia del objeto. Al igual que un dato se almacena en la lista vinculada, el nodo principal y el nodo de cola apuntan al nodo donde se almacenan los datos. En este momento, si se inserta un dato en el encabezado, aunque se opera el nodo principal, el nodo principal y el nodo de cola Los nodos son el mismo objeto, lo que equivale a operar el nodo de cola.
Comparación de datos y lista enlazada
- La búsqueda y actualización de la matriz son rápidas, solo se requiere una operación y las operaciones de inserción y eliminación son N.
- La búsqueda de listas vinculadas es lenta, el número de operaciones es N y solo se requiere una actualización, inserción y eliminación.
- Las matrices son adecuadas para leer más y escribir menos, mientras que las listas enlazadas son lo contrario.