devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

教你手撕链表

作者：很楠不爱3 | 2024-06-02 07:05:55

赞

踩

手撕链表

目录

链表的概念

单向链表

 链表的创建

节点的创建

创建链表

添加节点

头插法

尾插法

按照索引插入新节点

删除节点

删除第一个值为val的节点

删除索引指向的节点并返回该节点的值

删除头结点

删除尾节点

删除所有值为val的节点

修改节点值

查询节点

将链表打印输出并返回有效节点个数

双向链表

节点的创建

链表的创建

 增加节点

 头插法

尾插法

根据索引插入节点

查找节点

根据索引查找

根据值从头查找第一个值为val的节点返回索引

根据值从尾查找第一个值为val的节点返回索引

 删除节点

原理

根据索引删除节点

根据值从头开始删除第一个值为val节点

根据值从尾开始删除第一个值为val节点

删除所有值为val的节点

修改节点

将链表打印输出并返回有效节点个数

单链表源码

节点代码

链表代码

测试代码

双向链表源码

节点代码

链表代码

测试代码

链表的概念

链表是由许多相同数据类型的数据项，按照特定顺序排列而成的线性表。但链表的特性是其各个数据项在计算机内存中存储的位置是不连续且随机存放的，其优点是数据的插入或者删除都相当的方便呢，有新数据加入就向系统申请一块内存空间，而数据删除之后，就可以把这块内存空间还给系统，加入和删除都不需要移动大量的数据。缺点是在查找数据使，无法向数组那样可以随机数据，必须按序查找到该数据为止。

火车就可以看做一个链表

单向链表

一个单向链表节点由两个元素，一个是数据字段和指针多组成，指针会指向下一个节点的地址，一个节点如图所示。

    在单项链表中，第一个节点是头结点，它是一个链表的开始，最后一个节点指针指向null；例如下面链表.

 链表的创建

节点的创建

要创建链表首先需要创建节，我们创建节点类，定义节点的属性，每个节点有值和下一个节点的地址。

  1. package relinklist;
  2. //
  3. public class Node {
  4.     //下一个节点的地址
  5.     private Node next;
  6.     //节点保存的值
  7.     private int val;
  8.  
  9.     public Node() {
  10.     }
  11.  
  12.     public Node(int val) {
  13.         this.val = val;
  14.     }
  15.  
  16.     public Node getNext() {
  17.         return next;
  18.     }
  19.  
  20.     public void setNext(Node next) {
  21.         this.next = next;
  22.     }
  23.  
  24.     public int getVal() {
  25.         return val;
  26.     }
  27.  
  28.     public void setVal(int val) {
  29.         this.val = val;
  30.     }
  31. }

