主要讲述几点：

一、链表的简介

二、链表实现原理和必要性

三、单链表示例

四、双链表示例

　

一、链表的简介　

　　链表是一种比较常用的数据结构，链表虽然保存比较复杂，但是在查询时候比较便捷，在多种计算机语言都相应的应用，链表有多种类别，文章针对单链表和双链表进行分析。链表中数据就像被一个链条串联一起，轻易的可以实现数据的访问。

二、链表实现原理和必要性

　　这里只分析单链表和双链表。链表的实现过程是有些许复杂的，但是会带来许多好处。比如现在网购时代到来，商家发快递一般会将商品包装在盒子里并写上地址信息，快递公司就可以通过盒子上的信息找到买家，商品完整到达。如果没有盒子的保护，有可能在途中商品受损。而链表就好比那个写了地址信息的盒子，既保护了商品信息，同时又写好了物流信息。链表之中存在一个HEAD节点，类似“火车头”，只要找到相应HEAD节点，就可以对链表进行操作。此次分析中，HEAD节点只是做数据头，不保存有效数据。

　　单链表的实现原理如图：

　　双链表实现原理：

三、单链表示例　　

ICommOperate<T> 接口操作类：

  1.  package LinkListTest;
  2.  import java.util.Map;
  3.  public interface ICommOperate<T> {
  4.  
  5.      public boolean insertNode(T node) ;
  6.      public boolean insertPosNode(int pos, T node) ;
  7.      public boolean deleteNode(int pos) ;
  8.      public boolean updateNode(int pos, Map<String, Object> map) ;
  9.      public T getNode(int pos, Map<String, Object> map) ;
  10.      public void printLink() ;
  11.  }

单链表节点：

  1.  package LinkListTest;
  2.  // 单连表节点
  3.  public class SNode {
  4.      private String data;
  5.      private SNode  nextNode;
  6.      public SNode() {
  7.      }
  8.      public SNode(String data) {
  9.          this.data = data;
  10.          this.nextNode = new SNode();
  11.      }
  12.  
  13.      public String getData() {
  14.          return data;
  15.      }
  16.      public void setData(String data) {
  17.          this.data = data;
  18.      }
  19.      public SNode getNextNode() {
  20.          return nextNode;
  21.      }
  22.      public void setNextNode(SNode nextNode) {
  23.          this.nextNode = nextNode;
  24.      }
  25.      @Override
  26.      public String toString() {
  27.          return "SNode [data=" + data + "]";
  28.      }
  29.  }

