Java中一个双向链表的增删改查

已于 2022-02-17 21:20:50 修改
阅读量753 收藏
点赞数
分类专栏： #java学习
于 2022-02-16 21:50:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46235384/article/details/122971134
版权

双向链表 Java 数据结构 增删查改 索引操作
关键词由CSDN通过智能技术生成

目录

定义一个双向链表

定义双向链表的节点类 

增

头插法

尾插法

根据索引插入

测试

查

根据index查找

根据val查找

测试

改

根据index修改

测试 

删

删除头节点

删除尾节点

删除index节点

删除指定节点

测试

判断索引是否合法

找到index位置的节点----二分法

 toString()方法

全部代码

定义一个双向链表

public class DoubleLinkedList {
    // 当前链表中有效的元素个数
    private int size;
    // 头节点
    private Node head;
    // 尾节点
    private Node tail;
}

定义双向链表的节点类 

/**
 * 双链表的节点类
 */
class Node {
    //前驱节点
    Node prev;
    //保存具体值
    int val;
    //后继节点
    Node next;

    public Node(int val) {
        this.val = val;
    }

    public Node(Node prev, int val, Node next) {
        this.prev = prev;
        this.val = val;
        this.next = next;
    }
}

增

  • 头插法

/**
     * 头插法
     * @param val
     */
    public void addFirst(int val){
        Node node = new Node(null,val,head);
        if (head == null){
            tail = node;
        }else{
            head.prev = node;
        }
        head = node;
        size++;
    }

  • 尾插法

 /**
     * 尾插法
     * @param val
     */
    public void addLast(int val){
        Node node = new Node(tail,val,null);
        if (tail == null){
            head = node;
        }else {
            tail.next = node;
        }
        tail = node;
        size++;
    }

  • 根据索引插入

/**
     * 在index位置插入节点
     * @param val
     */
    public void addIndex(int index,int val) {
        if (index<0 || index>size) {
            System.err.println("索引非法!");
            return;
        } else if (index == 0) addFirst(val);
        else if (index == size) addLast(val);
        else {
            Node prev = findNode(index - 1);
            Node newNode = new Node(prev,val,prev.next);
            prev.next.prev = newNode;
            prev.next = newNode;
            size++;
        }
    }

  • 测试

/**
 * @author happy
 */
public class Test {
    public static void main(String[] args) {
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.addFirst(1);
        doubleLinkedList.addFirst(2);
        doubleLinkedList.addLast(3);
        doubleLinkedList.addLast(4);
        //2->1->3->4->null
        System.out.println(doubleLinkedList);
        doubleLinkedList.addIndex(0,5);
        doubleLinkedList.addIndex(2,7);
        doubleLinkedList.addIndex(6,9);
        //5->2->7->1->3->4->9->null
        System.out.println(doubleLinkedList);
    }
}

查

  • 根据index查找

/**
     * 根据索引来查找，返回查找到的值
     * @param index
     * @return
     */
    public int getIndex(int index){
        if (indexCheck(index)){
           return findNode(index).val;
        }else {
            System.out.println("索引非法!");
            return  -1;
        }
    }

  • 根据val查找

/**
     * 根据val值查找，返回true/false
     * @param val
     * @return
     */
    public boolean contains(int val){
        for (Node node = head; node != null ; node = node.next) {
            if (node.val == val){
                return true;
            }
        }
        return false;
    }

  • 测试

/**
 * @author happy
 */
public class Test {
    public static void main(String[] args) {
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.addFirst(1);
        doubleLinkedList.addFirst(2);
        doubleLinkedList.addLast(3);
        doubleLinkedList.addLast(4);
        //2->1->3->4->null
        System.out.println(doubleLinkedList);
        doubleLinkedList.addIndex(0,5);
        doubleLinkedList.addIndex(2,7);
        doubleLinkedList.addIndex(6,9);
        //5->2->7->1->3->4->9->null
        System.out.println(doubleLinkedList);

        //5
        System.out.println(doubleLinkedList.getIndex(0));
        //7
        System.out.println(doubleLinkedList.getIndex(2));
        //9
        System.out.println(doubleLinkedList.getIndex(6));
        //true
        System.out.println(doubleLinkedList.contains(3));
        //false
        System.out.println(doubleLinkedList.contains(10));
    }
}

