线性表实现与比较：顺序表与链表-优快云博客

本文链接：https://blog.youkuaiyun.com/diydcckv/article/details/128500704

线性表

首先我们讲由数组实现的顺序表：

定义方式如下：

public class ArrayList<E> {
    private int size = 0;//当前顺序表存放的元素数目
    private int capacity = 10;//当前顺序表的容量
    private Object[] array = new Object[capacity];//根据容量开辟的数组
}

既然是线性表，那么应该有：

插入数据
删除数据
获取指定位置的数据
获取表长

等功能

插入数据：

具体实现思路是将待插入位置之后所有元素向后挪一位，然后将index位置的元素值更改为传入的element

public void add(E element, int index){
        //在index位置插入元素element
        if(index > size || index < 0){
            throw new IndexOutOfBoundsException("超出可控范围了哦,合法范围为0~"+size);
        }
        if(size >= capacity){
            //扩容为1.5倍大小
            // 将原数组中的值copy进去
            // 然后把原数组的值赋值为新数组的引用，容量替换为新的容量
            int newCapacity = capacity*2 + (capacity>>1); //扩容为原来的1.5倍1
            Object[] newArray = new Object[newCapacity];
            System.arraycopy(array, 0, newArray, 0, size);
            array = newArray;
            capacity = newCapacity;
        }
        for (int i = size; i > index; i--) {
            array[i] = array[i-1];
        }
        array[index] = element;
        size++;
    }

删除数据:

具体实现思路是，将index位置之后的所有元素向前挪动一位，覆盖掉index位置的元素值，达到删除效果

@SuppressWarnings("unchecked")
public E remove(int index) {
    if (index >= size || index < 0) {
        throw new IndexOutOfBoundsException("删除位置非法，合法的范围为0~" + size);
    }
    E ans = (E) array[index];
    for (int i = index; i < size - 1; i++) {
        array[i] = array[i+1];
    }
    size--;
    return ans;
}

链表

链表的实现方式有两种，分别是有头结点的和没有头结点的，我们来实现一种有头结点的：

设计思路是：

首先设置一个final修饰的Node结点，表示头结点，不能更改，因此可以通过它访问整条链表
设计内部类Node<E>，其中有E element元素值和指向下一个位置的指针Node<E> next

package com.test.DataStructure.collection;

public class LinkedList<E> {

    //链表的头结点，用于连接之后的所有结点
    private final Node<E> head = new Node<>(null);
    int size = 0;//表示结点个数


    public static class Node<E> {

        private E element;
        private Node<E> next;

        public Node(E element) {
            this.element = element;
        }

    }


    public E get(int index){
        Node<E> node = new Node(null);
        node = head;
        while(index-- >= 0){
            node = node.next;
        }
        return node.element;
    }


    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        Node<E> tool = new Node<>(null);
        tool = head.next;
        while (tool != null) {
            stringBuilder.append(tool.element).append(" ");
            tool = tool.next;
        }
        return stringBuilder.toString();
    }
}

插入数据:

首先将prev结点挪动到index位置处，使得prev.next = index

然后将node的next指向index位置

再将prev位置的next值设置为node，达到插入效果

 public void add(int index, E element) {

        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("插入位置非法，合法位置为0~" + size);
        }
        Node<E> node = new Node<>(element);
        Node<E> prev = new Node<>(null);
        prev = head;
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }
        node.next = prev.next;
        prev.next = node;
        size++;
    }

删除数据

删除的步骤比较简单，

node.next = node.next.next 即可

为了防止数据丢失，该方法返回的是被删除结点的元素值

public E remove(int index) {

        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("删除位置非法，合法位置为0~" + size);
        }
        Node<E> node = new Node<>(null);
        node = head;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }//目前node处于被删位置之前
        E ans = node.next.element;
        node.next = node.next.next;
        size--;
        return ans;

    }