当前位置：移动技术网 > IT编程>开发语言>Java > JAVA 数据结构链表操作循环链表

JAVA 数据结构链表操作循环链表

2019年07月22日 | 移动技术网IT编程 | 我要评论

java 链表操作：循环链表

主要分析示例：

一、单链表循环链表

二、双链表循环链表

其中单链表节点和双链表节点类和接口icommoperate<t>与上篇一致，这里不在赘述。参考：java链表操作：单链表和双链表

一、单链表循环链表

 
package linklisttest;

import java.util.hashmap;
import java.util.map;

public class singlecyclelinklist implements icommoperate<snode> {
  private snode head = new snode("head") ; // 公共头指针，声明之后不变
  private int size = 0 ;
  public int getsize() {
    return this.size;
  }
  
  /*
   * 链表插入，每次往末端插入,判定末端的标准为next是否指向head
   * */
  @override
  public boolean insertnode(snode node) {
    boolean flag = false ; 
    
    initlinklist() ; // 初始化链表
    if( this.size==0 ){ // 空链表
      this.head.setnextnode(node) ;
      node.setnextnode(this.head) ;
    }else{
      snode current = this.head ;
      while( current.getnextnode()!=this.head ){ // 找到末端节点
        current = current.getnextnode() ;
      }
      current.setnextnode(node) ;
      node.setnextnode(this.head) ; // 循坏链表，尾节点指向head
    }
    this.size++ ;
    flag = true ;
    
    return flag;
  }
  
  /*
   * 插入链表指定位置pos,从1开始,而pos大于size则插入链表末端
   * */
  @override
  public boolean insertposnode(int pos, snode node) {
    boolean flag = true ; 
    snode current = this.head.getnextnode() ;
    
    initlinklist() ;// 初始化链表
    if( this.size==0 ){         // 链表为空
      this.head.setnextnode(node) ;
      node.setnextnode(this.head) ;// 循坏链表，尾节点指向head
      this.size++ ;
    }else if( this.size<pos ){      // pos位置大于链表长度，插入末端
      insertnode(node) ;
    }else if( pos>0 && pos<=this.size ){ // 链表内节点
      // 1、找到要插入pos位置节点和前节点，node将插入两个节点之间
      int find = 0;
      snode prenode = this.head; // 前节点
      snode currentnode = current; // 当前节点
      while( find<pos-1 && currentnode!=this.head ){
        prenode = current ;             // 前节点后移
        currentnode = currentnode.getnextnode() ; // 当前节点后移
        find++ ;
        if( find<pos-1 && currentnode!=this.head ){ // 未结束寻找节点前，后移前节点
          current = current.getnextnode() ;
        }
      }
//      system.out.println(prenode);
//      system.out.println(currentnode);
      
      // 2、插入节点
      prenode.setnextnode(node);
      node.setnextnode(currentnode);
      this.size++ ;
    }else {
      system.out.println("位置信息错误");
      flag = false ;
    }
    
    return flag;
  }

  private void initlinklist(){
    if( size==0 ){
      this.head.setnextnode(this.head);
    }
  }
  
  /*
   * 指定链表的节点pos，删除对应节点。方式：找到要删除节点的前后节点,进行删除,下标从1开始
   * */
  @override
  public boolean deletenode(int pos) {
    boolean flag = false; 
    snode current = this.head.getnextnode() ;
    if( pos<=0 || pos>this.size || current==this.head ){
      system.out.println("位置信息错误或链表无信息");
    }else{
      // 1、找到要删除节点的前后节点
      int find = 0;
      snode prenode = this.head; // 前节点
      snode nextnode = current.getnextnode(); // 后节点
      while( find<pos-1 && nextnode!=this.head ){
        prenode = current ;          // 前节点后移
        nextnode = nextnode.getnextnode() ; // 后节点后移
        find++ ;
        if( find<pos-1 && nextnode!=this.head ){ // 未结束找节点前，后移"前节点"
          current = current.getnextnode() ;
        }
      }
//      system.out.println(prenode);
//      system.out.println(nextnode);
      
      // 2、删除节点
      prenode.setnextnode(nextnode);
      system.gc(); // 回收删除节点
      this.size-- ;
      flag = true ;
    }
    
    return flag;
  }
  