创建链表

  1. public class LinkList {
  2.     //链表的头结点
  3.     private Node head;
  4.     //链表有效节点个数
  5.     private int size;
  6.     //无参构造方法
  7.     public LinkList() {
  8.     }
  9.     //有参构造方法
  10.     public LinkList(int val) {
  11.         Node node = new Node(val);
  12.         this.head = node;
  13.         this.size = 1;
  14.     }

添加节点

向链表中添加节点分为三种方式1、头插法 2、尾插法 3、向索引指向位置插入

头插法

向链表最前方插入节点，需要将新节点的指针指向链表当前的头结点，再将头节点移向新节点，让新节点来做头节点。

  1.     /**
  2.      * 向链表中添加节点（头插）
  3.      */
  4.     public void addNode(int val) {
  5.         if (head == null) {
  6.             //当链表为空时，将新节点赋给头节点    
  7.             head = new Node(val);
  8.         } else {
  9.             Node newNode = new Node();
  10.             newNode.setVal(val);
  11.             newNode.setNext(head);
  12.             head = newNode;
  13.         }
  14.         size++;
  15.     }

尾插法

让原链表的，指向新创建的节点。

  1.     /**
  2.      * 向链表的尾部插入节点
  3.      *
  4.      * @param val 插入节点的值
  5.      */
  6.     public void addNodeEnd(int val) {
  7.         if (this.head == null) {
  8.             //链表为空，将新节点赋给头结点
  9.             head = new Node(val);
  10.         } else {
  11.             Node x = head;
  12.             for (int i = 0; i < size - 1; i++) {
  13.                 x = x.getNext();
  14.             }
  15.             x.setNext(new Node(val));
  16.         }
  17.         size++;
  18.     }

按照索引插入新节点

首先需要找到索引位置的前节点节，将索引处节点与前节点连接断开，将前节点的指针指向新节点，新节点的指针指向之前的索引处节点。使用时需要判断索引是否是有效的。

例如向下面链表索引2，添加值为2的节点

  1.     /**
  2.      * 向链表中的目标位置插入节点
  3.      *
  4.      * @param index 目标位置
  5.      * @param val   插入节点值
  6.      */
  7.     public void addNodeIndex(int index, int val) {
  8.         if (index > size || index < 0) {
  9.             System.out.println("无效下标");
  10.             return;
  11.         } else if (index == 0) {
  12.             //当索引指向头节点时
  13.             addNode(val);
  14.         } else if (index == size) {
  15.             //当索引指向链表最后NULL时
  16.             addNodeEnd(val);
  17.         } else {
  18.             Node node = head;
  19.             Node x = new Node(val);
  20.             for (int i = 0; i < size - 1; i++) {
  21.                 if (i == index - 1) {
  22.                     x.setNext(node.getNext());
  23.                     node.setNext(x);
  24.                     size++;
  25.                     return;
  26.                 }
  27.                 node = node.getNext();
  28.             }
  29.         }
  30.     }

删除节点

删除第一个值为val的节点

删除第一个值为val的节点，需要前节点指向指向值为val节点的后节点，使val节点没有节点指向它

删除链表中第一个值3的节点

 先判断知否有值为val的节点

  1.     /**
  2.      * 判断链表中是否有包含值为val的节点
  3.      * @param val 节点的值
  4.      * @return 有值为val的节点返回true，没有返回false
  5.      */
  6.     public boolean contains(int val) {
  7.         return getNodeIndex(val) != -1;
  8.     }

进行删除操作 

  1.  /**
  2.      * 删除第一次出现值为val的节点
  3.      *
  4.      * @param val 删除节点的值
  5.      */
  6.     public void deleteNodeVal(int val) {
  7.         if (contains((val))) {
  8.             while (head.getVal() == val) {
  9.                 if (head.getNext() != null) {
  10.                     Node node = head;
  11.                     head = head.getNext();
  12.                     node.setNext(null);
  13.                     size--;
  14.                     return;
  15.                 } else {
  16.                     head = null;
  17.                     size--;
  18.                     return;
  19.                 }
  20.             }
  21.             Node x = head;
  22.             while (x.getNext() != null) {
  23.                 if (x.getNext().getVal() == val) {
  24.                     Node node = x.getNext();
  25.                     x.setNext(x.getNext().getNext());
  26.                     node.setNext(null);
  27.                     size--;
  28.                     return;
  29.                 } else {
  30.                     x = x.getNext();
  31.                 }
  32.             }
  33.         }
  34.         System.out.println("没有值为" + val + "的节点");
  35.     }

删除索引指向的节点并返回该节点的值

删除索引指向的节点，需要前节点指向待删除节点的后节点，使待删除节点没有节点指向它

删除索引为1的节点

先判断索引对否有效

  1.     /**
  2.      * 判断索引的合法性，是否为负数，是否小于size
  3.      *
  4.      * @param index 索引
  5.      * @return 为负数或者不小于size返回false，在区间内返回true
  6.      */
  7.     private boolean rangeCheck(int index) {
  8.         if (index < 0 || index >= size) {
  9.             return false;
  10.         }
  11.         return true;
  12.     }

进行删除操作

  1.     /**
  2.      * 删除索引指向的节点并返回节点原先的值
  3.      *
  4.      * @param index
  5.      * @return
  6.      */
  7.     public int deleteNodeReVal(int index) {
  8.         if (rangeCheck(index)) {
  9.             int oldVal = getIndexNode(index);
  10.             if (index == 0) {
  11.                 Node x = head;
  12.                 head = head.getNext();
  13.                 x.setNext(null);
  14.                 size--;
  15.                 return oldVal;
  16.             }
  17.             Node x = head;
  18.             for(int i = 0; i < index - 1; i ++){
  19.                 x = x.getNext();
  20.             }
  21.             Node node = x.getNext();
  22.             x.setNext(x.getNext().getNext());
  23.             node.setNext(null);
  24.             size --;
  25.             return oldVal;
  26.         }
  27.         System.err.println("index illegal! get error");
  28.         return -1;
  29.     }

删除头结点

让头结点后移到头结点指向的后一节点，原先的头结点指向null；

使用删除索引指向的节点，删除索引为0的节点

  1.     /**
  2.      * 删除头节点
  3.      */
  4.     public void deleteFirstNode(){
  5.         deleteNodeReVal(0);
  6.     }

删除尾节点

让最后一个节点的前一个节点指向null；

使用删除索引指向的节点，删除索引为size-1（有效节点数量 - 1）的节点

  1.     /**
  2.      * 删除尾节点
  3.      */
  4.     public void deleteEndNode(){
  5.         deleteNodeReVal(size - 1);
  6.     }

删除所有值为val的节点

删除所有值为2的节点

当链表的头节点的值就位2时，需要先进行从头删除，找出删除后链表的头结点

再对头节点不为2之后的值为2的节点进行删除

  1.     /**
  2.      *删除所有值为val的节点
  3.      * @param val 节点包含的值
  4.      */
  5.     public void deleteSameNodeVal(int val){
  6.         if(contains(val)){
  7.             while(head.getVal() == val){
  8.                 if(head.getNext() != null){
  9.                     Node node = head;
  10.                     head = head.getNext();
  11.                     node.setNext(null);
  12.                     size--;
  13.                 }else{
  14.                     head = null;
  15.                     size--;
  16.                     return;
  17.                 }
  18.             }
  19.             Node x = head;
  20.             while(x.getNext() != null){
  21.                 if(x.getNext().getVal() == val){
  22.                     Node node = x.getNext();
  23.                     x.setNext(x.getNext().getNext());
  24.                     node.setNext(null);
  25.                     size --;
  26.                 }else{
  27.                     x = x.getNext();
  28.                 }
  29.             }
  30.         }
  31.     }

修改节点值

修改只需通索引找到该节点，再进行修改错

修改索引指向的节点并返回原先的值

  1.     /**
  2.      * 修改索引指向节点的值并返回原始先的值
  3.      *
  4.      * @param index 索引
  5.      * @param val   修改节点的值
  6.      * @return 返回节点原先的值
  7.      */
  8.     public int setIndexNode(int index, int val) {
  9.         if (rangeCheck(index)) {
  10.             int oldVal = getIndexNode(index);
  11.             Node node = head;
  12.             for (int i = 0; i < index; i++) {
  13.                 node = node.getNext();
  14.             }
  15.             node.setVal(val);
  16.             return oldVal;
  17.         }
  18.         System.err.println("index illegal! get error");
  19.         return -1;
  20.     }

查询节点

通过索引查找索引指向的节点，或者通过值查找第一个值为val的节点

  1.     /**
  2.      * 查询索引 index 所指向节点的值
  3.      *
  4.      * @param index 索引
  5.      * @return 返回查询节点的值
  6.      */
  7.     public int getIndexNode(int index) {
  8.         if (rangeCheck(index)) {
  9.             Node x = head;
  10.             for (int i = 0; i < index; i++) {
  11.                 x = x.getNext();
  12.             }
  13.             return x.getVal();
  14.         }
  15.         System.err.println("index illegal! get error");
  16.         return -1;
  17.     }
  1.     /**
  2.      * 查询第一个值为val的节点的索引
  3.      *
  4.      * @param val 将要节点的值
  5.      * @return 返回节点的索引
  6.      */
  7.     public int getNodeIndex(int val) {
  8.         int index = 0;
  9.         for (Node node = head; node != null; node = node.getNext()) {
  10.             if (val == node.getVal()) {
  11.                 return index;
  12.             }
  13.             index++;
  14.         }
  15.         //链表中没有值为val的节点
  16.         return -1;
  17.     }

将链表打印输出并返回有效节点个数

  1.     /**
  2.      * 打印双向链表
  3.      *
  4.      * @return 返回双向链表每个节点的值
  5.      */
  6.     public StringBuffer toPrint() {
  7.         StringBuffer sb = new StringBuffer();
  8.         if (size == 0) {
  9.             return sb.append("null");
  10.         }
  11.         Node node = head;
  12.         for (int i = 0; i < size; i++) {
  13.             sb.append(node.getVal());
  14.             sb.append("-->");
  15.             node = node.getNext();
  16.         }
  17.         sb.append("null");
  18.         return sb;
  19.     }
  20.  
  21.     /**
  22.      * 返回size的值
  23.      *
  24.      * @return 返回size
  25.      */
  26.     public int getSize() {
  27.         return size;
  28.     }
  29. }

双向链表


双向链表的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。

节点的创建

  1.  
  2.  
  3. public class Node {
  4.     private Node prev;
  5.     private int val;
  6.     private Node next;
  7.  
  8.     public Node() {
  9.     }
  10.  
  11.     public Node(int val) {
  12.         this.val = val;
  13.     }
  14.  
  15.     public Node(Node prev, int val, Node next) {
  16.         this.prev = prev;
  17.         this.val = val;
  18.         this.next = next;
  19.     }
  20.  
  21.     public Node getPrev() {
  22.         return prev;
  23.     }
  24.  
  25.     public void setPrev(Node prev) {
  26.         this.prev = prev;
  27.     }
  28.  
  29.     public int getVal() {
  30.         return val;
  31.     }
  32.  
  33.     public void setVal(int val) {
  34.         this.val = val;
  35.     }
  36.  
  37.     public Node getNext() {
  38.         return next;
  39.     }
  40.  
  41.     public void setNext(Node next) {
  42.         this.next = next;
  43.     }
  44. }

