Java模拟(单双向)循环链表图文说明，有源码有注释

最新推荐文章于 2023-05-25 19:57:47 发布
最新推荐文章于 2023-05-25 19:57:47 发布
阅读量382 收藏 1
点赞数 2
文章标签： java单双向循环链表 附源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sJzao/article/details/79578595
版权
单向循环链表

前面为了说明方便，有些是用的贴图，由于有些图片较大形成挤压，看不清点击看原图即可，源码会在后面给出，话不多说，开始吧！

  • 节点类Node
/**
 *  @author AmVilCresx
 * 节点类
 */
public class Node {
    Object element; //数据域
    Node next; // 后继指针域
    Node previor;// 前驱指针域

    //非头结点的构造方法
    public Node(Object element) {
        this.element = element;
    }
}

  • 插入链表的第一个元素
    FirstrNode

  • 在尾部插入节点元素
    insertRear

  • 在头部插入节点元素
    insrtHead

  • 在指定位置插入元素节点
    anyWhere

  • 删除指定位置的节点
    delete

  • 删除给定的元素节点(注释做了简单说明，其它操作跟上面删除类似)
    delByNode

  • 单向循环链表源码
    复制粘贴开发工具，修改你自己的包名即可运行
public class Node {
    Object element; //数据域
    Node next; // 后继指针域
    Node previor;// 前驱指针域

    //非头结点的构造方法
    public Node(Object element) {
        this.element = element;
    }
}
------------------------分割线------------------------------------
package com.avc.link;

/**
 * @author AmVilCresx
 * 模拟单向循环链表
 * */
public class CycleLinkList{

    Node head; //头指针
    Node rear; //尾节点
    Node currentPrior; 当前节点的前一个节点，下面的删除和插入要用
    int size; //节点个数

    /**
     * 对空链表第一个节点进行插入
     * */
    private void insertFirstNode(Node node) {
        head = node;    //头指针指向node
        rear = head;    // 尾指针指向head
        head.next = rear;   //链接成环状
        size++; //长度+1
    }   

    /**
     * 在末尾插入
     * */
    public void insertRear(Node node) {
        if(head == null) {
            insertFirstNode(node); // 插入链表的第一个元素
        }else {
            node.next = rear.next;  //将带插入节点的next指向原链表rear的next;
            rear.next = node;   // 将原链表的rear的next指向node
            rear = node;    // 改变rear的指向 为node
            size++;     //长度+1
        }   
    }

    /**
     * 头插法
     * 头插其实就是和末尾插入一样的，只不过尾插改变的是尾指针，头指针不变，头插改变头指针，尾指针不变
     * */
    public void insertHead(Node node) {
        if(head == null) {
            insertFirstNode(node);
        }else {
            node.next = rear.next; 
            rear.next=node;
            head=node; // 此处改变的是头指针head的指向
            size++;
        }
    }


    /**
     * 获取节点
     * */
    public Node get(int index){
        Node tmp = head;
        int j=0;
        if(index<0 || index>size-1) {
            return null;
        }
        while(j!=index) {
            tmp = tmp.next;
            j++;
        }
        return tmp;
    }

    /**
     * 定位到操作节点的前一个位置
     * */
    public void getLoation(int index) {
        currentPrior = head;
        int j=0;

        while(j<index-1) {//找到要插入的位置前一个位置
            currentPrior = currentPrior.next;
            j++;
        }
        if(index==0) { //如果是第一个节点，则它的前一个节点就是rear节点，上面的while没处理这种情况
            currentPrior=rear; //手动赋值
            head=head.next; //注意：一定要将head指向下一个节点，不然get的时候会出错
        }
    }

    /**
     * 在这指定位置进行插入
     * */
    public void insertAnyWhere(int index,Node node) {
        if(index<0 || index > size) {
            throw new RuntimeException("参数非法");
        }

        if(index == 0) { //第一个位置，说明是头插 
            this.insertHead(node);
        }else if(index == size) { //最后一个位置，说明是，尾插
            this.insertRear(node);
        }else {
            getLoation(index);  //定位到index的前一个位置
            node.next = currentPrior.next; // 将带插入节点的next指向当前节点（也就是当前节点的前一个节点的下一个节点）
            currentPrior.next=node; // 将前一个节点的next指向node，完成连接
            size++; // 长度+1
        }
    }