单链接操作类：

  1.  package LinkListTest;
  2.  import java.util.HashMap;
  3.  import java.util.Map;
  4.  public class SingleLinkList implements ICommOperate<SNode>{
  5.      private SNode head = new SNode("HEAD") ; // 公共头指针，声明之后不变
  6.      private int size = 0 ;
  7.      public int getSize() {
  8.          return this.size;
  9.      }
  10.  
  11.      /*
  12.       * 链表插入，每次往末端插入
  13.       * */
  14.      @Override
  15.      public boolean insertNode(SNode node) {
  16.          boolean flag = false ;
  17.          SNode current = this.head ;
  18.          if( this.size==0 ){  // 空链表
  19.              this.head.setNextNode(node) ;
  20.              node.setNextNode(null) ;
  21.          }else{                // 链表内节点
  22.              while( current.getNextNode()!=null ){
  23.                  current = current.getNextNode() ;
  24.              }
  25.              current.setNextNode(node) ;
  26.              node.setNextNode(null) ;
  27.          }
  28.          this.size++ ;
  29.          flag = true ;
  30.  
  31.          return flag;
  32.      }
  33.  
  34.      /*
  35.       * 插入链表指定位置pos，从1开始,而pos大于size则插入链表末端
  36.       * */
  37.      @Override
  38.      public boolean insertPosNode(int pos, SNode node){
  39.          boolean flag = true;
  40.          SNode current = this.head.getNextNode() ;
  41.  
  42.          if( this.size==0 ){                   // 空链表
  43.              this.head.setNextNode(node) ;
  44.              node.setNextNode(null) ;
  45.              this.size++ ;
  46.          }else if( this.size<pos ){           // pos位置大于链表长度，插入末端
  47.              insertNode(node) ;
  48.          }else if( pos>0 && pos<=this.size) { // 链表内节点
  49.              // 1、找到要插入pos位置节点和前节点
  50.              int find = 0;
  51.              SNode preNode = this.head; // 前节点
  52.              SNode currentNode = current; // 当前节点
  53.              while( find<pos-1 && currentNode.getNextNode()!=null ){
  54.                  preNode = current ;                    // 前节点后移
  55.                  currentNode = currentNode.getNextNode() ; // 当前节点后移
  56.                  find++ ;
  57.              }
  58.  //            System.out.println(preNode);
  59.  //            System.out.println(currentNode);
  60.              // 2、插入节点
  61.              preNode.setNextNode(node);
  62.              node.setNextNode(currentNode);
  63.              this.size++ ;
  64.              System.out.println("节点已经插入链表中");
  65.          }else{
  66.              System.out.println("位置信息错误");
  67.              flag = false ;
  68.          }
  69.  
  70.          return flag;
  71.      }
  72.  
  73.      /*
  74.       * 指定链表的节点pos，删除对应节点。方式：找到要删除节点的前后节点，进行删除。从1开始
  75.       * */
  76.      @Override
  77.      public boolean deleteNode(int pos) {
  78.          boolean flag = false;
  79.          SNode current = this.head.getNextNode() ;
  80.          if( pos<=0 || pos>this.size || current==null ){
  81.              System.out.println("位置信息错误或链表无信息");
  82.          }else{
  83.              // 1、找到要删除节点的前后节点
  84.              int find = 0;
  85.              SNode preNode = this.head; // 前节点
  86.              SNode nextNode = current.getNextNode(); // 后节点
  87.              while( find<pos-1 && nextNode.getNextNode()!=null ){
  88.                  preNode = current ;                    // 前节点后移
  89.                  nextNode = nextNode.getNextNode() ; // 后节点后移
  90.                  find++ ;
  91.              }
  92.  //            System.out.println(preNode);
  93.  //            System.out.println(nextNode);
  94.  
  95.              // 2、删除节点
  96.              preNode.setNextNode(nextNode);
  97.              System.gc();
  98.              this.size-- ;
  99.              flag = true ;
  100.          }
  101.  
  102.          return flag;
  103.      }
  104.  
  105.      /*
  106.       * 指定链表的节点pos，修改对应节点。 从1开始
  107.       * */
  108.      @Override
  109.      public boolean updateNode(int pos, Map<String, Object> map) {
  110.          boolean flag = false ;
  111.          SNode node = getNode(pos, map); // 获得相应位置pos的节点
  112.          if( node!=null ){
  113.              String data = (String) map.get("data") ;
  114.              node.setData(data);
  115.              flag = true ;
  116.          }
  117.          return flag;
  118.      }
  119.  
  120.      /*
  121.       * 找到指定链表的节点pos，从1开始
  122.       * */
  123.      @Override
  124.      public SNode getNode(int pos, Map<String, Object> map) {
  125.          SNode current = this.head.getNextNode() ;
  126.          if( pos<=0 || pos>this.size || current==null ){
  127.              System.out.println("位置信息错误或链表不存在");
  128.              return null;
  129.          }
  130.          int find = 0 ;
  131.          while( find<pos-1 && current!=null  ){
  132.              current = current.getNextNode() ;
  133.              find++ ;
  134.          }
  135.          return current;
  136.      }
  137.  
  138.      /*
  139.       * 打印链表
  140.       * */
  141.      @Override
  142.      public void printLink() {
  143.          int length = this.size ;
  144.          if( length==0 ){
  145.              System.out.println("链表为空！");
  146.              return ;
  147.          }
  148.          SNode current = this.head.getNextNode() ;
  149.          int find = 0 ;
  150.          System.out.println("总共有节点数: " + length +" 个");
  151.          while( current!=null ){
  152.              System.out.println("第 " + (++find) + " 个节点 ：" + current);
  153.              current=current.getNextNode() ;
  154.          }
  155.      }
  156.  
  157.      public static void main(String[] args) {
  158.          SingleLinkList sll = new SingleLinkList() ;
  159.          SNode node1 = new SNode("节点1");
  160.          SNode node2 = new SNode("节点2");
  161.          SNode node3 = new SNode("节点3");
  162.          SNode node4 = new SNode("节点4");
  163.          SNode node5 = new SNode("节点5");
  164.          SNode node6 = new SNode("插入指定位置");
  165.          sll.insertPosNode(sll.getSize()+1, node1) ;
  166.          sll.insertPosNode(sll.getSize()+1, node2) ;
  167.          sll.insertPosNode(sll.getSize()+1, node3) ;
  168.          sll.insertPosNode(sll.getSize()+1, node4) ;
  169.          sll.insertPosNode(sll.getSize()+1, node5) ;
  170.  
  171.  //        sll.insertNode(node1);
  172.  //        sll.insertNode(node2);
  173.  //        sll.insertNode(node3);
  174.  //        sll.insertNode(node4);
  175.  //        sll.insertNode(node5);
  176.  
  177.          System.out.println("*******************输出链表*******************");
  178.          sll.printLink();
  179.  
  180.          System.out.println("*******************获得指定链表节点*******************");
  181.          int pos = 2 ;
  182.          System.out.println("获取链表第  "+pos+" 个位置数据 ："+sll.getNode(pos, null));
  183.  
  184.          System.out.println("*******************向链表指定位置插入节点*******************");
  185.          int pos1 = 2 ;
  186.          System.out.println("将数据插入第 "+pos1+" 个节点：");
  187.          sll.insertPosNode(pos1, node6) ;
  188.          sll.printLink();
  189.  
  190.          System.out.println("*******************删除链表指定位置节点*******************");
  191.          int pos2 = 2 ;
  192.          System.out.println("删除第 "+pos2+" 个节点：");
  193.          sll.deleteNode(pos2) ;
  194.          sll.printLink();
  195.  
  196.          System.out.println("*******************修改链表指定位置节点*******************");
  197.          int pos3 = 2 ;
  198.          System.out.println("修改第 "+pos3+" 个节点：");
  199.          Map<String, Object> map = new HashMap<>() ;
  200.          map.put("data", "this is a test") ;
  201.          sll.updateNode(pos3, map) ;
  202.          sll.printLink();
  203.      }
  204.  }

