Java数据结构-链表(LinkedList)(四)

• 方式三、

什么是链表

• 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是在每一个节点（数据存储单元）里存放下一个节点的位置信息（即地址）；

• 顺序表的构建需要预先知道数据大小来申请连续的存储空间，而在进行扩充时又需要进行数据的搬迁，所以使用起来并不是很灵活；

• 链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。

1. 单向链表

单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。

• 表元素域elem用来存放具体的数据；
• 链接域next用来存放下一个节点的位置 ；
• 变量p指向链表的头节点（首节点）的位置，从p出发能找到表中的任意节点。

代码实现《单向链表》

package com.daley.linkedlist;


import java.util.Iterator;

class Test{
    public static void main(String[] args) {
        MyLinkedList<Object> ml = new MyLinkedList<>();
        ml.insert("aa");
        ml.insert("bb");
        ml.insert("cc");
        ml.insert(0,"dd");
        for (Object s : ml){
            System.out.println(s);
        }

    }
}


public class MyLinkedList<T> implements Iterable<T> {
    //记录头结点
    private Node head;
    //记录链表的长度
    private int N;

    public MyLinkedList(){
        this.head = new Node(null,null);
        this.N = 0;

    }



    /**
     *  定义节点类
     */
    private  class Node{
        T item ;   //存储数据

        Node next;  //下一个节点

        public Node(T item, Node next) {
            this.item = item;
            this.next = next;
        }
    }

    /**
     * 清空链表
     */
    public void clear(){
        this.head = null;
        this.N = 0;
    }

    /**
     * 判断链表是否为空，是返回true，否返回false
     * @return
     */
    public boolean isEmpty(){
        return this.N == 0;
    }

    /**
     * 获取链表中元素的个数
     * @return
     */
    public int length(){
        return this.N;
    }

    /**
     * 读取并返回链中的第index个元素的值
     * @param index
     * @return
     */
    public T get(int index){
        if(index > this.N){
            System.out.println("链表长度越界！");
            return null;
        }
        Node n = this.head;
        for (int i = 0; i < index; i++) {
            n = n.next;
        }

        return n.item;
    }

    /**
     * 往链表中添加一个元素
     * @param t
     */
    public void insert(T t){
        Node n = this.head;
        while (n.next != null){
            n=n.next;
        }
        //让当前最后一个结点指向新结点
        n.next = new Node(t, null);
        N ++;
    }

    /**
     * 在链表的第index个元素之前插入一个值为t的数据元素
     * @param index
     * @param t
     */
    public void insert(int index,T t){
        //找到index位置前一个结点
        Node pre = this.head;
        for (int i = 0; i <= index - 1 ; i++) {
            pre = pre.next;
        }
        //要找到index位置的结点
        Node curr = pre.next;

        pre.next = new Node(t,curr);
        this.N ++;
    }

    /**
     * 删除并返回链表中第i个数据元素
     * @param index
     * @return
     */
    public T remove(int index){
        //找到index位置前一个结点
        Node pre = this.head;
        for (