主要讲述几点：

一、链表的简介

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

三、单链表示例

四、双链表示例

　

一、链表的简介　

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

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

　　这里只分析单链表和双链表。链表的实现过程是有些许复杂的，但是会带来许多好处。比如现在网购时代到来，商家发快递一般会将商品包装在盒子里并写上地址信息，快递公司就可以通过盒子上的信息找到买家，商品完整到达。如果没有盒子的保护，有可能在途中商品受损。而链表就好比那个写了地址信息的盒子，既保护了商品信息，同时又写好了物流信息。链表之中存在一个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. }

JAVA 链表操作：单链表和双链表的更多相关文章

  1. 数组、单链表和双链表介绍 以及 双向链表的C/C++/Java实现

    概要 线性表是一种线性结构,它是具有相同类型的n(n≥0)个数据元素组成的有限序列.本章先介绍线性表的几个基本组成部分:数组.单向链表.双向链表:随后给出双向链表的C.C++和Java三种语言的实现. ...

  2. 《程序员代码面试指南》第二章 链表问题 在单链表和双链表中删除倒数第K个节点

    题目 在单链表和双链表中删除倒数第K个节点 java代码 /** * @Description:在单链表和双链表中删除倒数第K个节点 * @Author: lizhouwei * @CreateDat ...

  3. C# 数据结构 - 单链表 双链表 环形链表

    链表特点(单链表 双链表) 优点:插入和删除非常快.因为单链表只需要修改Next指向的节点,双链表只需要指向Next和Prev的节点就可以完成插入和删除操作. 缺点:当需要查找某一个节点的时候就需要一 ...

  4. Java双链表

    一.概述 二.英雄类 class HeroNode { //值域 public int id; public String name; public String nickName; //指针域 pu ...

  5. Linux 底下使用C语言的　单链表　，双链表，二叉树　读取文件，并排序

    直接上代码 单链表Linux读文件排序: 双链表Linux读取文件排序: 二叉树LinuX读取文件并排序:

  6. C语言版本：双链表的实现

    Dlist.h #ifndef __DLIST_H__ #define __DLIST_H__ #include<cstdio> #include<malloc.h> #inc ...

  7. Python与数据结构[0] -> 链表/LinkedList[1] -> 双链表与循环双链表的 Python 实现

    双链表 / Doubly Linked List 目录 双链表 循环双链表 1 双链表 双链表和单链表的不同之处在于,双链表需要多增加一个域(C语言),即在Python中需要多增加一个属性,用于存储指 ...

  8. 算法 - 链表操作思想 && case

    算法 - 链表操作题目套路 前面这一篇文章主要讲链表操作时候的实操解决方式,本文从本质讲解链表操作的元信息,学完后,再也不怕链表操作题目了. 1.链表的基本操作 链表的基本操作无外乎插入,删除,遍历 ...

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

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

随机推荐

  1. Windows Azure Storage (6) Windows Azure Storage之Table

    <Windows Azure Platform 系列文章目录> 最近想了想,还是有必要把Windows Azure Table Storage 给说清楚. 1.概念 Windows Azu ...

  2. 注册OCX失败

    今天注册某个OCX时,Windows报告以下错误: 模块“XXX.ocx”已加载,但对 DllRegisterServer 的调用失败,错误代码为 0x80040200. 这是Windows权限引起的 ...

  3. EL

  4. IL指令汇总

    名称 说明   名称 说明 Add 将两个值相加并将结果推送到计算堆栈上.   Ldelem.I1 将位于指定数组索引处的 int8 类型的元素作为 int32 加载到计算堆栈的顶部. Add.Ovf ...

  5. [转]Linux常用命令

    系统信息arch 显示机器的处理器架构(1) uname -m 显示机器的处理器架构(2) uname -r 显示正在使用的内核版本 dmidecode -q 显示硬件系统部件 - (SMBIOS / ...

  6. Trace1：Default Trace

    sql server trace 是一个轻量级的追踪工具,对追踪数据库的行为很有用,因此,sql server内置一个trace(default trace). 1,sql server 内置Defa ...

  7. 链接(extern、static关键词\头文件\静态库\共享库)

    原文链接:http://www.orlion.ga/781/ 一. 多目标文件的链接 假设有两个文件:stack.c: /* stack.c */ char stack[512]; int top = ...

  8. java获取类的信息

    关键技术剖析 1.java.lang.reflect包实现了java的反射机制,在使用反射机制时,需要导入该包. 2.Class类的forName方法能够根据类名加载类,获得类的Class对象. Cl ...

  9. 【原创】机器学习之PageRank算法应用与C#实现(2)球队排名应用与C#代码

    在上一篇文章:机器学习之PageRank算法应用与C#实现(1)算法介绍 中,对PageRank算法的原理和过程进行了详细的介绍,并通过一个很简单的例子对过程进行了讲解.从上一篇文章可以很快的了解Pa ...

  10. AngularJS之Dependency Injection（五）

    前言 这一节我们来讲讲AngularJS中的依赖注入,在实际开发中Angular提供了具体的方法供我们去调用,但是一旦业务不能满足要求或者出现麻烦或者错误时导致无从下手,所以基于此我们有必要深入一点去 ...