改

  • 根据index修改

/**
     * 根据index修改
     * @param index
     * @param newVal
     * @return
     */
    public int set(int index,int newVal){
        if (indexCheck(index)){
           Node node = findNode(index);
           int oldVal = node.val;
           node.val = newVal;
           return oldVal;
        }else {
            System.out.println("索引非法！");
            return -1;
        }
    }

  • 测试 

/**
 * @author happy
 */
public class Test {
    public static void main(String[] args) {
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.addFirst(1);
        doubleLinkedList.addFirst(2);
        doubleLinkedList.addLast(3);
        doubleLinkedList.addLast(4);
        //2->1->3->4->null
        System.out.println(doubleLinkedList);
        doubleLinkedList.addIndex(0,5);
        doubleLinkedList.addIndex(2,7);
        doubleLinkedList.addIndex(6,9);
        //5->2->7->1->3->4->9->null
        System.out.println(doubleLinkedList);


        //5
        System.out.println(doubleLinkedList.getIndex(0));
        //7
        System.out.println(doubleLinkedList.getIndex(2));
        //9
        System.out.println(doubleLinkedList.getIndex(6));
        //true
        System.out.println(doubleLinkedList.contains(3));
        //false
        System.out.println(doubleLinkedList.contains(10));


        doubleLinkedList.set(0,3);
        doubleLinkedList.set(6,10);
        doubleLinkedList.set(3,5);
        //3->2->7->5->3->4->10->null
        System.out.println(doubleLinkedList);
    }
}

删

  • 删除头节点

  public void removeFirst(){
        removeIndex(0);
    }

  • 删除尾节点

public void removeLast(){
        removeIndex(size-1);
    }

  • 删除index节点

/**
     * 删除index位置的节点
     * @param index
     */
    public void removeIndex(int index){
        if (indexCheck(index)){
            Node node = findNode(index);
            removeNode(node);
        }else {
            System.out.println("索引非法！");
        }
    }
    /**

  • 删除指定节点

/**
     * 删除指定节点，分治法
     * @param node
     */
    private void removeNode(Node node){
        Node prev = node.prev;
        Node next = node.next;
        if (prev == null){
            head = next;
        }else {
            //有前驱节点
            //先处理前驱节点
            prev.next = next;
            node.prev = null;
        }
            if (next == null){
                tail = prev;
            }else {
                next.prev = prev;
                node.next = null;
            }
            size--;
        
    }

  • 测试

/**
 * @author happy
 */
public class Test {
    public static void main(String[] args) {
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.addFirst(1);
        doubleLinkedList.addFirst(2);
        doubleLinkedList.addLast(3);
        doubleLinkedList.addLast(4);
        //2->1->3->4->null
        System.out.println(doubleLinkedList);
        doubleLinkedList.addIndex(0,5);
        doubleLinkedList.addIndex(2,7);
        doubleLinkedList.addIndex(6,9);
        //5->2->7->1->3->4->9->null
        System.out.println(doubleLinkedList);


        //5
        System.out.println(doubleLinkedList.getIndex(0));
        //7
        System.out.println(doubleLinkedList.getIndex(2));
        //9
        System.out.println(doubleLinkedList.getIndex(6));
        //true
        System.out.println(doubleLinkedList.contains(3));
        //false
        System.out.println(doubleLinkedList.contains(10));


        doubleLinkedList.set(0,3);
        doubleLinkedList.set(6,10);
        doubleLinkedList.set(3,5);
        //3->2->7->5->3->4->10->null
        System.out.println(doubleLinkedList);


        doubleLinkedList.removeIndex(0);
        doubleLinkedList.removeIndex(2);;
        doubleLinkedList.removeIndex(4);
        //2->7->3->4->null
        System.out.println(doubleLinkedList);
        doubleLinkedList.removeFirst();
        //7->3->4->null
        System.out.println(doubleLinkedList);
        doubleLinkedList.removeLast();
        //7->3->null
        System.out.println(doubleLinkedList);
    }
}

 