    /**
     * 删除指定位置的节点
     * */
    public Node delete(int index) {
        if(index<0 || index>size-1)
            throw new RuntimeException("参数非法");
        if(isEmpty()) {
            throw new RuntimeException("链表为空，操作失败");
        }
        Node delNode = null;
        getLoation(index); //定位到index的前一个位置
        delNode = currentPrior.next; //待删除的节点（当前节点）
        currentPrior.next=delNode.next; // 将当前节点的前驱节点的next指针指向当前节点的next域
        size--; //长度 -1
        return delNode;
    }


    /**
     * 删除给定的节点，这里为了测试方便，默认值相同则是相同的节点,并且不存在element相同的节点
     * */
    public Node deleteByNode(Node node) {
        Node delNode= null;
        if(isEmpty()) {
            throw new RuntimeException("链表为空，操作失败");
        }
        if(size==1 && node.element == head.element) {
            delete(0);
            head=null;
            return node;
        }
        Node tmp = head; //临时指针变量
        int count=size;
        while(count>0 && node.element!= tmp.next.element) {
            // 如果小于count，没走完一圈 或者下个节点的值不等于给定节点的值
            count--;
            tmp = tmp.next;
        }
        if(count==0) {
            throw new RuntimeException("元素不存在，无法删除");
        }else {
            delNode = tmp.next;
            if(delNode==head) { // 判断一下，不然get会出错
                head=delNode.next;
            }
            if(tmp.next==rear) {
                rear=tmp;
            }
            tmp.next=delNode.next; // 改变指针指向
            size--;
        }
        return delNode;
    }

    //链表大小
    public int size() {
        return this.size;
    }
    /**
     * 判断链表是否为空
     * */
    public boolean isEmpty() {
        return size==0;
    }

    public static void main(String[] args) {
        CycleLinkList list = new CycleLinkList();
        /*list.insertRear(new Node(1));
        list.insertRear(new Node(2));
        list.insertRear(new Node(3));
        System.out.println(list.get(1).getElement());*/
        list.insertHead(new Node(1));
        list.insertHead(new Node(2));
        list.insertHead(new Node(3));
        list.insertHead(new Node(4));
        Node ist = new Node(6);
        list.insertRear(ist);
    //  list.insertAnyWhere(1, new Node("insrt"));
        /*System.out.println(list.get(1).element);
        System.out.println("size----"+list.size());
        list.delete(1);
        System.out.println("size----"+list.size());
        System.out.println(list.get(1).element);
        System.out.println(list.get(1).next.element);*/
        System.out.println("size----"+list.size());
        System.out.println(list.get(3).element);
        System.out.println(list.deleteByNode(ist).element);
        System.out.println("size----"+list.size());
        System.out.println(list.get(3).element);

    }
}
双向循环链表

  • 在尾部插入节点元素
    Rear

  • 在头部插入元素节点
    Head

  • 在指定的位置插入节点
    any

  • 删除指定位置的节点元素
    del

  • 删除给定的节点元素
    del2

    • 双向循环链表源码
package com.avc.link;

/**
 * @author AmVilCresx
 * 模拟双向循环链表
 *
 */
public class CycleBothWayLinkList {

    Node head; //头指针
    Node rear; //尾节点
    Node current; //当前节点，下面的删除和插入要用
    int size=0; //节点个数

    /**
     * 插入整个链表的第一个节点
     * */
    private void insertFirstNode(Node node ) {
        head=node;
        rear=head;
        head.next=rear; 
        head.previor=rear;// 形成双向环状
        size++;
    }

    /**
     * 尾插法
     * */
    public void insertRear(Node node) {
        if(head == null) {
            insertFirstNode(node);
        }else {
            node.next=rear.next;    // 将带插入节点node的next指向rear的next
            node.previor=rear;  // 将node的前驱指向rear
            rear.next.previor=node; //将rear的next的前驱指向node
            rear.next=node; //将rear的next指向node
            rear=node; //将rear设置为node
            size++;
        }

    }

    /**
     * 头插法
     * */
    public void insertHead(Node node) {
        if(head == null) {
            insertFirstNode(node);
        }else {
            node.next=rear.next; // 将带插入节点node的next指向rear的next
            node.previor=rear; //将node的前驱指向rear
            rear.next.previor=node; //将原来rear的next节点的前驱设置为node
            rear.next=node; //则rear的next指向node
            head = node; // 改变head的指向
            size++;
        }
    }

