java手写实现LinkedList链表，面试手写链表简单实现

面试的时候，面试官可能给你一个笔记本，叫你手写一个linkedList，下面是我写的一个链表，亲测通过。

接口：

package com.test.common;

public interface MyLinkList<V> {
    void remove(V v);
    int add(V v);
    V get(int key);
    interface MyLinkEntity<V>{
        V getValue();
        MyLinkEntity next();
        MyLinkEntity before();
    }
}

实现：

package com.test.common.impl;

import com.test.common.MyLinkList;


import java.util.Objects;

public class MyLinkListImpl< V> implements MyLinkList< V> {

    /**
     * 最前面的值
     */
    private MyLinkEntityImpl<V> firstOne;

    /**
     * 最后的值
     */
    private MyLinkEntityImpl<V> lastOne;

    /**
     * 数组大小
     */
    private int size=0;

    public MyLinkListImpl() {

    }

    /**
     * 根据下标移除，只要查询出来具体节点，然后修改前后下标即可
     * @param v
     */
    @Override
    public void remove(V v) {
        MyLinkEntityImpl myLinkEntity=getNodeByValue(v,firstOne);
        myLinkEntity.before.next=myLinkEntity.next;
    }

    /**
     * 根据值查询所在下标，或者用于查询是否存在在链表之中
     * @param v
     * @param nx
     * @param i
     * @return
     */
    private Integer indexOf(V v,MyLinkEntityImpl nx,int i){
        if(nx.getValue().equals(v)){
            return i;
        }else if(Objects.nonNull(nx.next)){
            i++;
            indexOf(v,nx.next,i);
        }
        return i;
    }

    /**
     * 根据值查询模型
     * @param v
     * @param nx
     * @return
     */
    private MyLinkEntityImpl getNodeByValue(V v,MyLinkEntityImpl nx){
        if(nx.getValue().equals(v)){
            return nx;
        }else if(Objects.nonNull(nx.next)){
            return getNodeByValue(v,nx.next);
        }
        return nx;
    }

    /**
     * 链表添加数据
     * @param v
     * @return
     */
    @Override
    public int add(V v) {
        MyLinkEntityImpl newOne=new MyLinkEntityImpl(v,lastOne,null);
        if(Objects.isNull(firstOne)){
            firstOne=newOne;
            lastOne=newOne;
        }else{
            lastOne.next=newOne;
            lastOne=newOne;
        }
        size++;
        return size-1;
    }

    @Override
    public V get(int index) {
        MyLinkEntityImpl<V> one=getByIndex(index);
        if(Objects.isNull(one)){
            return null;
        }
        return one.getValue();
    }

    /**
     * 下标遍历
     * @param index
     * @return
     */
    MyLinkEntityImpl<V> getByIndex(int index){
        MyLinkEntityImpl one=firstOne;
        for(int i=0;i<index;i++)
        {
            one=one.next;
        }
        return one;
    }

    /**
     * 链表的单个个体
     * @param <V>
     */
    class MyLinkEntityImpl<V> implements MyLinkList.MyLinkEntity<V> {

        private V value;
        private MyLinkEntityImpl before;
        private MyLinkEntityImpl next;
        public MyLinkEntityImpl(V value,MyLinkEntityImpl before,MyLinkEntityImpl next) {
            this.value = value;
            this.next=next;
            this.before=before;
        }

        @Override
        public V getValue() {
            return value;
        }

        @Override
        public MyLinkEntityImpl next() {
            return next;
        }

        @Override
        public MyLinkEntityImpl before() {
            return before;
        }
    }
}

调用：

		MyLinkListImpl<String> sss=new MyLinkListImpl<>();
        sss.add("sssss");
        sss.add("dadasda");
        sss.add("pppppp");
        System.out.println(sss.get(1));
        sss.remove("dadasda");
        System.out.println(sss.get(1));