判断索引是否合法

public boolean indexCheck(int index){
        if (index<0 || index>=size)
            return false;
        return true;
    }

找到index位置的节点----二分法

/**
     * 找到index索引对应的节点，使用二分查找
     * @param index
     * @return index对应的节点Node
     */
    private Node findNode(int index) {
        Node ret = null;
        if(index < (size >> 1)){
            ret = head;
            for (int i = 0; i <index ; i++) {
                ret = ret.next;
            }
        }else {
            ret = tail;
            for (int i = size-1; i > index ; i--) {
                ret = ret.prev;
            }
        }
        return ret;
    }

 toString()方法

public String toString(){
        String ret = "";
        Node node = head;
        while (node != null){
            ret += node.val + "->";
            node = node.next;
        }
        ret += null;
        return ret;
    }

全部代码

public class DoubleLinkedList {
    // 当前链表中有效的元素个数
    private int size;
    // 头节点
    private Node head;
    // 尾节点
    private Node tail;

    /**
     * 头插法
     * @param val
     */
    public void addFirst(int val){
        Node node = new Node(null,val,head);
        if (head == null){
            tail = node;
        }else{
            head.prev = node;
        }
        head = node;
        size++;
    }

    /**
     * 尾插法
     * @param val
     */
    public void addLast(int val){
        Node node = new Node(tail,val,null);
        if (tail == null){
            head = node;
        }else {
            tail.next = node;
        }
        tail = node;
        size++;
    }

    /**
     * 在index位置插入节点
     * @param val
     */
    public void addIndex(int index,int val) {
        if (index<0 || index>size) {
            System.err.println("索引非法!");
            return;
        } else if (index == 0) addFirst(val);
        else if (index == size) addLast(val);
        else {
            Node prev = findNode(index - 1);
            Node newNode = new Node(prev,val,prev.next);
            prev.next.prev = newNode;
            prev.next = newNode;
            size++;
        }
    }

    /**
     * 根据索引来查找，返回查找到的值
     * @param index
     * @return
     */
    public int getIndex(int index){
        if (indexCheck(index)){
           return findNode(index).val;
        }else {
            System.out.println("索引非法!");
            return  -1;
        }
    }

    /**
     * 根据val值查找，返回true/false
     * @param val
     * @return
     */
    public boolean contains(int val){
        for (Node node = head; node != null ; node = node.next) {
            if (node.val == val){
                return true;
            }
        }
        return false;
    }

    /**
     * 根据index修改
     * @param index
     * @param newVal
     * @return
     */
    public int set(int index,int newVal){
        if (indexCheck(index)){
           Node node = findNode(index);
           int oldVal = node.val;
           node.val = newVal;
           return oldVal;
        }else {
            System.out.println("索引非法！");
            return -1;
        }
    }

    public void removeFirst(){
        removeIndex(0);
    }

    public void removeLast(){
        removeIndex(size-1);
    }

    /**
     * 删除index位置的节点
     * @param index
     */
    public void removeIndex(int index){
        if (indexCheck(index)){
            Node node = findNode(index);
            removeNode(node);
        }else {
            System.out.println("索引非法！");
        }
    }

    /**
     * 删除指定节点，分治法
     * @param node
     */
    private void removeNode(Node node){
        Node prev = node.prev;
        Node next = node.next;
        if (prev == null){
            head = next;
        }else {
            //有前驱节点
            //先处理前驱节点
            prev.next = next;
            node.prev = null;
        }
            if (next == null){
                tail = prev;
            }else {
                next.prev = prev;
                node.next = null;
            }
            size--;

    }

