链表的简单源代码实现java

1.LinkedList

底层数据结构是双链表，查询慢，首尾操作的速度是极快的，所以多了很多首尾操作的特有API。

LinkedList集合的特有功能:

方法名称	说明
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素

2.实现代码及思路

import java.util.Arrays;

public class MYLinklist {
    private Node head;//头节点。
    private int size;//链表大小

  private static class Node {
      Object date;
      Node next;

      Node(Object date) {//创建新的节点。
          this.date = date;
      }
  }
        public MYLinklist(){//初始化链表
            head=null;
            size=0;
        }
    public int size() {
        return size;
    }
//开头插入指定元素；
    public void addFisrt(Object element){
        if(head == null){
            head = new Node(element);//创建一个新的node对象，也其实是创建了一个新的节点。
        }
        else{
            Node newone=new Node(element);
//            newone.next=head.next;
//            head.next=newone;
            newone.next = head;
            head = newone;//新类的尾插法，就是把我的新节点的next指向头节点，然后你这个节点再成为新的头节点。
        }

    }
    public void addLast(Object element){//先遍历，然后找最后一个节点，直接把最后一个节点的next指向最后加入的元素即可，为什么不用调用他的 指针到一直走呢？因为每次都是便利到最后一个元素，你调用指针无非就是让whlie少走一步，无所谓的。
    
        if (head == null) {
            head = new Node(element);
        } else {
            Node current = head;
            while (current.next != null) {
                current = current.next;
            }
            Node newone = new Node(element);
            current.next = newone;
        }
    }
    public Object getFirst() {//获取第一个元素
        if (head != null)
            return head.date;
        else {
            return null;
        }
    }
    public Object getLat()//这是获取最后一个元素
      if(head==null){
          return null;
      }  Node current=head;
      while (current.next!=null){
        current=current.next;
      }
      return current.date;
    }

import java.util.Arrays;

public class MYLinklist {
    private Node head;//头节点。
    private int size;//链表大小

  private static class Node {
      Object date;
      Node next;

      Node(Object date) {//创建新的节点。
          this.date = date;
      }
  }
        public MYLinklist(){//初始化链表
            head=null;
            size=0;
        }
    public int size() {
        return size;
    }
//开头插入指定元素；
    public void addFisrt(Object element){
        if(head == null){
            head = new Node(element);//创建一个新的node对象，也其实是创建了一个新的节点。
        }
        else{
            Node newone=new Node(element);
//            newone.next=head.next;
//            head.next=newone;
            newone.next = head;
            head = newone;//新类的尾插法，就是把我的新节点的next指向头节点，然后你这个节点再成为新的头节点。
        }

    }
    public void addLast(Object element){//先遍历，然后找最后一个节点，直接把最后一个节点的next指向最后加入的元素即可，为什么不用调用他的
      //指针到一直走呢？因为每次都是便利到最后一个元素，你调用指针无非就是让whlie少走一步，无所谓的。
        if (head == null) {
            head = new Node(element);
        } else {
            Node current = head;
            while (current.next != null) {
                current = current.next;
            }
            Node newone = new Node(element);
            current.next = newone;
        }
    }
    public Object getFirst() {
        if (head != null)
            return head.date;
        else {
            return null;
        }
    }
    public Object getLat(){
      if(head==null){
          return null;
      }  Node current=head;
      while (current.next!=null){

        current=current.next;
      }
      return current.date;
    }
    public Object removeFirst(){//删除并返回第一个元素
      if(head==null){
          return null;
      }
      else{
          Object A=head.date;//存储第一个元素的值用来返回。
        head=head.next;//头节点向后移了一位
          return A;
      }
    }
    public Object removeLast(){
        if (head == null) {
            return null;
        } else {
            Node current = head;
            Node currentpre = null;
            while (current.next != null) {
                currentpre = current;
                current = current.next;
            }//先找最后一个节点和最后一个节点的前一个节点。
            if (currentpre == null) {
                // 如果链表只有一个节点，直接将头节点置空
                head = null;
            } else {
                currentpre.next = null; // 将倒数第二个节点的 next 指针置为 null
            }
            Object A=current.date;
            return A; // 返回被删除的最后一个节点的值
        }
    }

    public void print(){  //输出方法
      Node current=head;
      while (current!=null){
          System.out.print(current.date+" ");
          current=current.next;
      }
        System.out.println();
    }
    public static void main(String[] args) {
        MYLinklist list=new MYLinklist();
        list.addFisrt(1);
        list.addFisrt(2);
        list.addFisrt(3);
        list.addFisrt(4);
        list.addLast(5);
        list.print();
        Object A=list.removeFirst();
        System.out.println(A);
        list.print();
        Object B=list.removeLast();
        System.out.println(B);
        list.print();
//        list.print();
//        System.out.println(list.getLat());
//        System.out.println(list.getFirst());


    }

第一行是原来的集合，第三行是删去第一个元素的集合，第五行是删除最后一个元素的集合。那2个单独数字分别是删去元素的返回值。

感谢观看酸Q你们！