数据结构(2)- 单链表

链式存储是基于指针实现的,由于Java中没有指针这东西,但是我们常用就是一个数据元素+一个指针形成结点的方式去完成这个结构.而在Java中使用链式存储的其实就是我们的LinkList.链表的链接主要是通过直接来将相互关联的结点链接起来.
每一个结点的结构是: 数据元素 | 指针域

我们认为的一般的单链表结构
头指针—>头结点—>第一个有数据的元素–>元素结点
(只有指针) (无数据,可放长度) (有数据跟指针)

我们需要区分的概念:
1. 一般来说我们的链表是通过我们指针域来连接
2. 我们的长度是不受限制的,但是必须是一系列的集合,不能空缺,其实顺序表也不能空缺,但是一般没存数据的位置都默认值存了.
3. 我们的数据是从整个存储空间,找到对应的那个指针地址找到的.(java的Debug看出的应该是Id)

定义结构(即是Node类):

/**
 * 
 * @author Administrator
 * 结点的结构: 数据域+指针域
 * 增加了每一个结点的消耗,但是能动态运用表结构
 * 
 */
public class Node {
    Object element; //数据域
    Node next;  //指针域

    //头结点的构造方法,头结点只有一个指针域 用来指向下一个结点,本身是没有数据的
    //这里我们需要区分头结点还有第一个结点的差别
    public Node(Node nextval) {
        this.next = nextval;
    }

    //非头结点的构造方法
    public Node(Object obj, Node nextval) {
        this.element = obj;
        this.next = nextval;
    }

    //获得当前结点的指针域
    public Node getNext() {
        return this.next;
    }

    //获得当前结点数据域的值
    public Object getElement() {
        return this.element;
    }
    //设置当前结点的指针域
    public void setNext(Node nextval) {
        this.next = nextval;
    }

    //设置当前结点数据域的值
    public void setElement(Object obj) {
        this.element = obj;
    }

    public String toString() {
        return this.element.toString();
    }
}

具体操作实现:(注意可以没有头结点,但是不能有没有指针)

     /**
 * 链表结构
 * -2        -1        0
 * 头指针-->头结点--->第一个数据结点
 * @author Administrator
 *
 */
public class LinkedListSample {
    Node head; // 头指针
    Node current;// 当前结点对象
    int size;// 结点个数
    public LinkedListSample() {
        // 初始化头结点,让头指针指向头结点,并且让当前结点对象等于头结点,这时候没有任何数据
        this.head = current = new Node(null);
        this.size = 0;
    }

    // 目的是获取到操作的结点
    public void index(int index) {
        if (index < -1 || index > size) {
            System.out.println("参数错误");
        }
        if (index == -1) {
            // 这个说明是为了表示这个是头指针的存在
            return; // 这里要有一个思想:头指针的下标是-1,第一个元素的下标是0
        }
        current = head.next;
        int j = 0;// 循环变量
        while (current != null && j < index) {
            current = current.next;
            j++;
        }
    }

    // 插入操作
    public void insert(int index, Object object) {
        if (index < 0 || index > size) {
            System.out.println("插入位置不对");
        }
        index(index - 1);// 确定位置,获取到操作结点的前一个对象,就是现在current就是在这个节点的前一个对象
        current.setNext(new Node(object, current.next));
        size++;
    }

    // 删除操作
    public void delete(int index) {
        if (index < 0 || index > size - 1) {
            System.out.println("参数错误");
        }
        if (isEmpty()) {
            System.out.println("表为空");
        }
        index(index - 1);
        current.setNext(current.next.next);
        size--;
    }

    // 获取具体元素
    public Object get(int index) {
        if (index < 0 || index > size - 1) {
            System.out.println("参数错误");
        }
        index(index);
        return current.getElement();
    }

    public int getSize() {
        return size;

    }

    public boolean isEmpty() {
        return size == 0;
    }

    public static void main(String[] args) {
        LinkedListSample linkedListSample = new LinkedListSample();
        linkedListSample.insert(0, "小明");
        linkedListSample.insert(1, "小明");
        linkedListSample.insert(2, "小黄");
        Object f = linkedListSample.get(3);
        System.out.println(f);

    }
}

时间复杂度:
1. 查找–O(n)
2. 插入/删除–O(1)

优劣分析:
1. 不用分配空间,凡是需要每个结点多出存储指针的空间.
2. 任意的储存单位
3. 插入和删除操作时不需要移动数据元素；

劣势:
1. 单链表不支持随机读取,等于从头找到尾.