Java 数据结构 | 线性表「顺序存储 + 链式存储」

一、顺序存储

1) 特点

(1) 使用一组地址连续的存储单元依次存放线性表中各个数据元素。

(2) 逻辑上相邻的数据元素，物理上也是相邻的，删除数据会引起大量数据移动。

(3) 便于随机存取。

(4) 不便于插入和删除操作。

(5) 若要扩充存储空间，需要重新创建一个地址连续的更大的存储空间，并把所有数据复制到新的存储空间。

2) 实现

package com.hly.dataStructure.linkedList;
import java.util.Arrays;
/**
 * @author :hly
 * @github :https://github.com/huangliangyun
 * @blog :http://www.javahly.com/
 * @CSDN :blog.csdn.net/Sirius_hly
 * @date :2019/3/8
 */
//线性表顺序存储
public class SequentialLinearList<E> {
   

    //线性表存储空间
    private Object[] listElem;
    //线性表长度
    private int len;

    //初始化线性表的大小
    public SequentialLinearList(int maxLen) {
   
        len = 0;
        listElem = new Object[maxLen];
    }
    //将线性表置空
    public void clear() {
   
        len = 0;
    }
    //判断线性表是否为空
    public boolean isEmpty() {
   
        return len == 0;
    }
    //返回线性表中元素的个数
    public int length() {
   
        return len;
    }
    //返回线性表中第 i 个数据
    public E get(int i) throws Exception {
   
        if (i < 0 || i >= len)
            throw new Exception("查找范围不正确,第" + i + "个元素不存在");
        return (E) listElem[i];
    }
    //在第 i 个数据之前插入数据
    public void insert(int i, E e) throws Exception {
   
        if (i < 0 || i > len)
            throw new Exception("插入范围不正确,第" + i + "个元素不存在");
        //若线性表已满，则扩容一倍
        if (len == listElem.length)
            listElem = Arrays.copyOf(listElem, 2 * listElem.length);
        //数据后移一位，让j=i时挑出，将数据插入i
        for (int j = len; j > i; j--)
            listElem[j] = listElem[j - 1];
        listElem[i] = e;
        len++;
    }

    //删除并返回线性表中第 i 个数据
    public E remove(int i) throws Exception {
   
        if (i < 0 || i >= len)
            throw new Exception("删除范围不正确,第" + i + "个元素不存在");
        E e = (E) listElem[i];
        //j=len-1 时跳出循环，最后一步为 listElem[len-2] = listElem[len-1]
        for (int j = i; j < len - 1; j++)
            listElem[j] = listElem[j + 1];
        len--;
        return e;
    }

    //返回线性表中数据元素的位序号，若线性表中不包含返回-1
    public int indexOf(E e) {
   
        for (int i = 0; i < len; i++) {
   
            if (listElem[i].equals(e)) {
   
                return i;
            }
        }
        return -1;
    }

    //输出线性表中的元素
    public void display() {
   
        for (int i = 0; i < len; i++)
            System.out.print(listElem[i] + " ");
        System.out.println();
    }

    public static void main(String[] args) throws Exception {
   
        SequentialLinearList<Character> list = new SequentialLinearList<>(3);
        list.insert(0, 'a');
        list.insert(1, 'b');
        list.insert(2, 'c');
        list.remove(2);
        list.display();
        list.get(1);
        System.out.println(list.indexOf('a'));
        list.insert(2,'c');
        list.insert(3,'d');
        System.out.println(list.length());
        System.out.println(list.listElem.length);
    }
}

二、带头结点的单链表

1) 特点

1.采用链式存储方式存储的线性表

2.每一个节点包含存放数据元素值的数据域和存放指向逻辑上相邻节点的指针域。

3.一个节点包含一个指针。

4.由他的头指针来唯一标识它。

5.最后一个节点没有后继。

6.头结点不存放具体的值，指针域指向第一个节点。

2) 带头结点单链表实现

package com.hly.dataStructure.linkedList;

/**
 * @author :hly
 * @github :https://github.com/huangliangyun
 * @blog :http://www.javahly.com/
 * @CSDN :blog.csdn.net/Sirius_hly
 * @date :2019/3/8
 */

//带头结点的单链表
public class LinkedList<AnyType extends Comparable<? super AnyType>> {
   

    //定义静态内部类节点
    private static class Node<AnyType>{
   

        public AnyType data;
        public Node<AnyType> next;

        public Node() {
   
            this(null,null);
        }

        public Node(AnyType data) {
   
            this.data = data;
        }

        public Node(AnyType data, Node<AnyType> next) {
   
            this.data = data;
            this.next = next;
        }
    }

    //头指针
    private Node<AnyType> head;
    private int size;

    public LinkedList() {
   
        size = 0;
        head = new Node<>();
    }

    public LinkedList(Node<AnyType> head, int size) {
   
        this.head = head;
        this.size = size;
    }

    public int size(){
   
        return size;
    }

    //将单链表置成空表
    public void clear(){