四、双链表示例

ICommOperate<T> 接口操作类：

  1.  package LinkListTest;
  2.  import java.util.Map;
  3.  public interface ICommOperate<T> {
  4.      public boolean insertNode(T node) ;
  5.      public boolean insertPosNode(int pos, T node) ;
  6.      public boolean deleteNode(int pos) ;
  7.      public boolean updateNode(int pos, Map<String, Object> map) ;
  8.      public T getNode(int pos, Map<String, Object> map) ;
  9.      public void printLink() ;
  10.  }

双链表节点：

  1.  package LinkListTest;
  2.  // 双连表节点
  3.  public class DNode {
  4.      private DNode  priorNode;
  5.      private String data;
  6.      private DNode  nextNode;
  7.  
  8.      public DNode(){
  9.      }
  10.      public DNode(String data) {
  11.          this.priorNode = new DNode() ;
  12.          this.data = data ;
  13.          this.nextNode = new DNode() ;
  14.      }
  15.  
  16.      public DNode getPriorNode() {
  17.          return priorNode;
  18.      }
  19.      public void setPriorNode(DNode priorNode) {
  20.          this.priorNode = priorNode;
  21.      }
  22.  
  23.      public String getData() {
  24.          return data;
  25.      }
  26.      public void setData(String data) {
  27.          this.data = data;
  28.      }
  29.  
  30.      public DNode getNextNode() {
  31.          return nextNode;
  32.      }
  33.      public void setNextNode(DNode nextNode) {
  34.          this.nextNode = nextNode;
  35.      }
  36.  
  37.      @Override
  38.      public String toString() {
  39.          return "DNode [data=" + data + "]";
  40.      }
  41.  }