  /*
   * 指定链表的节点pos，修改对应节点,下标从1开始
   * */
  @override
  public boolean updatenode(int pos, map<string, object> map) {
    boolean flag = false ;
    snode node = getnode(pos, map); // 获得相应位置pos的节点
    if( node!=null ){
      string data = (string) map.get("data") ;
      node.setdata(data);
      flag = true ;
    }
    return flag;
  }
  
  /*
   * 找到指定链表的节点pos,下标从1开始
   * */
  @override
  public snode getnode(int pos, map<string, object> map) {
    snode current = this.head.getnextnode() ;
    if( pos<=0 || pos>this.size || current==this.head ){
      system.out.println("位置信息错误或链表不存在");
      return null;
    }
    int find = 0 ;
    while( find<pos-1 && current!=this.head ){
      current = current.getnextnode() ;
      find++ ;
    }
    return current;
  }

  /*
   * 打印链表
   * */
  @override
  public void printlink() {
    int length = this.size ;
    if( length==0 ){
      system.out.println("链表为空！");
      return ;
    }
    snode current = this.head.getnextnode() ;
    system.out.println("总共有节点数: " + length +" 个");
    int find = 0 ;
    while( current!=this.head ){
      system.out.println("第 " + (++find) + " 个节点 ：" + current);
      current=current.getnextnode() ;
    }
  }
  
  public static void main(string[] args) {
    singlecyclelinklist scll = new singlecyclelinklist() ;
    snode node1 = new snode("节点1");
    snode node2 = new snode("节点2");
    snode node3 = new snode("节点3");
    snode node4 = new snode("节点4");
    snode node5 = new snode("节点5");
    snode node6 = new snode("插入指定位置");
//    scll.insertposnode(scll.getsize()+1, node1) ;
//    scll.insertposnode(scll.getsize()+1, node2) ;
//    scll.insertposnode(scll.getsize()+1, node3) ;
//    scll.insertposnode(scll.getsize()+1, node4) ;
//    scll.insertposnode(scll.getsize()+1, node5) ;
    scll.insertnode(node1);
    scll.insertnode(node2);
    scll.insertnode(node3);
    scll.insertnode(node4);
    scll.insertnode(node5);
    
    system.out.println("*******************输出链表*******************");
    scll.printlink();
    
    system.out.println("*******************获得指定链表节点*******************");
    int pos = 2 ;
    system.out.println("获取链表第 "+pos+" 个位置数据 ："+scll.getnode(pos, null));
    
    system.out.println("*******************向链表指定位置插入节点*******************");
    int pos1 = 3 ;
    system.out.println("将数据插入第"+pos1+"个节点：");
    scll.insertposnode(pos1, node6) ;
    scll.printlink();
    
    system.out.println("*******************删除链表指定位置节点*******************");
    int pos2 = 3 ;
    system.out.println("删除第"+pos2+"个节点：");
    scll.deletenode(pos2) ;
    scll.printlink();
    
    system.out.println("*******************修改链表指定位置节点*******************");
    int pos3 = 3 ;
    system.out.println("修改第"+pos3+"个节点：");
    map<string, object> map = new hashmap<>() ;
    map.put("data", "this is a test") ;
    scll.updatenode(pos3, map) ;
    scll.printlink();
  }

}

二、双链表循环链表



package linklisttest;

import java.util.hashmap;
import java.util.map;

public class doublecyclelinklist implements icommoperate<dnode>{
  private dnode head = new dnode("head"); // 公共头指针，声明之后不变
  private int size = 0 ; // 记录链表节点数量
  
  public int getsize() {
    return this.size;
  }
  
  /*
   * 链表插入，每次往末端插入,判定末端的标准为next是否指向head
   * */
  @override
  public boolean insertnode(dnode node) {
    boolean flag = false ; 
    
    initlinklist() ; // 初始化链表
    dnode current = this.head ;
    if( this.size==0 ){  // 空链表
      this.head.setnextnode(node) ;
      node.setpriornode(this.head);
      node.setnextnode(this.head) ;
    }else{        // 链表内节点
      while( current.getnextnode()!=this.head ){ // 找到末端节点
        current = current.getnextnode() ;
      }
      current.setnextnode(node) ;
      node.setpriornode(current);
      node.setnextnode(this.head) ; // 循坏链表，尾节点指向head
    }
    this.size++ ;
    flag = true ;
    
    return flag;
  }
  