链表的创建

  1. public class DoubleLinkList {
  2.     private Node head;
  3.     private Node tail;
  4.     private int size;
  5. }

 增加节点

 头插法

将新节点的后指针，指向当前链表的头节点，头节点的前指针，指向新节点，最后将新节点赋给头节点

  1.     /**
  2.      * 头插法
  3.      *
  4.      * @param val 插入节点的值
  5.      */
  6.  
  7.     public void addHead(int val) {
  8.         Node node = new Node(null, val, head);
  9.         if (tail != null) {
  10.             head.setPrev(node);
  11.         } else {
  12.             tail = node;
  13.         }
  14.         head = node;
  15.         size++;
  16.     }

尾插法

将新节点的前指针，指向尾节点，尾节点的后指针，指向新节点，将新节点赋给尾节点

  1.     /**
  2.      * 尾插法
  3.      *
  4.      * @param val 插入节点的值
  5.      */
  6.     public void addEnd(int val) {
  7.         Node node = new Node(tail, val, null);
  8.         if (tail == null) {
  9.             addHead(val);
  10.         } else {
  11.             tail.setNext(node);
  12.             tail = node;
  13.             size++;
  14.         }
  15.     }

根据索引插入节点

由于双向链表可以从头遍历到尾，或者从尾遍历到头，当我们有100个节点，插入节点位置是10，我们从头找开始很快，当位置为90时，我们发现从尾部开始找很快，所以我们创建一个方法来判断从头开始找还是从尾部开始找

  1.     /**
  2.      * 判断索引的节点是从头插入还是从尾插入
  3.      *
  4.      * @param index 索引
  5.      * @return 返回 1 则从头插入，返回 0则从尾部插入，返回-1是无效下标
  6.      */
  7.     private int headOrEnd(int index) {
  8.         if (checkIndex(index)) {
  9.             if (index < size / 2) {
  10.                 return 1;
  11.             } else {
  12.                 return 0;
  13.             }
  14.         }
  15.         return -1;
  16.     }

 然后进行擦插入操作，将索引指向节点的前置节点与新节点相连1操作，再将新节点与索引指向节点相连2操作 

  1.     /**
  2.      * 根据索引插入节点
  3.      *
  4.      * @param index 索引
  5.      * @param val   节点值
  6.      */
  7.     public void addAnyIndex(int index, int val) {
  8.         if (index == 0) {
  9.             addHead(val);
  10.             return;
  11.         } else if (index == size) {
  12.             addEnd(val);
  13.             return;
  14.         }
  15.         Node node = new Node(val);
  16.         if (headOrEnd(index) == 1) {
  17.             //头部插入
  18.             Node h = head;
  19.             for (int i = 0; i < index; i++) {
  20.                 h = h.getNext();
  21.             }
  22.             Node a = h.getPrev();
  23.             node.setPrev(a);
  24.             a.setNext(node);
  25.             node.setNext(h);
  26.             h.setPrev(node);
  27.         } else if (headOrEnd(index) == 0) {
  28.             //尾部插入
  29.             Node t = tail;
  30.             for (int i = 0; i < size - index; i++) {
  31.                 t = t.getPrev();
  32.             }
  33.             Node a = t.getNext();
  34.             node.setNext(a);
  35.             a.setPrev(node);
  36.             node.setPrev(t);
  37.             t.setNext(node);
  38.         } else {
  39.             System.out.println("索引不合法");
  40.             return;
  41.         }
  42.         size++;
  43.     }

查找节点

根据索引查找

需要判断索引的合法性

  1.     /**
  2.      * 判断索引的合法性
  3.      *
  4.      * @param index 索引
  5.      * @return 返回false 索引不合法，返回true 索引合法
  6.      */
  7.     private Boolean checkIndex(int index) {
  8.         if (index < 0 || index >= size) {
  9.             return false;
  10.         } else {
  11.             return true;
  12.         }
  13.     }

进行查找

  1.     /**
  2.      * 根据索引查询目标节点
  3.      *
  4.      * @param index 索引
  5.      * @return 返回目标节点的值, 返回-1表示无效索引
  6.      */
  7.     public int getIndexNodeVal(int index) {
  8.         int count = 0;
  9.         if (headOrEnd(index) == 1) {
  10.             //从头结点开始查询
  11.             Node node = head;
  12.             while (count < index) {
  13.                 node = node.getNext();
  14.                 count++;
  15.             }
  16.             return node.getVal();
  17.         }
  18.         if (headOrEnd(index) == 0) {
  19.             //从尾节点开始查询
  20.             Node node = tail;
  21.             while (count < size - 1 - index) {
  22.                 node = node.getPrev();
  23.                 count++;
  24.             }
  25.             return node.getVal();
  26.         }
  27.         System.err.println("无效索引");
  28.         return -1;
  29.     }

根据值从头查找第一个值为val的节点返回索引

  1.     /**
  2.      * 根据值从头结点开始查询第一个值为val的节点返回节点索引
  3.      *
  4.      * @param val 查询节点值
  5.      * @return 查询到的节点索引
  6.      */
  7.     public int getValHeadNodeIndex(int val) {
  8.         Node node = head;
  9.         int index = 0;
  10.         while (node != null) {
  11.             if (node.getVal() == val) {
  12.                 return index;
  13.             }
  14.             index++;
  15.             node = node.getNext();
  16.         }
  17.         //查找不到值为val的节点返回-1
  18.         return -1;
  19.     }

根据值从尾查找第一个值为val的节点返回索引

  1.     /**
  2.      * 根据值从尾结点开始查询第一个值为val的节点返回节点索引
  3.      *
  4.      * @param val 查询节点值
  5.      * @return 查询到的节点索引
  6.      */
  7.     public int getValEndNodeIndex(int val) {
  8.         Node node = tail;
  9.         int index = 0;
  10.         while (node != null) {
  11.             if (node.getVal() == val) {
  12.                 return size - 1 - index;
  13.             }
  14.             index++;
  15.             node = node.getPrev();
  16.         }
  17.         //查找不到值为val的节点返回-1
  18.         return -1;
  19.     }

 删除节点

原理

先找到待删除节点，将待删除节点的后置节点赋给一个新节点x，再将待删除节点与x节点相连，带删除节点的前指针和后指针指向空。先执行1操作，再执行2、3操作，最后4、5操作

根据索引删除节点

先根据值找到待删除节点之后执行删除操作

  1.     /**
  2.      * 删除索引指向的节点，并返回该节点的值
  3.      *
  4.      * @param index 索引
  5.      * @return 删除节点的值
  6.      */
  7.     public int deleteIndex(int index) {
  8.         int val = 0;
  9.         if (checkIndex(index)) {
  10.             if (index == size - 1) {
  11.                 //链表只有一个节点时;
  12.                 if (size == 1) {
  13.                     val = head.getVal();
  14.                     head = tail = null;
  15.                     size--;
  16.                     return val;
  17.                 }
  18.                 //不止一个节点
  19.                 val = tail.getVal();
  20.                 Node x = tail.getPrev();
  21.                 tail.setPrev(null);
  22.                 x.setNext(null);
  23.                 tail = x;
  24.             } else if (index == 0) {
  25.                 val = head.getVal();
  26.                 Node x = head.getNext();
  27.                 x.setPrev(null);
  28.                 head.setNext(null);
  29.                 head = x;
  30.             } else {
  31.                 Node node = head;
  32.                 for (int i = 0; i < index; i++) {
  33.                     node = node.getNext();
  34.                 }
  35.                 val = node.getVal();
  36.                 Node x = node.getPrev();
  37.                 Node n = node.getNext();
  38.                 x.setNext(n);
  39.                 n.setPrev(x);
  40.             }
  41.             size--;
  42.             return val;
  43.         }
  44.         //索引不合法返回-1
  45.         return -1;
  46.     }

