数据结构02-链表

说明：由于该数据结构是由java并且是原生实现，所以与C有一些出入，不过原理是相同的

1.链表的定义

　　　　为了表示线性表元素a与a+1的逻辑关系，存储数据时，除了存储元素本身的信息之外，还存储了直接后继元素的位置信息。这两部分组成的数据元素被称为“结点”，一个结点分为两部分，存放数据元素信息的部分被称为数据域，

　　　　存放直接后继元素位置的部分被称为指针域。

　　　　单链表：结点指针域只存放直接后继元素位置的链表，也叫单向链表。

　　　　双链表：结点指针域同时存放前驱元素和后继元素位置的链表，也叫双向链表。

　　　　循环链表：一般的链表尾结点（最后一个结点）的指针域一般null，但是有的链表将最后一个节点的指针域指向头结点，构成一个环，称作循环链表。

　　　　头结点： 一个链表的头节点，就是指针域指向该链表的第一个结点的结点，一般用来唯一确定一个链表（也有的链表是不带头结点的，那时我们通过链表的第一个结点来确定链表），注意：头结点的数据与是null

2.实现原理

　　　　链表的每一个结点包括两部分，数据域和指针域，数据域用来存储数据，指针域用来存储后继结点的位置。

class Link<T>{
    /**
    *用来存储数据
    */
    T data;
    /**
    *用来存储下一结点位置
     */
    Link next;
}

3.链表的基本操作

　　　　1.初始化 init() 创建一个链表

　　　　2.清空 clear() 清空一个链表

　　　　3.销毁 destroy() 销毁链表

　　　　4.在头部插入一个结点 insertFront()

　　　　5.在尾部插入一个结点 insertBackend()

　　　　6.在任意位置插入一个结点 insertIndex()

　　　　7.删除任意位置元素 delete()

　　　　8.查找元素 find()

　　　　9.获取指定位置节点的值 get()

4.代码实现

　　4.1链表代码实现

package com.xiaobai.linelist;

/**
 * @Author: xiaobai
 * @Date: 2019/5/1 9:00
 * @email:
 * @address:
 * @desc 模拟单链表操作
 * @Version 1.0
 */
@SuppressWarnings("ALL")
public final class Link<T> {
    /**
     * data 是要存储的数据
     */
    private T data;
    /**
     * next是下一结点的引用位置
     */
    public Link<T> next;

    /**
     * 初始化操作 构造方法返回一个空结点
     */
    public Link(){
        this.next = null;
        this.data = null;
    }

    /**
     * 构造一个新的链表结点
     * 新结点是没有后继结点的 所以直接null
     * @param data 数据
     */
    public Link(T data){
        this.data = data;
        this.next = null;
    }

    /**
     * 清空链表操作
     * @param link 要被清空的链表头节点
     */
    public void clear(){
        //让每一个结点的引用都为 null GC 自动回收
        Link<T> link = this;
        while(link.next!=null){
            Link curr = link.next;
            link.next = link.next.next;
            curr = null;
        }
        link = null;
    }

    /**
     * 销毁链表 这里的销毁和清空我认为没有什么区别，所以直接调用
     * 如果大家认为有区别的话，可以与我交流
     * @param link 被销毁的链表
     */
    public void destroy(){
        this.clear();
    }

