Java-链表（单向链表、双向链表）

Java-链表

1、什么是链表？

2、链表的特点是什么？

3、链表的实现原理？

4、如何自己写出一个链表？

---

1、什么是链表？

• 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针连接次序实现的。
• 每一个链表都包含多个节点，节点又包含两个部分，一个是数据域（储存节点含有的信息），一个是引用域（储存下一个节点或者上一个节点的地址）。
• 链表的理解示意图

2、链表的特点是什么？

• 获取数据麻烦，需要遍历查找，比数组慢
• 方便插入、删除

3、链表的实现原理

1. 创建一个节点类，其中节点类包含两个部分，第一个是数据域（你到时候要往节点里面储存的信息），第二个是引用域（相当于指针，单向链表有一个指针，指向下一个节点；双向链表有两个指针，分别指向下一个和上一个节点）
2. 创建一个链表类，其中链表类包含三个属性：头结点、尾节点和大小，方法包含添加、删除、插入等等方法。

单向链表的节点类：

 public class Node {
     public Object data;
     public Node next;

     public Node(Object e){
         this.data = e;
     }
 }

双向链表的节点类：

 public class Node {
     public Object e;
     public Node next;
     public Node pre;
     public Node(){

     }
     public Node(Object e){
         this.e = e;
         next = null;
         pre = null;
     }
 }

4、如何自己写出一个链表？

代码如下（以双向链表为例，有详细的注释，单向链表同理）：

首先创建了一个节点类

 package MutuLink;

 public class Node {
     public Object e;
     public Node next;
     public Node pre;
     public Node(){

     }
     public Node(Object e){
         this.e = e;
         next = null;
         pre = null;
     }
 }

然后创建了一个链表类

 package MutuLink;

 public class MyList {
     private Node head;
     private Node tail;
     private int size = 0;

     public MyList() {
         head = new Node();
         tail = new Node();
         head.next =null;
         tail.pre = null;
     }

     public boolean empty() {
         if (head.next == null)
             return true;
         return false;
     }
     //找到所找下标节点的前一个节点
     public Node findpre(int index){
         Node rnode = head;
         int dex = -1;
         while(rnode.next != null){
             //找到了插入节点的上一个节点
             if( dex== index - 1){
                 return rnode;
             }
             rnode = rnode.next;
             dex++;
         }
         return null;
     }
     public Node findthis(int index){
         Node rnode = head;
         //把rnode想象为指针，dex为指向的下标，这个地方很容易错，因为当指向最后一个节点时没有判断IF就跳出循环了
         int dex = -1;
         while(rnode.next != null){
             if(dex == index)
             return rnode;
             rnode = rnode.next;
             dex++;
         }
         if(dex == size - 1){
             return rnode;
         }
 //        Node test = new Node(new Students("haha",1,2));
         return null;
     }

     // 往链表末尾加入节点
     public void add(Object e) {
         Node node = new Node(e);
         Node rnode = head;
         //如果是空链表的话插入一个节点，这个节点的pre不能指向上一个节点，必须指空
         if (this.empty()) {
             rnode.next = node;
             rnode.next.pre = null;
             tail.pre = node;
             size++;
         } else {
             while (rnode.next != null)
                 rnode = rnode.next;
             rnode.next = node;
             node.pre = rnode;
             tail.pre = node;
             size++;
         }
     }
     //往链表的某一个标插入一个节点
     public boolean add(int index,Object e){
         if(index <0||index>=size)
             return false;
         Node node = new Node(e);
         Node prenode = this.findpre(index);
         node.next = prenode.next;
         prenode.next.pre = node;
         prenode.next = node;
         node.pre = prenode;
         size++;
         return true;
     }
     public boolean add(int index,MyList myl){
         if(index <0 || index >= size)
             return false;
         Node prenode = this.findpre(index);
 //        myl.tail.pre.next = prenode.next;
 //        prenode.pre = myl.tail.pre;
 //        tail.pre = null;
 //        prenode.next = myl.head.next;
 //        myl.head.next.pre = prenode;
 //        head.next = null;
         myl.tail.pre.next = prenode.next;
         prenode.next.pre = myl.tail.pre.pre;
         myl.head.next.pre = prenode.pre;
         prenode.next = myl.head.next;
         myl.head = null;
         myl.tail = null;
         size+=myl.size;
         return true;
     }

     public Object remove(int index){
         Object ob= this.get(index);
         if(index <0 || index >= size)
             return null;
         //特殊情况，当移除节点是最后一个节点的时候
         //较为复杂通过画图来写代码
         if(index == size - 1){
             Node prenode = this.findpre(index);
             this.tail.pre = this.tail.pre.pre;
             this.tail.pre.next.pre = null;
             this.tail.pre.next =null;
             size--;
             return ob;
         }
         //比较复杂，通过画图解决
         else{
             Node prenode = this.findpre(index);
             prenode.next = prenode.next.next;
             prenode.next.pre.next = null;
             prenode.next.pre = prenode.next.pre.pre;
             size--;
             return ob;
         }
     }

     public Object get(int index){
         Node thisnode = this.findthis(index);
         return thisnode.e;
     }
     public int size(){
         return size;
     }
 }

最后测试

 package MutuLink;

 import java.util.Random;

 public class manage {
     public static void main(String[] args) {
         String name = "";
         int credit;
         int age;
         int size;
         MyList myl = new MyList();
         Random random = new Random();
         size = random.nextInt(5) + 1;
         for (int i = 0; i < size; i++) {
             credit = random.nextInt(5);
             age = random.nextInt(5) + 18;
             for (int j = 0; j < 4; j++) {
                 name += (char) (random.nextInt(26) + 97);
             }
             Students stu = new Students(name, credit, age);
             myl.add(stu);
             name = "";
         }

         System.out.println("Size of myl1 is "+ myl.size());
         for(int i = 0; i < myl.size() ;i++){
             Students stu2 = (Students) myl.get(i);
             stu2.show();
         }
 //        //测试能否在链表末尾加入节点（成功）
 //        for(int i = 0; i < myl.size() ;i++){
 //            Students stu2 = (Students) myl.get(i);
 //            stu2.show();
 //        }
 //        //测试能否通过下标加入一个节点（成功）
 //        Students stu3 = new Students("cyt",5,18);
 //        myl.add(1, stu3);
 //        System.out.println("Size is "+ myl.size());
 //        for(int i = 0; i < myl.size() ;i++){
 //            Students stu2 = (Students) myl.get(i);
 //            stu2.show();
 //        }

         MyList myl2 = new MyList();
         size = random.nextInt(5) + 1;
         for (int i = 0; i < size; i++) {
             credit = random.nextInt(5);
             age = random.nextInt(5) + 18;
             for (int j = 0; j < 4; j++) {
                 name += (char) (random.nextInt(26) + 97);
             }
             Students stu2 = new Students(name, credit, age);
             myl2.add(stu2);
             name = "";
         }
         System.out.println("Size is of myl2 "+ myl2.size());
         for(int i = 0; i < myl2.size() ;i++){
             Students stu2 = (Students) myl2.get(i);
             stu2.show();
         }

         myl.add(1, myl2);
         System.out.println("Size is of myl1 "+ myl.size());
         for(int i = 0; i < myl.size() ;i++){
             Students stu2 = (Students) myl.get(i);
             stu2.show();
         }

     }

 }

结果输出：

这样，一个简单的双向链表就编写完成了，希望这篇博客对您有所帮助哦！