根据值从头开始删除第一个值为val节点

  1.     /**
  2.      * 从头开始删除第一个值为val的节点
  3.      *
  4.      * @param val 删除节点的值
  5.      */
  6.     public void deleteHeadFirstVal(int val) {
  7.         int index = getValHeadNodeIndex(val);
  8.         deleteIndex(index);
  9.     }

根据值从尾开始删除第一个值为val节点

  1.     /**
  2.      * 从尾开始删除第一个值为val的节点
  3.      * @param val 删除节点的值
  4.      */
  5.     public void deleteTailFirstVal(int val) {
  6.         int index = getValEndNodeIndex(val);
  7.         deleteIndex(index);
  8.     }

删除所有值为val的节点

如果头结点就是待删除节点，则先处理头结点，当头结点不为待删除值时，处理后面的节点

  1.     /**
  2.      * 删除所有值为val的节点
  3.      *
  4.      * @param val 节点值
  5.      */
  6.     public void deleteSameVal(int val) {
  7.         if (getValHeadNodeIndex(val) != -1) {
  8.             while (head.getVal() == val) {
  9.                 if (head.getNext() != null) {
  10.                     Node x = head.getNext();
  11.                     head.setNext(null);
  12.                     x.setPrev(null);
  13.                     head = x;
  14.                     size--;
  15.                 } else {
  16.                     head = tail = null;
  17.                     size--;
  18.                     return;
  19.                 }
  20.             }
  21.             Node node = head;
  22.             while (node.getNext() != null) {
  23.                 if (node.getVal() == val) {
  24.                     Node x = node.getNext();
  25.                     Node h = node.getPrev();
  26.                     x.setPrev(h);
  27.                     h.setNext(x);
  28.                     node.setNext(null);
  29.                     node.setPrev(null);
  30.                     node = x;
  31.                     size--;
  32.                 } else {
  33.                     node = node.getNext();
  34.                 }
  35.             }
  36.             if (node.getVal() == val) {
  37.                 node.getPrev().setNext(null);
  38.                 tail = node.getPrev();
  39.                 node.setPrev(null);
  40.                 size--;
  41.             }
  42.             return;
  43.         }
  44.         System.out.println("链表中没有此节点");
  45.     }

修改节点

根据索引修改节点的值

  1.     /**
  2.      * 根据索引修改该节点，并返回修改前的值
  3.      *
  4.      * @param index 索引
  5.      * @param val   修改的值
  6.      * @return 返回修改前的值
  7.      */
  8.     public int setIndexVal(int index, int val) {
  9.         if (headOrEnd(index) == 1) {
  10.             Node node = head;
  11.             for (int i = 0; i < index; i++) {
  12.                 node = node.getNext();
  13.             }
  14.             int reVal = node.getVal();
  15.             node.setVal(val);
  16.             return reVal;
  17.         } else if (headOrEnd(index) == 0) {
  18.             Node node = tail;
  19.             for (int i = 0; i < size - 1 - index; i++) {
  20.                 node = node.getPrev();
  21.             }
  22.             int reVal = node.getVal();
  23.             node.setVal(val);
  24.             return reVal;
  25.         }
  26.         System.err.println("无效索引");
  27.         return -1;
  28.     }

将链表打印输出并返回有效节点个数

  1.     /**
  2.      * 打印双向链表
  3.      *
  4.      * @return 返回双向链表每个节点的值
  5.      */
  6.     public StringBuffer toPrint() {
  7.         StringBuffer sb = new StringBuffer();
  8.         if (size == 0) {
  9.             return sb.append("null");
  10.         }
  11.         Node node = head;
  12.         for (int i = 0; i < size; i++) {
  13.             sb.append(node.getVal());
  14.             sb.append("-->");
  15.             node = node.getNext();
  16.         }
  17.         sb.append("null");
  18.         return sb;
  19.     }
  20.  
  21.     /**
  22.      * 返回size的值
  23.      *
  24.      * @return 返回size
  25.      */
  26.     public int getSize() {
  27.         return size;
  28.     }

单链表源码

节点代码

  1. public class Node {
  2.     private Node next;
  3.     private int val;
  4.  
  5.     public Node() {
  6.     }
  7.  
  8.     public Node(int val) {
  9.         this.val = val;
  10.     }
  11.  
  12.     public Node getNext() {
  13.         return next;
  14.     }
  15.  
  16.     public void setNext(Node next) {
  17.         this.next = next;
  18.     }
  19.  
  20.     public int getVal() {
  21.         return val;
  22.     }
  23.  
  24.     public void setVal(int val) {
  25.         this.val = val;
  26.     }
  27. }