双链表实现类：

  1.  package LinkListTest;
  2.  import java.util.HashMap;
  3.  import java.util.Map;
  4.  public class DoubleLinkList implements ICommOperate<DNode>{
  5.      private DNode head = new DNode("HEAD");
  6.      private int size = 0 ;
  7.      public int getSize() {
  8.          return this.size;
  9.      }
  10.  
  11.      /*
  12.       * 链表插入，每次往末端插入
  13.       * */
  14.      @Override
  15.      public boolean insertNode(DNode node) {
  16.          boolean flag = false; 
  17.  
  18.          DNode current = this.head ;
  19.          if( this.size==0 ){  // 空链表
  20.              this.head.setNextNode(node) ;
  21.              node.setPriorNode(this.head);
  22.              node.setNextNode(null) ;
  23.          }else{                // 链表内节点
  24.              while( current.getNextNode()!=null ){
  25.                  current = current.getNextNode() ;
  26.              }
  27.              current.setNextNode(node);
  28.              node.setNextNode(null);
  29.              node.setPriorNode(current);
  30.          }
  31.          this.size++ ;
  32.          flag = true ;
  33.  
  34.          return flag;
  35.      }
  36.  
  37.      /*
  38.       * 插入链表指定位置pos，从1开始,而pos大于size则插入链表末端
  39.       * */
  40.      @Override
  41.      public boolean insertPosNode(int pos, DNode node) {
  42.          boolean flag = true;
  43.  
  44.          DNode current = this.head.getNextNode() ;
  45.          if( this.size==0){                         // 链表为空
  46.              this.head.setNextNode(node) ;
  47.              node.setNextNode(null) ;
  48.              node.setPriorNode(this.head);
  49.              this.size++ ;
  50.          }else if( pos>this.size ){                 // pos位置大于链表长度，插入末端
  51.              insertNode(node) ;
  52.          }else if( pos>0 && pos<=this.size ){    // 链表内节点
  53.              // 1、找到要插入位置pos节点，插入pos节点当前位置
  54.              int find = 0;
  55.              while( find<pos-1 && current.getNextNode()!=null ){
  56.                  current = current.getNextNode() ;
  57.                  find++ ;
  58.              }
  59.              // 2、插入节点
  60.              if( current.getNextNode()==null ){ // 尾节点
  61.                  node.setPriorNode(current);
  62.                  node.setNextNode(null);
  63.                  current.setNextNode(node);
  64.              } else if( current.getNextNode()!=null ) {  //中间节点
  65.                  node.setPriorNode(current.getPriorNode());
  66.                  node.setNextNode(current);
  67.                  current.getPriorNode().setNextNode(node);
  68.                  current.setPriorNode(node);
  69.              }
  70.              this.size++ ;
  71.          }else{
  72.              System.out.println("位置信息错误");
  73.              flag = false ;
  74.          }
  75.  
  76.          return flag;
  77.      }
  78.  
  79.      /*
  80.       * 指定链表的节点pos，删除对应节点，从1开始
  81.       * */
  82.      @Override
  83.      public boolean deleteNode(int pos) {
  84.          boolean flag = false;
  85.          DNode current = this.head.getNextNode() ;
  86.          if( pos<=0 || pos>this.size || current==null ){
  87.              System.out.println("位置信息错误或链表不存在");
  88.          }else{
  89.              // 1、找到要删除位置pos节点
  90.              int find = 0;
  91.              while( find<pos-1 && current.getNextNode()!=null ){
  92.                  current = current.getNextNode() ;
  93.                  find++ ;
  94.              }
  95.              // 2、删除节点
  96.              if( current.getNextNode()==null ){ // 尾节点
  97.                  current.getPriorNode().setNextNode(null) ;
  98.              } else if( current.getNextNode()!=null ) {  //中间节点
  99.                  current.getPriorNode().setNextNode(current.getNextNode()) ;
  100.                  current.getNextNode().setPriorNode(current.getPriorNode()) ;
  101.              }
  102.              System.gc();
  103.              this.size-- ;
  104.              flag = true ;
  105.          }
  106.          return flag;
  107.      }
  108.  
  109.      /*
  110.       * 指定链表的节点pos，修改对应节点。 从1开始
  111.       * */
  112.      @Override
  113.      public boolean updateNode(int pos, Map<String, Object> map) {
  114.          boolean flag = false ;
  115.          DNode node = getNode(pos, map);
  116.          if( node!=null ){
  117.              String data = (String) map.get("data") ;
  118.              node.setData(data);
  119.              flag = true ;
  120.          }
  121.          return flag;
  122.      }
  123.  
  124.      /*
  125.       * 找到指定链表的节点pos，从1开始
  126.       * */
  127.      @Override
  128.      public DNode getNode(int pos, Map<String, Object> map) {
  129.          DNode current = this.head.getNextNode() ;
  130.          if( pos<=0 || pos>this.size || current==null ){
  131.              System.out.println("位置信息错误或链表不存在");
  132.              return null;
  133.          }
  134.          int find = 0 ;
  135.          while( find<pos-1 && current!=null  ){
  136.              current = current.getNextNode() ;
  137.              find++ ;
  138.          }
  139.          return current;
  140.      }
  141.  
  142.      /*
  143.       * 打印链表
  144.       * */
  145.      @Override
  146.      public void printLink() {
  147.          int length = this.size ;
  148.          if( length==0 ){
  149.              System.out.println("链表为空！");
  150.              return ;
  151.          }
  152.          DNode current = this.head.getNextNode() ;
  153.          int find = 0 ;
  154.          System.out.println("总共有节点数: " + length +" 个");
  155.          while( current!=null ){
  156.              System.out.println("第  " + (++find) + " 个节点 ：" + current);
  157.              current=current.getNextNode() ;
  158.          }
  159.      }
  160.  
  161.      public static void main(String[] args) {
  162.          DoubleLinkList dll = new DoubleLinkList() ;
  163.          DNode node1 = new DNode("节点1");
  164.          DNode node2 = new DNode("节点2");
  165.          DNode node3 = new DNode("节点3");
  166.          DNode node4 = new DNode("节点4");
  167.          DNode node5 = new DNode("节点5");
  168.          DNode node6 = new DNode("插入指定位置");
  169.          dll.insertPosNode(10, node1) ;
  170.          dll.insertPosNode(10, node2) ;
  171.          dll.insertPosNode(10, node3) ;
  172.          dll.insertPosNode(10, node4) ;
  173.          dll.insertPosNode(10, node5) ;
  174.  //        dll.insertNode(node1);
  175.  //        dll.insertNode(node2);
  176.  //        dll.insertNode(node3);
  177.  //        dll.insertNode(node4);
  178.  //        dll.insertNode(node5);
  179.  
  180.          System.out.println("*******************输出链表*******************");
  181.          dll.printLink();
  182.  
  183.          System.out.println("*******************获得指定链表节点*******************");
  184.          int pos = 2 ;
  185.          System.out.println("获取链表第  "+pos+" 个位置数据 ："+dll.getNode(pos, null));
  186.  
  187.          System.out.println("*******************向链表指定位置插入节点*******************");
  188.          int pos1 = 2 ;
  189.          System.out.println("将数据插入第"+pos1+"个节点：");
  190.          dll.insertPosNode(pos1, node6) ;
  191.          dll.printLink();
  192.  
  193.          System.out.println("*******************删除链表指定位置节点*******************");
  194.          int pos2 = 7 ;
  195.          System.out.println("删除第"+pos2+"个节点：");
  196.          dll.deleteNode(pos2) ;
  197.          dll.printLink();
  198.  
  199.          System.out.println("*******************修改链表指定位置节点*******************");
  200.          int pos3 = 2 ;
  201.          System.out.println("修改第"+pos3+"个节点：");
  202.          Map<String, Object> map = new HashMap<>() ;
  203.          map.put("data", "this is a test") ;
  204.          dll.updateNode(pos3, map) ;
  205.          dll.printLink();
  206.      }
  207.  }