  /*
   * 插入链表指定位置pos,从1开始,而pos大于size则插入链表末端
   * */
  @override
  public boolean insertposnode(int pos, dnode node) {
    boolean flag = true; 
    
    initlinklist() ; // 初始化链表
    dnode current = this.head.getnextnode() ;
    if( this.size==0 ){           // 链表为空
      this.head.setnextnode(node) ;
      node.setpriornode(this.head);
      node.setnextnode(this.head) ;
      this.size++ ;
    }else if( pos>this.size ){         // pos位置大于链表长度，插入末端
      insertnode(node) ;
    }else if( pos>0 && pos<=this.size ){  // 链表内节点
      // 1、找到要插入位置pos节点,插入pos节点当前位置
      int find = 0;
      while( find<pos-1 && current.getnextnode()!=this.head ){
        current = current.getnextnode() ;
        find++ ;
      }
      // 2、插入节点
      if( current.getnextnode()==this.head ){ // 尾节点
        node.setpriornode(current);
        node.setnextnode(this.head);
        current.setnextnode(node);
      } else if( current.getnextnode()!=this.head ) { //中间节点
        node.setpriornode(current.getpriornode());
        node.setnextnode(current);
        current.getpriornode().setnextnode(node);
        current.setpriornode(node);
      } 
      this.size++ ;
    }else{
      system.out.println("位置信息错误");
      flag = false ;
    }
    return flag;
  }

  private void initlinklist(){
    if( size==0 ){
      this.head.setnextnode(this.head);
      this.head.setpriornode(this.head);
    }
  }
  
  /*
   * 指定链表的节点pos，删除对应节点。方式：找到要删除节点的前后节点删除,下标从1开始
   * */
  @override
  public boolean deletenode(int pos) {
    boolean flag = false; 
    dnode current = this.head.getnextnode() ;
    if( pos<=0 || pos>this.size || current==this.head ){
      system.out.println("位置信息错误或链表不存在");
    }else{
      // 1、找到要删除位置pos节点
      int find = 0;
      while( find<pos-1 && current.getnextnode()!=this.head ){
        current = current.getnextnode() ;
        find++ ;
      }
      // 2、删除节点
      if( current.getnextnode()==this.head ){ // 尾节点
        current.getpriornode().setnextnode(this.head) ;
      } else if( current.getnextnode()!=this.head ) { //中间节点
        current.getpriornode().setnextnode(current.getnextnode()) ;
        current.getnextnode().setpriornode(current.getpriornode()) ;
      } 
      system.gc(); // 回收删除节点
      this.size-- ;
      flag = true ;
    }
    return flag;
  }
  
  /*
   * 指定链表的节点pos，修改对应节点,下标从1开始
   * */
  @override
  public boolean updatenode(int pos, map<string, object> map) {
    boolean flag = false ;
    dnode node = getnode(pos, map);
    if( node!=null ){
      string data = (string) map.get("data") ;
      node.setdata(data);
      flag = true ;
    }
    return flag;
  }

  /*
   * 找到指定链表的节点pos,下标从1开始
   * */
  @override
  public dnode getnode(int pos, map<string, object> map) {
    dnode current = this.head.getnextnode() ;
    if( pos<=0 || pos>this.size || current==this.head ){
      system.out.println("位置信息错误或链表不存在");
      return null;
    }
    int find = 0 ;
    while( find<pos-1 && current!=this.head ){
      current = current.getnextnode() ;
      find++ ;
    }
    return current;
  }

  /*
   * 打印链表
   * */
  @override
  public void printlink() {
    int length = this.size ;
    if( length==0 ){
      system.out.println("链表为空！");
      return ;
    }
    dnode current = this.head.getnextnode() ;
    int find = 0 ; 
    system.out.println("总共有节点数: " + length +" 个");
    while( current!=this.head ){
      system.out.println("第 " + (++find) + " 个节点 ：" + current);
      current=current.getnextnode() ;
    }
  }
  