链表代码

  1.  
  2. public class LinkList {
  3.     private Node head;
  4.     private int size;
  5.  
  6.     public LinkList() {
  7.     }
  8.  
  9.     public LinkList(int val) {
  10.         Node node = new Node(val);
  11.         this.head = node;
  12.         this.size = 1;
  13.     }
  14.  
  15.     /**
  16.      * 向链表中添加节点（头插）
  17.      */
  18.     public void addNode(int val) {
  19.         if (head == null) {
  20.             head = new Node(val);
  21.         } else {
  22.             Node newNode = new Node();
  23.             newNode.setVal(val);
  24.             newNode.setNext(head);
  25.             head = newNode;
  26.         }
  27.         size++;
  28.     }
  29.  
  30.     /**
  31.      * 向链表的尾部插入节点
  32.      *
  33.      * @param val 插入节点的值
  34.      */
  35.     public void addNodeEnd(int val) {
  36.         if (this.head == null) {
  37.             head = new Node(val);
  38.         } else {
  39.             Node x = head;
  40.             for (int i = 0; i < size - 1; i++) {
  41.                 x = x.getNext();
  42.             }
  43.             x.setNext(new Node(val));
  44.         }
  45.         size++;
  46.     }
  47.  
  48.     /**
  49.      * 向链表中的目标位置插入节点
  50.      *
  51.      * @param index 目标位置
  52.      * @param val   插入节点值
  53.      */
  54.     public void addNodeIndex(int index, int val) {
  55.         if (index > size || index < 0) {
  56.             System.out.println("无效下标");
  57.             return;
  58.         } else if (index == 0) {
  59.             //当索引指向头节点时
  60.             addNode(val);
  61.         } else if (index == size) {
  62.             //当索引指向链表最后NULL时
  63.             addNodeEnd(val);
  64.         } else {
  65.             Node node = head;
  66.             Node x = new Node(val);
  67.             for (int i = 0; i < size - 1; i++) {
  68.                 if (i == index - 1) {
  69.                     x.setNext(node.getNext());
  70.                     node.setNext(x);
  71.                     size++;
  72.                     return;
  73.                 }
  74.                 node = node.getNext();
  75.             }
  76.         }
  77.     }
  78.  
  79.     /**
  80.      * 查询索引 index 所指向节点的值
  81.      *
  82.      * @param index 索引
  83.      * @return 返回查询节点的值
  84.      */
  85.     public int getIndexNode(int index) {
  86.         if (rangeCheck(index)) {
  87.             Node x = head;
  88.             for (int i = 0; i < index; i++) {
  89.                 x = x.getNext();
  90.             }
  91.             return x.getVal();
  92.         }
  93.         System.err.println("index illegal! get error");
  94.         return -1;
  95.     }
  96.  
  97.     /**
  98.      * 查询第一个值为val的节点的索引
  99.      *
  100.      * @param val 将要节点的值
  101.      * @return 返回节点的索引
  102.      */
  103.     public int getNodeIndex(int val) {
  104.         int index = 0;
  105.         for (Node node = head; node != null; node = node.getNext()) {
  106.             if (val == node.getVal()) {
  107.                 return index;
  108.             }
  109.             index++;
  110.         }
  111.         //链表中没有值为val的节点
  112.         return -1;
  113.     }
  114.  
  115.     /**
  116.      * 修改索引指向节点的值并返回原始先的值
  117.      *
  118.      * @param index 索引
  119.      * @param val   修改节点的值
  120.      * @return 返回节点原先的值
  121.      */
  122.     public int setIndexNode(int index, int val) {
  123.         if (rangeCheck(index)) {
  124.             int oldVal = getIndexNode(index);
  125.             Node node = head;
  126.             for (int i = 0; i < index; i++) {
  127.                 node = node.getNext();
  128.             }
  129.             node.setVal(val);
  130.             return oldVal;
  131.         }
  132.         System.err.println("index illegal! get error");
  133.         return -1;
  134.     }
  135.  
  136.     /**
  137.      * 删除第一次出现值为val的节点
  138.      *
  139.      * @param val 删除节点的值
  140.      */
  141.     public void deleteNodeVal(int val) {
  142.         if (contains((val))) {
  143.             while (head.getVal() == val) {
  144.                 if (head.getNext() != null) {
  145.                     Node node = head;
  146.                     head = head.getNext();
  147.                     node.setNext(null);
  148.                     size--;
  149.                     return;
  150.                 } else {
  151.                     head = null;
  152.                     size--;
  153.                     return;
  154.                 }
  155.             }
  156.             Node x = head;
  157.             while (x.getNext() != null) {
  158.                 if (x.getNext().getVal() == val) {
  159.                     Node node = x.getNext();
  160.                     x.setNext(x.getNext().getNext());
  161.                     node.setNext(null);
  162.                     size--;
  163.                     return;
  164.                 } else {
  165.                     x = x.getNext();
  166.                 }
  167.             }
  168.         }
  169.         System.out.println("没有值为" + val + "的节点");
  170.     }
  171.  
  172.     /**
  173.      * 删除索引指向的节点并返回节点原先的值
  174.      *
  175.      * @param index
  176.      * @return
  177.      */
  178.     public int deleteNodeReVal(int index) {
  179.         if (rangeCheck(index)) {
  180.             int olaVal = getIndexNode(index);
  181.             if (index == 0) {
  182.                 Node x = head;
  183.                 head = head.getNext();
  184.                 x.setNext(null);
  185.                 size--;
  186.                 return olaVal;
  187.             }
  188.             Node x = head;
  189.             for(int i = 0; i < index - 1; i ++){
  190.                 x = x.getNext();
  191.             }
  192.             Node node = x.getNext();
  193.             x.setNext(x.getNext().getNext());
  194.             node.setNext(null);
  195.             size --;
  196.             return olaVal;
  197.         }
  198.         System.err.println("index illegal! get error");
  199.         return -1;
  200.     }
  201.  
  202.     /**
  203.      * 删除头节点
  204.      */
  205.     public void deleteFirstNode(){
  206.         deleteNodeReVal(0);
  207.     }
  208.  
  209.     /**
  210.      * 删除尾节点
  211.      */
  212.     public void deleteEndNode(){
  213.         deleteNodeReVal(size - 1);
  214.     }
  215.  
  216.     /**
  217.      *删除所有值为val的节点
  218.      * @param val 节点包含的值
  219.      */
  220.     public void deleteSameNodeVal(int val){
  221.         if(contains(val)){
  222.             while(head.getVal() == val){
  223.                 if(head.getNext() != null){
  224.                     Node node = head;
  225.                     head = head.getNext();
  226.                     node.setNext(null);
  227.                     size--;
  228.                 }else{
  229.                     head = null;
  230.                     size--;
  231.                     return;
  232.                 }
  233.             }
  234.             Node x = head;
  235.             while(x.getNext() != null){
  236.                 if(x.getNext().getVal() == val){
  237.                     Node node = x.getNext();
  238.                     x.setNext(x.getNext().getNext());
  239.                     node.setNext(null);
  240.                     size --;
  241.                 }else{
  242.                     x = x.getNext();
  243.                 }
  244.             }
  245.         }
  246.     }
  247.  
  248.  
  249.     /**
  250.      * 判断索引的合法性，是否为负数，是否小于size
  251.      *
  252.      * @param index 索引
  253.      * @return 为负数或者不小于size返回false，在区间内返回true
  254.      */
  255.     private boolean rangeCheck(int index) {
  256.         if (index < 0 || index >= size) {
  257.             return false;
  258.         }
  259.         return true;
  260.     }
  261.  
  262.     /**
  263.      * 判断链表中是否有包含值为val的节点
  264.      * @param val 节点的值
  265.      * @return 有值为val的节点返回true，没有返回false
  266.      */
  267.     public boolean contains(int val) {
  268.         return getNodeIndex(val) != -1;
  269.     }
  270.  
  271.     /**
  272.      * 打印输出链表
  273.      *
  274.      * @return 返回链表的每个节点的值
  275.      */
  276.     public String toPrint() {
  277.         String s = "";
  278.         if (size == 0) {
  279.             s += null;
  280.             return s;
  281.         } else {
  282.             Node node = head;
  283.             for (int i = 0; i < size; i++) {
  284.                 s += node.getVal();
  285.                 if (node.getNext() != null) {
  286.                     s += "-->";
  287.                 }
  288.                 node = node.getNext();
  289.             }
  290.             s += "-->null";
  291.         }
  292.         return s;
  293.     }
  294.  
  295.     /**
  296.      * 返回链表长度
  297.      *
  298.      * @return 返回size的值
  299.      */
  300.     public int getSize() {
  301.         return size;
  302.     }
  303. }