    public boolean indexCheck(int index){
        if (index<0 || index>=size)
            return false;
        return true;
    }

    /**
     * 找到index索引对应的节点，使用二分查找
     * @param index
     * @return index对应的节点Node
     */
    private Node findNode(int index) {
        Node ret = null;
        if(index < (size >> 1)){
            ret = head;
            for (int i = 0; i <index ; i++) {
                ret = ret.next;
            }
        }else {
            ret = tail;
            for (int i = size-1; i > index ; i--) {
                ret = ret.prev;
            }
        }
        return ret;
    }



    public String toString(){
        String ret = "";
        Node node = head;
        while (node != null){
            ret += node.val + "->";
            node = node.next;
        }
        ret += null;
        return ret;
    }
}
/**
 * 双链表的节点类
 */
class Node {
    //前驱节点
    Node prev;
    //保存具体值
    int val;
    //后继节点
    Node next;

    public Node(int val) {
        this.val = val;
    }

    public Node(Node prev, int val, Node next) {
        this.prev = prev;
        this.val = val;
        this.next = next;
    }
}

学习java的张三
关注
专栏目录
高薪程序员&面试题精讲系列31之你熟悉Java中的哪些集合？
一一哥
12-06 780
一. 面试题及剖析 1. 今日面试题 Java中的集合你了解吗？ 你熟悉Java中的哪些集合？ 集合的顶级接口是哪个，集合的具体实现类有哪些？ ...... 2. 题目剖析 我们在进行Java开发、代码优化以及并发操作时，经常会涉及到Java中的集合类，而在我们的面试中，集合尤其是HashMap集合，也是衡量我们Java基础是否扎实的一个高频考点。 可以说在Java基础方面，HashMap属于重中之重，如果HashMap回答不好，基本上就会被面试官判断为基础不扎实了。 接下来 壹哥 会
Java面试题整理
ZHAOHUODIAN888的博客
08-29 466
动态代理就是，在程序运行期，创建目标对象的代理对象，并对目标对象中的方法进行功能性增强的一种技术。在生成代理对象的过程中，目标对象不变，代理对象中的方法是目标对象方法的增强方法。可以理解为运行期间，对象中方法的动态拦截，在拦截方法的前后执行功能操作。反射是动态获取信息以及动态调用对象方法的一种机制。Java反射就是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；并且能改变它的属性。而这也是Java被视为动态语言的一个关键性质。...
Java实现双向链表的增删改查
weixin_44256581的博客
07-11 320
package com.tentact.linkedlist; public class DoubleLinkedListDemo { public static void main(String[] args) { HeroNode2 hero1 = new HeroNode2(1, "宋江", "及时雨"); HeroNode2 hero2 = new HeroNode2(2, "卢俊义", "玉麒麟"); HeroNode2 hero3 = new HeroNode2(3, "吴用"
java实现双向链表的增删改查
new_buff_007的博客
08-06 199
实现思路： 代码： public class DoubleLinkedList { private Person head = new Person(0,""); // 获取头结点 public Person getHead(){ return head; } // 添加-- 直接添加，没有按顺序添加 public ...
java实现简单双向链表增删改查
qq_44443020的博客
04-28 183
public class DoubleNode { private int index; private String name; private DoubleNode next; private DoubleNode front; private DoubleNode hear; public DoubleNode() { } public DoubleNode(int index, String name) { this
java 双向链表 增删改查
qq_39472229的博客
01-06 151
双向链表的增删改查 class MM{ public static void main(String[] args){ doublelist list=new doublelist(); Node node1=new Node(1,"林冲"); Node node2=new Node(2,"吴用"); Node node3 =...
java实现双向链表的增删改
挚友阳光的博客
05-26 451
java实现双向链表的增删改
java链表之--单向链表的增删改查
basycai的博客
07-06 916
结果：原链表： A-->B-->C-->D 查找节点:B 查找结果：找到! 删除节点：B 删除节点后的链表： A-->C-->D
Android数据结构进阶教程：从单向到双向链表
![Android数据结构进阶教程：从单向到双向链表]...本文将详细介绍链表的类型、特点和应用场景，重点放在单向链表和双向链表上，我们将从基础概念开始，逐步深入到操作细节，并结合Android平台的应用案例，为读者
Java知识点概览
qq_48403611的博客
08-03 3278
java后端开发常见面试题总结
自用JAVA基础面试八股文（简单易记不踩坑）
最新发布
weixin_53805188的博客
03-13 942
java基础易懂的实时更新知识点，自用！！！！
双向链表的增删改查Java
Word码鸭的博客
12-28 245
双链表
Java实现双链表的增删改查
qq_52621831的博客
08-10 208
import java.util.ArrayList; import java.util.Arrays; import java.util.LinkedList; import java.util.List; /* 双向链表：相当于单向链表，在每个节点除了记录下一个节点地址，还会记录上一个节点地址 分析： 1、先要有一个链表的类-------MyLinkedList 2、链表内有属性---节点 3、行为---增删改查 4、测试 */ public class Demo1 { public s.
Java实现双向链表增删改查
zt的博客
12-11 541
双向链表带头节点的双向链表模拟结点双向链表的增删改查测试 带头节点的双向链表 什么是双向链表： 双链表是链表的一种，由节点组成，每个数据结点中都有两个指针，分别指向直接后继和直接前驱。 模拟结点 //模拟双向链表的结点 public class DoubleNode { //data域中的数据 public int id; public String name; public int price; //上一个结点（直接前驱） public Doubl
java数据结构双向链表之算法增删改查
weixin_45519487的博客
06-02 239
1.双向链表应用实例 使用带头的双向链表实现----水浒英雄排行榜。 实现增删改查操作！ package Linkedlist.DoublelinkedList; public class DoubleLinkedListDemo { public static void main(String[] args) { //测试。创建节点 HeroNode2 heroNode1=new HeroNode2(1,"宋江"); ...
java代码实现双向链表增删改查demo
qq_39144393的博客
05-25 187
public class DoubleLinkedListDemo { public static void main(String[] args) { System.out.println("双向链表测试~"); //先创建节点 HeroNode2 hero1 = new HeroNode2(1, "宋江", "及时雨"); HeroNode2 hero2 = new HeroNode2(2, "卢俊义", "玉麒麟"); // .
java链表之--java双向链表的增删改查
basycai的博客
07-06 1536
单向链表只能从一个方向遍历链表，即只能查找结点的下一个结点（后继结点），而不能查找结点的上一个结点（前驱结点）。鉴于上述问题，引入了双向链表。由于双向循环链表包含双向链表的所有功能操作。因此，我们只讲述双向循环链表。 与单向链表不同，双向链表的结点构造如下图所示。即一个结点由三个部分组成，数据域DATA，左指针域pre和右指针域next。其中，数据域用来存放结点数据信息，左指针域用来指向前驱
Java 双向链表的增删改查
CalledJoker的博客
02-28 921
双向链表 简介 双向链表是基于单链表的基础上，每个节点中添加了一个指向上一个节点的指针。相对单链表而言，双向链表中的增删除改更为方便。例如，双链表可以便捷地进行自我删除的（单链表则需要借助辅助节点），届时只需要需要删除节点的相邻节点进行链接，便可实现自我删除。 功能实现 定义双链表节点 在单链表的基础上，添加一个存储上一个节点的指针。 class Node { int no; S...
JAVA实现双向链表增删功能详解
"这篇文章主要讲解了如何在JAVA中实现双向链表的增删功能，提供了相关的代码示例，包括创建链表、插入节点和删除节点的操作。" 在Java编程中，双向链表是一种数据结构，它允许在链表的两个方向上进行遍历。与单链表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

学习java的张三

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值