  public static void main(string[] args) {
    doublecyclelinklist dcll = new doublecyclelinklist() ;
    dnode node1 = new dnode("节点1");
    dnode node2 = new dnode("节点2");
    dnode node3 = new dnode("节点3");
    dnode node4 = new dnode("节点4");
    dnode node5 = new dnode("节点5");
    dnode node6 = new dnode("插入指定位置");
    dcll.insertposnode(10, node1) ;
    dcll.insertposnode(10, node2) ;
    dcll.insertposnode(8, node3) ;
    dcll.insertposnode(88, node4) ;
    dcll.insertposnode(8, node5) ;
//    dcll.insertnode(node1);
//    dcll.insertnode(node2);
//    dcll.insertnode(node3);
//    dcll.insertnode(node4);
//    dcll.insertnode(node5);
    
    system.out.println("*******************输出链表*******************");
    dcll.printlink();
    
    system.out.println("*******************获得指定链表节点*******************");
    int pos = 2 ;
    system.out.println("获取链表第 "+pos+"个位置数据 ："+dcll.getnode(pos, null));
    
    system.out.println("*******************向链表指定位置插入节点*******************");
    int pos1 = dcll.getsize()+1 ;
    system.out.println("将数据插入第"+pos1+"个节点：");
    dcll.insertposnode(pos1, node6) ;
    dcll.printlink();
    
    system.out.println("*******************删除链表指定位置节点*******************");
    int pos2 = 7 ;
    system.out.println("删除第"+pos2+"个节点：");
    dcll.deletenode(pos2) ;
    dcll.printlink();
    
    system.out.println("*******************修改链表指定位置节点*******************");
    int pos3 = 3 ;
    system.out.println("修改第"+pos3+"个节点：");
    map<string, object> map = new hashmap<>() ;
    map.put("data", "this is a test") ;
    dcll.updatenode(pos3, map) ;
    dcll.printlink();
  }
}

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！

您可能感兴趣的文章:

如对本文有疑问，点击进行留言回复！！

关于在IDEA中SpringBoot项目中activiti工作流的使用详解

记录一下工作流的在springboot中的使用,，顺便写个demo，概念，什么东西的我就不解释了，如有问题欢迎各位大佬指导一下。1.创建springboot项目... [阅读全文]
视频编辑工具ACDSee Luxea Video Editor安装及激活图文教程

acdsee luxea video editor如何免费激活？今天，小编为大家带来了acdsee luxea video editor安装及激活图文教程。感兴... [阅读全文]
解决java idea新建子目录时命名不是树形结构的问题

问题再现解决办法：点击设置，然后再点击compact middle packages，如下图：成功补充知识：idea 2019.2 svn 忽略文件/目录 .i... [阅读全文]
idea 普通文件夹转换成 module操作

经常会遇到从github上download的progect在idea里面打开是普通文件夹形式，而并不是我们想要的module形式（文件夹图标右下角有个蓝色的ta... [阅读全文]
SpringBoot中使用Ehcache的详细教程

ehcache 是一个纯 java 的进程内缓存框架，具有快速、精干等特点，是 hibernate 中默认的 cacheprovider。用惯了 redis，很... [阅读全文]
在idea 中添加和删除模块Module操作

1、添加模块2、删除模块补充知识：idea添加子module的正确姿势因需求要增加一个新的测试模块，于是要在一堆module中再添加一个module，单纯的我没... [阅读全文]
Unity3D生成一段隧道网格的方法

本文实例为大家分享了unity3d生成一段隧道网格的具体代码，供大家参考，具体内容如下一、需求最近有一个需求，生成段隧道的骨架网格。目前想到的方法就是，获取隧道... [阅读全文]
Django CBV模型源码运行流程详解

在view文件中编写一个类，并配置好路由class test(view): def get(self, request, *args, **kwargs): ... [阅读全文]
java spring整合junit操作(有详细的分析过程)

此博客解决了什么问题：解决测试的时候代码冗余的问题，解决了测试工程师的编码能力可能没有开发工程师编码能力的问题，解决了junit单元测试和spring注解相结合... [阅读全文]
详解JAVA 弱引用

定义弱引用是使用weakreference创建的引用，弱引用也是用来描述非必需对象的，它是比软引用更弱的引用类型。在发生gc时，只要发现弱引用，不管系统堆空间是... [阅读全文]

网友评论


验证码：

JAVA 数据结构链表操作循环链表

2019年07月22日 | 移动技术网IT编程 | 我要评论

您可能感兴趣的文章:

相关文章:

网友评论