测试代码

  1.  
  2. public class Test {
  3.     public static void main(String[] args) {
  4.         LinkList linkList = new LinkList();
  5.         System.out.println("===============头插法==============");
  6.         linkList.addNode(10);
  7.         linkList.addNode(20);
  8.         System.out.println(linkList.toPrint());
  9.         System.out.println("===============尾插法==============");
  10.         linkList.addNodeEnd(1);
  11.         System.out.println(linkList.toPrint());
  12.         System.out.println("==============指定下标插入==============");
  13.         linkList.addNodeIndex(0,30);
  14.         System.out.println(linkList.toPrint());
  15.         linkList.addNodeIndex(4,2);
  16.         System.out.println(linkList.toPrint());
  17.         linkList.addNodeIndex(2,15);
  18.         System.out.println(linkList.toPrint());
  19.         linkList.addNodeIndex(5,1);
  20.         System.out.println(linkList.toPrint());
  21.         System.out.println("==============查询指定索引的节点===================");
  22.         System.out.println(linkList.getIndexNode(1));
  23.         System.out.println("==============查询值为val的第一个的节点的索引===================");
  24.         System.out.println(linkList.getNodeIndex(15));
  25.         System.out.println("=========判断链表中是否有值为val的节点==============");
  26.         System.out.println(linkList.contains(11));
  27.         System.out.println(linkList.contains(1));
  28.         System.out.println("==============修改指定节点的值并返回原先的值===================");
  29.         System.out.println("原先的值为" + linkList.setIndexNode(4,3) + "现在的值为" + linkList.getIndexNode(4));
  30.         System.out.println("==========添加节点=============================");
  31.         linkList.addNodeIndex(1,30);
  32.         linkList.addNodeIndex(3,30);
  33.         linkList.addNodeIndex(5,30);
  34.         System.out.println("=============删除值为val的第一个节点========================");
  35.         System.out.println(linkList.toPrint());
  36.         linkList.deleteNodeVal(30);
  37.         System.out.println(linkList.toPrint());
  38.         linkList.deleteNodeVal(10);
  39.         System.out.println(linkList.toPrint());
  40.         linkList.deleteNodeVal(2);
  41.         System.out.println(linkList.toPrint());
  42.         System.out.println("============删除所有值为val的节点===========================");
  43.         linkList.deleteSameNodeVal(30);
  44.         System.out.println(linkList.toPrint());
  45.         System.out.println("=================添加节点====================");
  46.         linkList.addNode(30);
  47.         linkList.addNodeIndex(2,10);
  48.         linkList.addNodeIndex(5,2);
  49.         linkList.addNode(40);
  50.         System.out.println(linkList.toPrint());
  51.         System.out.println("===========根据索引删除节点并返回原先的值==========");
  52.         System.out.println("原先的值为" + linkList.deleteNodeReVal(0));
  53.         System.out.println(linkList.toPrint());
  54.         System.out.println("原先的值为" + linkList.deleteNodeReVal(2));
  55.         System.out.println(linkList.toPrint());
  56.         System.out.println("原先的值为" + linkList.deleteNodeReVal(5));
  57.         System.out.println(linkList.toPrint());
  58.         System.out.println("=========添加节点==============================");
  59.         linkList.addNodeIndex(3,5);
  60.         linkList.addNode(40);
  61.         linkList.addNode(50);
  62.         linkList.addNodeEnd(0);
  63.         System.out.println(linkList.toPrint());
  64.         System.out.println("======删除头节点========");
  65.         linkList.deleteFirstNode();
  66.         System.out.println(linkList.toPrint());
  67.         System.out.println("=====删除尾节点====================");
  68.         linkList.deleteEndNode();
  69.         System.out.println(linkList.toPrint());
  70.         System.out.println("=========添加节点========");
  71.         linkList.addNodeEnd(1);
  72.         System.out.println(linkList.toPrint());
  73.         System.out.println("==============链表所有节点值都一样删除所有节点=====================");
  74.         //链表所有节点值都一样删除所有节点
  75.         LinkList linkList1 = new LinkList();
  76.         linkList1.addNode(10);
  77.         linkList1.addNode(10);
  78.         linkList1.addNode(10);
  79.         linkList1.addNode(10);
  80.         linkList1.addNode(10);
  81.         System.out.println(linkList1.toPrint());
  82.         linkList1.deleteSameNodeVal(10);
  83.         System.out.println(linkList1.toPrint());
  84.  
  85.     }
  86. }

双向链表源码

节点代码

  1.  
  2. public class Node {
  3.     private Node prev;
  4.     private int val;
  5.     private Node next;
  6.  
  7.     public Node() {
  8.     }
  9.  
  10.     public Node(int val) {
  11.         this.val = val;
  12.     }
  13.  
  14.     public Node(Node prev, int val, Node next) {
  15.         this.prev = prev;
  16.         this.val = val;
  17.         this.next = next;
  18.     }
  19.  
  20.     public Node getPrev() {
  21.         return prev;
  22.     }
  23.  
  24.     public void setPrev(Node prev) {
  25.         this.prev = prev;
  26.     }
  27.  
  28.     public int getVal() {
  29.         return val;
  30.     }
  31.  
  32.     public void setVal(int val) {
  33.         this.val = val;
  34.     }
  35.  
  36.     public Node getNext() {
  37.         return next;
  38.     }
  39.  
  40.     public void setNext(Node next) {
  41.         this.next = next;
  42.     }
  43. }