文章转载至：https://www.cnblogs.com/xiaoxing/p/5969133.html

Java链表讲解的更多相关文章

  1. java集合讲解

    java集合讲解 1.概述 集合类的顶级接口是Iterable,Collection继承了Iterable接口 常用的集合主要有 3 类,Set,List,Queue,他们都是接口,都继于Collec ...

  2. JAVA 链表操作：循环链表

    主要分析示例: 一.循环链表简述 二.单链表循环链表 三.双链表循环链表 一.循环链表简述 循环链表即链表形成了一个循环的结构,尾节点不再指向NULL,而是指向头节点HEAD,此时判定链表的结束是尾节 ...

  3. Java链表基本操作和Java.util.ArrayList

    Java链表基本操作和Java.util.ArrayList 今天做了一道<剑指offer>上的一道编程题“从尾到头打印链表”,具体要求如下:输入一个链表,按链表值从尾到头的顺序返回一个A ...

  4. JAVA链表中迭代器的实现

    注:本文代码出自<java数据结构和算法>一书. PS:本文中类的名字定义存在问题,Link9应改为Link.LinkList9应该为LinkList.由于在同包下存在该名称,所以在后面接 ...

  5. JAVA 链表操作：单链表和双链表

    主要讲述几点: 一.链表的简介 二.链表实现原理和必要性 三.单链表示例 四.双链表示例 一.链表的简介 链表是一种比较常用的数据结构,链表虽然保存比较复杂,但是在查询时候比较便捷,在多种计算机语言都 ...

  6. java 链表数据结构

    首先,单链表相对于队列的优势在于存储地址不是连续的,这样的意义在于,操作其中的某一个位置的元素时不需要对之前的其他元素都进行内存操作,大大的为我们的计算机减压了.下面直接进入正题: 先要定义一个结点类 ...

  7. Java 链表

    按链表的组织形式分有ArrayList和LinkList两种.ArrayList内部其实是用数组的形式实现链表,比较适合链表大小确定或较少对链表进行增删操作的情况,同时对每个链表节点的访问时间都是co ...

  8. 算法_栈与队列的Java链表实现

    链表是一个递归的数据结构,它或者为null,或者是指向一个结点的引用,该结点含有一个泛型的元素和指向另一个链表的引用.可以用一个内部类来定义节点的抽象数据类型: private class Node ...

  9. 学习记录 java 链表知识

    01.import java.util.HashMap; 02.import java.util.Scanner; 03.import java.util.Stack; 04. 05./** 06. ...

随机推荐

  1. Jenkins pipeline shared library

    Jenkinsfile https://jenkins.io/doc/book/pipeline/jenkinsfile/ Jenkins Pipeline is a suite of plugins ...

  2. shell 命令使用笔记

    1.提取字符串中以.ddd结尾的ddd值 result=$(echo "chip86.500" | grep -Eo '\.[0-9]{1,}' | grep -Eo '[0-9] ...

  3. c# 线程锁 ，

    using System; using System.Collections.Generic; using System.Text; using System.Threading; namespace ...

  4. python随机数random模块

    需要  import random x=random.random()    产生 0 到 1 之间的随机浮点数 结果  0.005570080000840916 x=random.randint(1 ...

  5. div行高不确定，文字和图片居中

    // 加在父级div中 垂直居中:align-items:center; display: -webkit-flex;水平居中:justify-content:center; display: -we ...

  6. asyncio模块中的Future和Task

      task是可以理解为单个coroutine,经过ensure_future方法处理而形成,而众多task所组成的集合经过asyncio.gather处理而形成一个future. 再不精确的粗略的说 ...

  7. 《Java编程思想第四版》附录 C Java 编程规则

    附录 C Java 编程规则 本附录包含了大量有用的建议,帮助大家进行低级程序设计,并提供了代码编写的一般性指导: (1) 类名首字母应该大写.字段.方法以及对象(句柄)的首字母应小写.对于所有标识符 ...

  8. Thymeleaf--:fragment

    <html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="http://www.thymeleaf.org" ...

  9. truncate、delete、drop区别

    语法: truncate table 表名 delete from 表名 drop table 表名 应用范围: truncate 只能对表,且不能用于参与了索引的表,不能用于外键约束引用的表 del ...

  10. linux 安装图行界面

    centos6的环境中 代码:[root@ebs122 sysconfig]#yum groupinstall "Desktop" 使用 init 5命令进入图形化界面,如果成功的 ...