02_什么是链表和数组

垃圾回收

• 许多高级语言，如Java，拥有自动化的垃圾回收机制，所以我们不用刻意取释放被删除的节点，只要外部没有引用指向他们，被删除的节点就被自动回收。

数组（顺序表代码）

private int[] array;
private int size;

public MyArray(int capacity){
    this.array = new int[capacity];
    size = 0;
}

/*数组插入元素*/
public void insert(int element, int index) throws Exception{
   if(index < 0 || index > size){
        throw new IndexOutOfBounsException("超出链表节点范围！")
    }
    // 如果实际元素达到数组容量上限，则对数组进行扩容
    if(size >= array.length){
        resize();
    }
    for(int i = size - 1; i >= index; i--)
    {
        array[i + 1] = array[i];
    }
    array[index] = element;
    size++;
}

/*数组扩容*/
public void resize()
{
    int[] arrayNex = new int[array.length * 2];
    System.arraycopy(array, 0, arrayNex, 0, array.length);
    array = arrayNew;
}

/*输出数组*/
public void output(){
    for(int i = 0; i < size; i++)
    {
        System.out.println(array[i]);
    }
}

/*数组删除元素*/
public int delete(int index) throws Exception{
    if(index < 0 || index > size){
        throw new IndexOutOfBounsException("超出链表节点范围！")
    }
    int deletedElement = array[index];
    for(int i = index; i < size - 1; i++){
        array[i] = array[i + 1];
    }
    size--;
    return deletedElement;
}


/*测试*/
public static void main(String[] args) throws Exception{
    MyArray myArray = new MyArray(4);
    myArray.insert(3, 0);
    myArray.insert(7, 1);
    myArray.insert(9, 2);
    myArray.insert(5, 3);
    myArray.insert(6, 1);
    myArray.output();

}

单链表代码

/*链表节点*/
private static class Node{
    int data;
    Node next;
    Node(int data){
        this.data = data;
    }
}

// 头结点指针
private Node head;
// 尾节点
privte Node last;
// 链表实际长度
private int size;

/*链表插入元素*/
public void insert(int data, int index) throws Exception{
    if(index < 0 || index > size){
        throw new IndexOutOfBounsException("超出链表节点范围！")
    }
    Node insertedNode = new Node(data)
    if(size == 0){
        // empty linktable
        head = insertedNode;
        last = insertedNode;
    }
    else if(index == 0){
        // insert head
        insertedNode.next = head;
        head = insertedNode;
    }
    else if(size == index){
        // insert tail
        last.next = insertedNode;
        last = insertedNode;
    }
    else{
        // insert middle
        Node prevNode = get(index - 1);
        insertedNode.next = prevNode.next;
        prevNode.next = insertedNode;
    }
    size++;
}

/*链表删除元素*/
public Node remove(int index) throws Exception{
   if(index < 0 || index > size){
        throw new IndexOutOfBounsException("超出链表节点范围！")
    }
    Node removedNode = null;
    if(index == 0){
        // remove head
        removedNode = head;
        head = head.next;
    }
    else if(index == size - 1){
        // remove tail
        Node prevNode = get(index - 1);
        removedNode = prevNode.next;
        prevNode.next = null;
        last = prevNode;
    }
    else{
        // remove middle
        Node prevNode = get(index - 1);
        Node nextNode = prevNode.next.next;
        removeNode = prevNode.next;
        prevNode.next = nextNode;
    }
    size--;
    return removeNode;
}

/*链表查找元素*/
public Node get(int index) throws Exceoption{
    if(index < 0 || index > size){
        throw new IndexOutOfBounsException("超出链表节点范围！")
    }
    Node temp = head;
    for(int i = 0; i < index; i++)
    {
        temp = temp.next;
    }
    return temp;
}

/*输出链表*/
public void output(){
    Node temp = head;
    while(temp != null){
        System.out.println(temp.data);
        temp = temp.next;
    }
}

/*测试*/
public static void main(String[] args) throws Exceotion{
    MyLinkedList myLinkedList = new MyLinkedList();
    myLinkedList.insert(3, 0);
    myLinkedList.insert(7, 1);
    myLinkedList.insert(9, 2);
    myLinkedList.insert(5, 3);
    myLinkedList.insert(6, 1);
    myLinkedList.remove(0);
    myLinkedList.output();
}