    /**
     * 在任意位置插入
     * */
    public void insertAnyWhere(int index, Node node) {
        if(index<0 || index>size) {
            throw new RuntimeException("参数非法！");
        }
        if(index ==0) {
            insertHead(node);
        }else if(index==size) {
            insertRear(node);
        }else {
            getLoation(index); // 因为是双向链表，所以直接定位到要操作的节点
            node.next = current; //将待插入节点的next指向当期节点
            node.previor=current.previor; //将node的前驱节点设置为当前节点的前驱节点
            current.previor.next=node; // 再讲当前节点的前驱的next指向node
            current.previor=node; // 再将当前节点的前驱节点设置为node
            size++;
        }
    }

    /**
     * 删除指定位置的节点
     * */
    public Node deleteNode(int index) {
        if(index<0 || index>size-1)
            throw new RuntimeException("参数非法");
        if(isEmpty()) {
            throw new RuntimeException("链表为空，操作失败");
        }
        getLoation(index);//找到要插入的位置的当前节点(这里也可以找要操作的节点的前一个节点，因为这里有前驱指针,可不必)
        Node delNode = current;
        current.previor.next=current.next;
        current.next.previor=current.previor;
        size--;
        return delNode;
    }

    /**
     * 删除给定的节点，这里为了测试方便，默认值相同则是相同的节点,并且不存在element相同的节点
     * */
    public Node deleteByGiveNode(Node node) {
        Node delNode= null;
        if(isEmpty()) {
            throw new RuntimeException("链表为空，操作失败");
        }
        if(size==1 && node.element == head.element) {
            deleteNode(0);
            head=null;
            return node;
        }
        Node tmp = head;
        int count=size;
        while(count>0 && tmp.element != node.element) {
            count--;
            tmp=tmp.next;
        }
        if(count==0) {
            throw new RuntimeException("元素不存在，无法删除");
        }else {
            delNode = tmp;
            if(delNode==head) {
                head=delNode.next;
            }
            if(delNode==rear) {
                rear=delNode.previor;
            }
            tmp.previor.next=tmp.next;
            tmp.next.previor=tmp.previor;
            size--;
        }       
        return delNode;
    }

    //定位到指定位置
    public void getLoation(int index) {
        current = head;
        int j=0;
        while(j<index) {//找到要插入的位置前一个位置
            current = current.next;
            j++;
        }
        if(index ==0) {
            head = current.next; //改变head的指向
        }
    }

    /**
     * 获取节点
     * */
    public Node get(int index){
        Node tmp = head;
        int j=0;
        if(index<0 || index>size-1) {
            return null;
        }
        while(j!=index) {
            tmp = tmp.next;
            j++;
        }
        return tmp;
    }

    public boolean isEmpty() {
        return size==0;
    }
    //链表大小
    public int size() {
        return this.size;
    }

    /**
     * main函数测试
     * */
    public static void main(String[] args) {
        CycleBothWayLinkList cyl = new CycleBothWayLinkList();
        cyl.insertHead(new Node(1));
        cyl.insertHead(new Node(2));
        cyl.insertHead(new Node(3));
        cyl.insertHead(new Node(4));
        System.out.println("前驱："+cyl.get(0).previor.element);
        System.out.println("自身："+cyl.get(0).element);
        System.out.println("后继："+cyl.get(0).next.element);
        System.out.println("---------------");
        cyl.insertAnyWhere(0, new Node("insrt"));
        System.out.println("前驱："+cyl.get(0).previor.element);
        System.out.println("自身："+cyl.get(0).element);
        System.out.println("后继："+cyl.get(0).next.element);
        System.out.println("---------------");
        cyl.deleteNode(0);
        System.out.println("前驱："+cyl.get(0).previor.element);
        System.out.println("自身："+cyl.get(0).element);
        System.out.println("后继："+cyl.get(0).next.element);
    }
}

有问题请大家留言，批评指正！共勉！！！