链表代码

  1.  
  2. public class DoubleLinkList {
  3.     private Node head;
  4.     private Node tail;
  5.     private int size;
  6.  
  7.     /**
  8.      * 头插法
  9.      *
  10.      * @param val 插入节点的值
  11.      */
  12.  
  13.     public void addHead(int val) {
  14.         Node node = new Node(null, val, head);
  15.         if (tail != null) {
  16.             head.setPrev(node);
  17.         } else {
  18.             tail = node;
  19.         }
  20.         head = node;
  21.         size++;
  22.     }
  23.  
  24.     /**
  25.      * 尾插法
  26.      *
  27.      * @param val 插入节点的值
  28.      */
  29.     public void addEnd(int val) {
  30.         Node node = new Node(tail, val, null);
  31.         if (tail == null) {
  32.             addHead(val);
  33.         } else {
  34.             tail.setNext(node);
  35.             tail = node;
  36.             size++;
  37.         }
  38.     }
  39.  
  40.     /**
  41.      * 根据索引插入节点
  42.      *
  43.      * @param index 索引
  44.      * @param val   节点值
  45.      */
  46.     public void addAnyIndex(int index, int val) {
  47.         if (index == 0) {
  48.             addHead(val);
  49.             return;
  50.         } else if (index == size) {
  51.             addEnd(val);
  52.             return;
  53.         }
  54.         Node node = new Node(val);
  55.         if (headOrEnd(index) == 1) {
  56.             //头部插入
  57.             Node h = head;
  58.             for (int i = 0; i < index; i++) {
  59.                 h = h.getNext();
  60.             }
  61.             Node a = h.getPrev();
  62.             node.setPrev(a);
  63.             a.setNext(node);
  64.             node.setNext(h);
  65.             h.setPrev(node);
  66.         } else if (headOrEnd(index) == 0) {
  67.             //尾部插入
  68.             Node t = tail;
  69.             for (int i = 0; i < size - index; i++) {
  70.                 t = t.getPrev();
  71.             }
  72.             Node a = t.getNext();
  73.             node.setNext(a);
  74.             a.setPrev(node);
  75.             node.setPrev(t);
  76.             t.setNext(node);
  77.         } else {
  78.             System.out.println("索引不合法");
  79.             return;
  80.         }
  81.         size++;
  82.     }
  83.  
  84.     /**
  85.      * 判断索引的合法性
  86.      *
  87.      * @param index 索引
  88.      * @return 返回false 索引不合法，返回true 索引合法
  89.      */
  90.     private Boolean checkIndex(int index) {
  91.         if (index < 0 || index >= size) {
  92.             return false;
  93.         } else {
  94.             return true;
  95.         }
  96.     }
  97.  
  98.     /**
  99.      * 判断索引的节点是从头插入还是从尾插入
  100.      *
  101.      * @param index 索引
  102.      * @return 返回 1 则从头插入，返回 0则从尾部插入，返回-1是无效下标
  103.      */
  104.     private int headOrEnd(int index) {
  105.         if (checkIndex(index)) {
  106.             if (index < size / 2) {
  107.                 return 1;
  108.             } else {
  109.                 return 0;
  110.             }
  111.         }
  112.         return -1;
  113.     }
  114.  
  115.     /**
  116.      * 根据值从头结点开始查询第一个值为val的节点返回节点索引
  117.      *
  118.      * @param val 查询节点值
  119.      * @return 查询到的节点索引
  120.      */
  121.     public int getValHeadNodeIndex(int val) {
  122.         Node node = head;
  123.         int index = 0;
  124.         while (node != null) {
  125.             if (node.getVal() == val) {
  126.                 return index;
  127.             }
  128.             index++;
  129.             node = node.getNext();
  130.         }
  131.         //查找不到值为val的节点返回-1
  132.         return -1;
  133.     }
  134.  
  135.     /**
  136.      * 根据值从尾结点开始查询第一个值为val的节点返回节点索引
  137.      *
  138.      * @param val 查询节点值
  139.      * @return 查询到的节点索引
  140.      */
  141.     public int getValEndNodeIndex(int val) {
  142.         Node node = tail;
  143.         int index = 0;
  144.         while (node != null) {
  145.             if (node.getVal() == val) {
  146.                 return size - 1 - index;
  147.             }
  148.             index++;
  149.             node = node.getPrev();
  150.         }
  151.         //查找不到值为val的节点返回-1
  152.         return -1;
  153.     }
  154.  
  155.     /**
  156.      * 根据索引查询目标节点
  157.      *
  158.      * @param index 索引
  159.      * @return 返回目标节点的值, 返回-1表示无效索引
  160.      */
  161.     public int getIndexNodeVal(int index) {
  162.         int count = 0;
  163.         if (headOrEnd(index) == 1) {
  164.             //从头结点开始查询
  165.             Node node = head;
  166.             while (count < index) {
  167.                 node = node.getNext();
  168.                 count++;
  169.             }
  170.             return node.getVal();
  171.         }
  172.         if (headOrEnd(index) == 0) {
  173.             //从尾节点开始查询
  174.             Node node = tail;
  175.             while (count < size - 1 - index) {
  176.                 node = node.getPrev();
  177.                 count++;
  178.             }
  179.             return node.getVal();
  180.         }
  181.         System.err.println("无效索引");
  182.         return -1;
  183.     }
  184.  
  185.     /**
  186.      * 查询头结点的值
  187.      *
  188.      * @return 返回头节点点的值
  189.      */
  190.     public int getHead() {
  191.         return getIndexNodeVal(0);
  192.     }
  193.  
  194.     /**
  195.      * 查询尾节点的值
  196.      *
  197.      * @return 返回尾节点的值
  198.      */
  199.     public int getTail() {
  200.         return getIndexNodeVal(size - 1);
  201.     }
  202.  
  203.     /**
  204.      * 从头开始删除第一个值为val的节点
  205.      *
  206.      * @param val 删除节点的值
  207.      */
  208.     public void deleteHeadFirstVal(int val) {
  209.         int index = getValHeadNodeIndex(val);
  210.         deleteIndex(index);
  211.     }
  212.  
  213.     /**
  214.      * 从尾开始删除第一个值为val的节点
  215.      * @param val 删除节点的值
  216.      */
  217.     public void deleteTailFirstVal(int val) {
  218.         int index = getValEndNodeIndex(val);
  219.         deleteIndex(index);
  220.     }
  221.  
  222.     /**
  223.      * 删除头结点，并返回头结点的值
  224.      *
  225.      * @return 返回删除头结点的值
  226.      */
  227.     public int deleteHead() {
  228.         return deleteIndex(0);
  229.     }
  230.  
  231.     /**
  232.      * 删除尾结点，并返回尾结点的值
  233.      *
  234.      * @return 返回被删除尾结点的值
  235.      */
  236.     public int deleteTail() {
  237.         return deleteIndex(size - 1);
  238.     }
  239.  
  240.     /**
  241.      * 删除索引指向的节点，并返回该节点的值
  242.      *
  243.      * @param index 索引
  244.      * @return 删除节点的值
  245.      */
  246.     public int deleteIndex(int index) {
  247.         int val = 0;
  248.         if (checkIndex(index)) {
  249.             if (index == size - 1) {
  250.                 //链表只有一个节点时;
  251.                 if (size == 1) {
  252.                     val = head.getVal();
  253.                     head = tail = null;
  254.                     size--;
  255.                     return val;
  256.                 }
  257.                 //不止一个节点
  258.                 val = tail.getVal();
  259.                 Node x = tail.getPrev();
  260.                 tail.setPrev(null);
  261.                 x.setNext(null);
  262.                 tail = x;
  263.             } else if (index == 0) {
  264.                 val = head.getVal();
  265.                 Node x = head.getNext();
  266.                 x.setPrev(null);
  267.                 head.setNext(null);
  268.                 head = x;
  269.             } else {
  270.                 Node node = head;
  271.                 for (int i = 0; i < index; i++) {
  272.                     node = node.getNext();
  273.                 }
  274.                 val = node.getVal();
  275.                 Node x = node.getPrev();
  276.                 Node n = node.getNext();
  277.                 x.setNext(n);
  278.                 n.setPrev(x);
  279.             }
  280.             size--;
  281.             return val;
  282.         }
  283.         //索引不合法返回-1
  284.         return -1;
  285.     }
  286.  
  287.     /**
  288.      * 删除所有值为val的节点
  289.      *
  290.      * @param val 节点值
  291.      */
  292.     public void deleteSameVal(int val) {
  293.         if (getValHeadNodeIndex(val) != -1) {
  294.             while (head.getVal() == val) {
  295.                 if (head.getNext() != null) {
  296.                     Node x = head.getNext();
  297.                     head.setNext(null);
  298.                     x.setPrev(null);
  299.                     head = x;
  300.                     size--;
  301.                 } else {
  302.                     head = tail = null;
  303.                     size--;
  304.                     return;
  305.                 }
  306.             }
  307.             Node node = head;
  308.             while (node.getNext() != null) {
  309.                 if (node.getVal() == val) {
  310.                     Node x = node.getNext();
  311.                     Node h = node.getPrev();
  312.                     x.setPrev(h);
  313.                     h.setNext(x);
  314.                     node.setNext(null);
  315.                     node.setPrev(null);
  316.                     node = x;
  317.                     size--;
  318.                 } else {
  319.                     node = node.getNext();
  320.                 }
  321.             }
  322.             if (node.getVal() == val) {
  323.                 node.getPrev().setNext(null);
  324.                 tail = node.getPrev();
  325.                 node.setPrev(null);
  326.                 size--;
  327.             }
  328.             return;
  329.         }
  330.         System.out.println("链表中没有此节点");
  331.     }
  332.  
  333.     /**
  334.      * 根据索引修改该节点，并返回修改前的值
  335.      *
  336.      * @param index 索引
  337.      * @param val   修改的值
  338.      * @return 返回修改前的值
  339.      */
  340.     public int setIndexVal(int index, int val) {
  341.         if (headOrEnd(index) == 1) {
  342.             Node node = head;
  343.             for (int i = 0; i < index; i++) {
  344.                 node = node.getNext();
  345.             }
  346.             int reVal = node.getVal();
  347.             node.setVal(val);
  348.             return reVal;
  349.         } else if (headOrEnd(index) == 0) {
  350.             Node node = tail;
  351.             for (int i = 0; i < size - 1 - index; i++) {
  352.                 node = node.getPrev();
  353.             }
  354.             int reVal = node.getVal();
  355.             node.setVal(val);
  356.             return reVal;
  357.         }
  358.         System.err.println("无效索引");
  359.         return -1;
  360.     }
  361.  
  362.     /**
  363.      * 打印双向链表
  364.      *
  365.      * @return 返回双向链表每个节点的值
  366.      */
  367.     public StringBuffer toPrint() {
  368.         StringBuffer sb = new StringBuffer();
  369.         if (size == 0) {
  370.             return sb.append("null");
  371.         }
  372.         Node node = head;
  373.         for (int i = 0; i < size; i++) {
  374.             sb.append(node.getVal());
  375.             sb.append("-->");
  376.             node = node.getNext();
  377.         }
  378.         sb.append("null");
  379.         return sb;
  380.     }
  381.  
  382.     /**
  383.      * 返回size的值
  384.      *
  385.      * @return 返回size
  386.      */
  387.     public int getSize() {
  388.         return size;
  389.     }
  390. }