    /**
     * 在链表的头部插入一个结点（默认是带头结点的链表）
     * @param head 链表的头节点
     * @param data 被插入的数据
     * @return 插入结果
     */
    public boolean insertFront(T data){
        //先构建一个新的结点
        Link<T> node = new Link<T>(data);
        try {
            //将结点插入到头部 即 新节点后继指向原来的第一个结点  头节点后继指向新节点
            node.next = this.next;
            this.next = node;
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 在链表的尾部插入一个结点
     * @param head 链表头节点
     * @param data 要插入的数据
     * @return 插入结果
     */
    public boolean insertBackend(T data){
        //先构建一个新的结点
        try {
            Link<T> node = new Link<T>(data);
            //然后找到链表的尾
            Link<T> point = this.next;
            while(point.next!=null){
                point = point.next;
            }
            //插入
            point.next = node;
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 在任意位置插入一个结点
     * @param head 要插入的链表
     * @param i  插入位置 从0开始
     * @param data 插入的数据
     * @return 插入结果
     */
    public boolean insertIndex(int i,T data){
        Link curr = this.next;
        //空链表 拒绝插入
        if(null == curr && i > 0){
            return false;
        }
        int count = 0;
        //找到被插入的位置（要找被插入位置前一个）
        while(count != i-1 && null != curr){
            curr = curr.next;
            count ++;
        }
        //如果循环提前结束 说明i值过大
        if(count != i-1){
            return false;
        }
        //开始插入节点
        Link<T> node = new Link<T>(data);
        node.next = curr.next;
        curr.next = node;
        return true;
    }

    /**
     * 删除任意位置元素
     * @param i 被删除的位置  从0 开始
     * @return 被删除的元素 删除失败返回null
     */
    public T delete(int i){
        T del = null;
        int count = 0;
        Link<T> curr = this.next;
        //找到被删除结点的前一个结点
        while (curr != null&& count < i-1){
            curr = curr.next;
            count++;
        }
        //如果不满足条件 删除失败
        if(count!=i-1){
            return del;
        }
        //如果找到 执行删除操作 （GC 自动释放）
        del = curr.next.data;
        curr.next = curr.next.next;
        return del;
    }

    /**
     * 查找元素是否存在  可能需要重写存储对象的equals方法
     * @param data 被查找元素
     * @return 查找结果
     */
    public boolean find(T data){
        Link curr = this.next;
        while(curr != null){
            if(curr.data.equals(data)||curr.data ==data){
                return true;
            }
            curr = curr.next;
        }
        return false;
    }

    /**
     * 获取指定位置的元素
     * @param i 位置
     * @return 获取到的值 没有返回null
     */
    public T get(int i) {
        T data = null;
        Link<T> curr = this.next;
        int count = 0;
        while(count!=i && curr!=null){
            curr = curr.next;
            count ++;
        }
        if(count == i && curr!= null){
            data = curr.data;
        }
        return data;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder().append("HashCode = "+this.hashCode()).append(" {head -> ");
        Link<T> curr = this.next;
        while (curr!=null){
            sb.append(curr.data+" -> ");
            curr = curr.next;
        }
        sb.append(" null}");
        return sb.toString();
    }
}

　　4.2  测试代码及结果

/**
 * @Author: xiaobai
 * @Date: 2019/5/1 9:42
 * @email: 
 * @address:
 * @Version 1.0
 */
public class TestLink {
    public static void main(String[] args) {
        System.out.println("初始化链表");
        Link<Integer> link = new Link<>();
        System.out.println("当前链表: "+link);

        System.out.println("在前端插入一个元素 5");
        link.insertFront(5);
        System.out.println("当前链表: "+link);

        for(int i=1;i<=10;i++){
            link.insertBackend(i);
        }
        System.out.println("依次从后端继续插入10个数后： "+link);

        link.insertIndex(3,100);
        //索引从0开始
        System.out.println("在第三个位置上插入100以后的链表 "+link);

        System.out.println("在第100个位置上插入0 "+link.insertIndex(100,0));

        System.out.println("删除第三个位置上的元素"+link.delete(3));
        System.out.println(link);

        System.out.println("查找元素10的结果"+link.find(10));
        System.out.println("查找元素100的结果"+link.find(100));

        System.out.println("获取第3个结点的值 "+link.get(3));
        System.out.println("获取第999个结点的值 "+link.get(999));

        link.clear();
        System.out.println("执行清空操作后的链表： "+link);

        link.destroy();

    }
}

　　　　　　运行结果图：