AmVilCres
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java双向循环链表的实现代码
09-05
介绍了java双向循环链表的实现代码，有需要的朋友可以参考一下
java实现双向链表(图解以及分析)
qq_54469537的博客
10-02 1679
详细分析以图解实现双向链表
java实现双向循环链表（循环双链表）
初心不忘、始终方得
04-20 5476
若是不清楚链表的结构，该篇文章不适合观看，这里只做文字说明，没有链表结构的图示
【数据结构】线性表 ⑤ ( 双循环链表 | 双循环链表特点 | 双循环链表插入操作处理 | 代码示例 - 使用 Java 实现 双循环链表 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
05-20 2095
一、双循环链表 二、双循环链表特点 三、双循环链表插入操作处理 四、代码示例 - 使用 Java 实现 双循环链表
Java数据结构--双向链表
m0_74808313的博客
04-23 1319
在上一篇中我们学习了单向链表的实现，链表中我们除了单向链表还有双向链表，在这一篇我们将更进一步地了解链表，实现双向链表。
Java数据结构之双向链表（配图详解，简单易懂）
如风暖阳的博客
01-28 5625
Java数据结构之双向链表（配图详解，简单易懂）
双向循环链表源码
02-01
本人自己编写的双向循环链表源码,分享给大家,存在什么问题请指出
java中使用双向链表实现贪吃蛇程序源码分享
09-03
主要介绍了java中使用双向链表实现贪吃蛇程序源码分享,本文直接给出了实现代码,需要的朋友可以参考下
Java实现双向链表(两个版本)
09-02
主要介绍了Java实现双向链表(两个版本)的相关资料,需要的朋友可以参考下
C语言中双向链表和双向循环链表详解
08-30
主要介绍了C语言中双向链表和双向循环链表详解的相关资料,需要的朋友可以参考下
用Java实现模拟双向循环链表LinkedList
02-28
这是自己写的一个Java实现模拟数据结构中的LinkedList。实现其简单的添加节点功能
单向循环链表（JAVA）
05-23
类似约瑟夫环问题。有一群人组成一个圈。从头开始按照顺时针方向从1开始依次报数。报到到9的人就离开圈子。其左手边的人接着从1开始报数。依此进行，直到剩最后一个人为止。
利用单向循环链表存储结构模拟约瑟夫环
06-06
约瑟夫环问题： 编号为1，2，3 n的n个人按顺时针方向围坐一圈，没人持有一个密码。一开始任选一个正整数作为报数上限值m，从第一人开始按顺时针方向报数，报到m停止。报m的人出列，将他的密码作为新的m的值，从他的下一个人开始从一报数，如此下去，直到所有人出列。
java基础-双向循环链表
热门推荐
专注于Java架构学习 https://gitee.com/laokouyun https://github.com/KouShenhai
10-29 3万+
小伙伴们，你们好呀！我是老寇！ 前文介绍了java基础-链表 双向循环链表就是链表的升级版，多了有头，尾指针之分，指针的方向是双向的！！！ 首先创一个节点类： package cn.itcast.huahai.linklist; //AnyType表示任意类型 public class DulNode<AnyType>{ public AnyType data;//数值 public DulNode<AnyType> next;//前驱节点 publi.
【数据结构】线性表 ④ ( 循环链表 / 单循环链表 | 代码示例 - 使用 Java 实现 单循环链表 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
05-19 909
一、循环链表 ( 单循环链表 ) 二、代码示例 - 使用 Java 实现 单循环链表
【简易轮子】Java双向循环链表实现
Ry1的博客
04-21 387
在计算机科学中，链表（Linked List）是一种常见的数据结构，由若干个节点组成，每个节点包含一个值和一个指针，指向下一个节点。与单向链表不同，双向链表（Doubly Linked List）每个节点还有一个指向前驱节点的指针。因此，我们可以从任意一个节点开始，向前或向后遍历整个链表。在双向循环链表（Doubly Circular Linked List）中，链表的尾部指针也指向头部，这样就形成了一个循环结构。
java实现双向循环链表（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-25 51
java实现双向循环链表（附完整源码）
双向链表---JavaSE
weixin_61518137的博客
06-11 153
666
Java数据结构——代码实现双向链表的方法
chenchenchencl的博客
09-23 2402
一文速学双向链表方法的实现
java实现带头双向循环链表(附完整源码)
最新发布
06-08
以下是Java实现带头双向循环链表的完整源码，供参考： ``` public class DoublyCircularLinkedList<T> { private Node<T> head; // 头节点 // 节点类 private static class Node<T> { T data; Node<T> prev; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值