测试代码

  1. public class Test {
  2.  
  3.     public static void main(String[] args) {
  4.         DoubleLinkList linkList = new DoubleLinkList();
  5.         System.out.println("========头插法======");
  6.         linkList.addHead(11);
  7.         linkList.addHead(20);
  8.         System.out.println(linkList.toPrint());
  9.         System.out.println("========尾插法======");
  10.         linkList.addEnd(10);
  11.         linkList.addEnd(20);
  12.         System.out.println(linkList.toPrint());
  13.         System.out.println("=====根据索引插入============");
  14.         linkList.addAnyIndex(0,30);
  15.         linkList.addAnyIndex(0,40);
  16.         linkList.addAnyIndex(0,50);
  17.         linkList.addAnyIndex(0,70);
  18.         linkList.addAnyIndex(2,55);
  19.         linkList.addAnyIndex(2,56);
  20.         linkList.addAnyIndex(4,51);
  21.         linkList.addAnyIndex(6,45);
  22.         linkList.addAnyIndex(10,15);
  23.         System.out.println(linkList.getSize());
  24.         System.out.println(linkList.toPrint());
  25.         linkList.addAnyIndex(-1,10);
  26.         linkList.addAnyIndex(3,55);
  27.         linkList.addAnyIndex(3,55);
  28.         System.out.println(linkList.getSize());
  29.         System.out.println(linkList.toPrint());
  30.         System.out.println("=========根据val从头节点查询第一个值为val的节点============");
  31.         System.out.println(linkList.getValHeadNodeIndex(55));
  32.         System.out.println("=========根据val从尾节点查询第一个值为val的节点============");
  33.         System.out.println(linkList.getValEndNodeIndex(55));
  34.         System.out.println("=========根据索引查询目标节点的值==================");
  35.         System.out.println(linkList.toPrint());
  36.         System.out.println(linkList.getIndexNodeVal(0));
  37.         System.out.println(linkList.getIndexNodeVal(-1));
  38.         System.out.println("=======查询头节点的值=======");
  39.         System.out.println(linkList.getHead());
  40.         System.out.println("=======查询尾节点的值=======");
  41.         System.out.println(linkList.getTail());
  42.         System.out.println("========从头结点开始删除值为val的第一个节点");
  43.         System.out.println(linkList.toPrint());
  44.         linkList.deleteHeadFirstVal(70);
  45.         System.out.println(linkList.toPrint());
  46.         linkList.deleteHeadFirstVal(55);
  47.         linkList.deleteHeadFirstVal(20);
  48.         linkList.deleteHeadFirstVal(20);
  49.         System.out.println(linkList.toPrint());
  50.         System.out.println("======添加节点====");
  51.         linkList.addAnyIndex(8,55);
  52.         System.out.println(linkList.toPrint());
  53.         System.out.println("========从尾节点开始删除值为val的第一个节点");
  54.         linkList.deleteTailFirstVal(55);
  55.         System.out.println(linkList.toPrint());
  56.         System.out.println("=====删除索引指向的节点返回删除前该节点的值=======");
  57.         System.out.println(linkList.deleteIndex(1));
  58.         System.out.println(linkList.deleteIndex(0));
  59.         System.out.println(linkList.deleteIndex(8));
  60.         System.out.println(linkList.toPrint());
  61.  
  62.         System.out.println("======删除头节点=====");
  63.         System.out.println(linkList.deleteHead());
  64.         System.out.println(linkList.toPrint());
  65.         System.out.println("======删除尾节点=====");
  66.         System.out.println(linkList.deleteTail());
  67.         System.out.println(linkList.toPrint());
  68.         System.out.println("============添加节点================");
  69.         linkList.addAnyIndex(5,55);
  70.         linkList.addAnyIndex(2,55);
  71.         linkList.addAnyIndex(4,55);
  72.         linkList.addAnyIndex(6,55);
  73.         linkList.addAnyIndex(3,55);
  74.         linkList.addAnyIndex(11,55);
  75.         System.out.println(linkList.toPrint());
  76.         System.out.println("=====删除所有值为val的节点==========");
  77.         linkList.deleteSameVal(55);
  78.         System.out.println(linkList.toPrint());
  79.         System.out.println("=====修改索引指向节点的值====");
  80.         System.out.println(linkList.setIndexVal(2,35));
  81.         System.out.println(linkList.toPrint());
  82.     }
  83. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/661714
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号