双链表(增，删，改)的各种操作

最新推荐文章于 2023-08-25 07:00:00 发布
最新推荐文章于 2023-08-25 07:00:00 发布
阅读量175 收藏
点赞数
分类专栏： 算法+数据结构 文章标签： 链表 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_19348175/article/details/108616428
版权

Node类

package com.doubluelinklist.test;

public class Node {

    private int id;  //编号
    private String name;  //姓名
    public Node pre; //前一个结点
    public Node next; //下一个结点
    
    public Node(int id,String name){
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Node getPre() {
        return pre;
    }

    public void setPre(Node pre) {
        this.pre = pre;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
    
    @Override
    public String toString() {
        return "id = " + this.getId() + "\t" + "name = " + this.getName();
    }   
}

DoubleLikeListSample类

package com.doubluelinklist.test;

import java.util.Stack;

public class DoubleLikeListSample {
    
    private int size;    //记录结点个数的变化
    private Node head = new Node(0,"");   //头结点，值为空，表示一个空结点
    
    /*
     * 1.结点的个数
     * 2.获得头结点
     * 3.判断结点是否存在，即加入的结点的编号是否已经存在
     * 4.插入：
     *     1.尾部加入
     *  2.头部加入
     *  3.指定位置插入
     * 5.删除
     *     1.指定位置删除
     *  2.指定编号删除
     *  3.指定姓名删除
     * 6.修改
     *  1.根据编号进行修改
     *  2.根据姓名进行修改
     * 7.根据编号进行排序
     * 8.两个有序双链表进行合并
     * 9.打印
     * 10.从尾到头打印单链表
     * 11.双向链表反转
     * 12.查找单链表中的倒数第k个结点
     */
    
    /*
     * 1.结点的个数
     */
    public int getSize(){
        return size;
    }

    /*
     * 2.获得头结点
     */
    public Node getHead(){
        return head;
    }
    
    /*
     * 3.判断结点是否已经存在
     */
    private boolean ifNodeNumberExists(Node node){
        Node tmp = head.next;
        for (int i = 1; i <= size; i++) {
            if(node.getId() == tmp.getId()){
                System.out.println("结点已经存在!!!");
                return true;
            }
            tmp = tmp.next;
        }
        return false;
    }
    
    /*
     * 4.1尾部加入
     */
    public void add(Node node){
        
        Node tmp = head;
        
        //判断结点是否存在
        if(ifNodeNumberExists(node)){
            return;
        }
        
        if(head.next == null){
            head.next = node;
            node.pre = head;
        }else{
            for (int i = 1; i <= size; i++) {
                tmp = tmp.next;
            }
            tmp.next = node;
            node.pre = tmp;
        }
        node.next = null;
        size++;
    }

    /*
     * 4.2头部加入
     */
    public void add2(Node node){
        //判断结点是否已经存在
        if(ifNodeNumberExists(node)){
            return;
        }
        
        if(head.next == null){
            head.next = node;
            node.pre = head;
            node.next = null;
        }else{
            node.next = head.next;
            head.next.pre = node;
            head.next = node;
            node.pre = head;
        }
        size++;
    }

    
    /*
     * 4.3指定位置插入
     */
    public void add3(int index,Node node){
        
        Node tmp = head;
        
        //判断结点是否存在
        if(ifNodeNumberExists(node)){
            return;
        }
        
        //判断指定的位置是否正确
        if(index < 1 || index > size + 1){  //设置为 > size + 1,表示可以在结尾加入
            System.out.println("插入的位置不正确!!!");
            return;
        }
        //得到指定位置的前一个结点
        for (int i = 1; i < index; i++) {
            tmp = tmp.next;
        }
        
        if(tmp.next != null){
            node.next = tmp.next;
            tmp.next.pre = node;
            tmp.next = node;
            node.pre = tmp;
        }else{
            //相当于在尾部加入了或者当只有头结点的时候
            node.pre = tmp;
            tmp.next = node;
            node.next = null;
        }
        size++;
    }
    
    /*
     * 5.1指定位置删除
     */
    public void indexDetleNode(int index){
        
        Node tmp = head;
        
        //判断是否为空链表
        if(head.next == null){
            System.out.println("空链表!!!");
            return;
        }
        //判断删除的位置是否正确
        if(index < 1 || index > size){
            System.out.println("删除的位置不正确！！！");
            return;
        }
        
        for (int i = 1; i <= index; i++) {
            tmp = tmp.next;
        }
        if(tmp.next != null){
            tmp.next.pre = tmp.pre;
            tmp.pre.next = tmp.next;
        }else{
            //相当于删除最后一个结点
            tmp.pre.next = null;
        }
        size--;
    }
    
    /*
     * 5.2指定编号删除
     */
    public void idDetleNode(int id){
        Node tmp = head;
        
        //判断链表是否为空链表
        if(head.next == null){
            System.out.println("空链表!!!");
            return;
        }
        
        for (int i = 1; i <= size; i++) {
            tmp = tmp.next;
            if(tmp.getId() == id){
                System.out.println("删除成功!!!");
                break;
            }
        }
        if(tmp.next != null){
            tmp.pre.next = tmp.next;
            tmp.next.pre = tmp.pre;
        }else{
            //相当于删除最后一个结点
            tmp.pre.next = null;
        }
        size--;
    }
    
    /*
     * 5.3指定姓名删除
     */
    public void nameDetleNode(String name){
        Node tmp = head;
        
        //判断指定姓名是否存在
        boolean ifNameExists = false;
        
        //判断是否为空链表
        if(head.next == null){
            System.out.println("空链表！！！");
            return;
        }
        
        //获得总结点数
        int len = size;
        for (int i = 1; i <= len; i++) {
            tmp = tmp.next;
            if(tmp.getName().equals(name)){
                if(tmp.next !=null){
                    tmp.next.pre = tmp.pre;
                    tmp.pre.next = tmp.next;
                }else {
                    tmp.pre.next = null;
                }
                ifNameExists = true;
                size--;
            }
        }
        if(!ifNameExists){
            System.out.println("要删除的姓名不存在!!!");
        }    
    }
    
    /*
     * 6.1根据编号进行修改
     */
    public void idUpdateNode(int id,Node node){
        
        Node tmp = head;
        boolean ifIdExists = false;
        
        //判断是否为空链表
        if(head.next == null){
            System.out.println("空链表!!!");
            return;
        }
        
        for (int i = 1; i <= size; i++) {
            tmp = tmp.next;
            if(tmp.getId() == id){
                //判断tmp是否为最后一个结点
                if(tmp.next != null){
                    node.next = tmp.next;
                    tmp.next.pre = node;
                }
                tmp.pre.next = node;
                node.pre = tmp.pre;
                ifIdExists = true;
                break;
            }
        }
        
        if(!ifIdExists){
            System.out.println("指定的编号不存在！！！");
        }
    }
    
    /*
     * 6.2根据姓名进行修改
     */
    public void nameUpdateNode(String srcName,String desName){
        
        Node tmp = head;
        boolean ifNameExists = false;
        
        //判断是否为空链表
        if(head.next == null){
            System.out.println("空链表!!!");
            return;
        }
        
        for (int i = 1; i <= size; i++) {
            tmp = tmp.next;
            if(tmp.getName().equals(srcName)){
                tmp.setName(desName);
                ifNameExists = true;
            }
        }
        if(!ifNameExists){
            System.out.println("姓名不存在！！！");
        }
        
    }
    
    /*
     * 7.根据编号进行排序
     */
    private void sortDoubleList(){
        Node newHead = head.next;
        for(int i = 0; i< size - 1; i++){
            //前一个元素指针
            Node preNode  = null;
            
            //当前处理的元素
            Node curNode = newHead;

            for(int j = 0; j < size - i - 1;j++){
                if(curNode.getId() > curNode.next.getId()){
                    //交换两个结点的引用，此时curNode的指针交换后会前移，只需要更新preNode指向即可
                    //缓存下下个结点
                    Node tmpNode = curNode.next.next;
                    curNode.next.next = curNode;
                    curNode.pre = curNode.next;
                
                    //前驱结点指向nextNode
                    if(preNode != null){
                        preNode.next = curNode.next;
                        curNode.next.pre = preNode;
                    }else{
                        //没有前驱结点证明结点为头结点，更新头结点
                        newHead = curNode.next;
                    }

                    //因为需要把preNode指向原来的下个结点，所以此处复制preNode,preNode后移
                    preNode = curNode.next;

                    //curNode指向下下个结点
                    curNode.next = tmpNode;

                //更新preNode & curNode指针
                }else{
                    preNode = curNode;
                    curNode = curNode.next;
                }
            }
        }    
         head.next = newHead;
    }
    
    /*
     * 8.两个有序单链表合并，并且有序
     */
    public static void combinNodeToNode(DoubleLikeListSample srcDoubleLink,DoubleLikeListSample desDoubleLink){
        Node srcHeadNode = srcDoubleLink.getHead();
        Node desHeadNode = desDoubleLink.getHead();
        
        for (int i = 1; i <= srcDoubleLink.getSize(); i++) {
            srcHeadNode = srcHeadNode.next;
        }
        srcHeadNode.next = desHeadNode.next;

        //排序
        srcDoubleLink.size = srcDoubleLink.getSize() + desDoubleLink.getSize();
        srcDoubleLink.sortDoubleList();
    }
    
    
    /*
     * 9.打印
     */
    public void print(){
        Node tmp = head;
        for (int i = 1; i <= size; i++) {
            tmp = tmp.next;
            System.out.println(tmp.toString());
        }
    }
    
    /*
     * 10.从尾到头打印单链表
     */
    public void endToStartPrint(){
        
        //判断是否为空链表
        if(head.next == null){
            System.out.println("空链表");
            return;
        }
        
        Node tmp = head;
        //使用栈---先进后出
        Stack<Node> stack = new Stack<>();
        for (int i = 1; i <= size; i++) {
            tmp = tmp.next;
            stack.push(tmp);
        }
        
        while (stack.size() > 0) {
            System.out.println(stack.pop().toString());    
        }
    }

    /*
     * 11.双向链表反转
     * 思想：总是以当前的结点为基准，与头结点进行链接
     */
    public void reverseDoubleList(){
        
        Node cur = head.next;            //当前结点
        Node next = null;                //下一个结点
        Node tmpHead = new Node(0,"");              //前一个指针
        
        //判断是否为空链表
        if(head.next == null){
            System.out.println("空链表！！！");
            return;
        }
        
        while (cur != null) {
            next = cur.next;
            cur.next = tmpHead.next;
            if(tmpHead.next != null){
                tmpHead.next.pre = cur;
            }
            cur.pre = tmpHead;
            tmpHead.next = cur;
            cur = next;
        }
        head = tmpHead;
    }
    
    /*
     * 12.查找单链表中的倒数第k个结点
     * 思路：就是顺查找第size -k + 1个结点
     */
    public Node findReciprocalKNode(int k){
        
        Node node = head;
        //判断k是否存在
        if(k < 1 || k > size){
            System.out.println("k输入不正确!!!");
            return null;
        }
        //判断是否为空链表
        if(head.next == null){
            System.out.println("空链表！！！");
            return null;
        }
        
        for (int i = 1; i <= size - k + 1; i++) {
            node = node.next;
        }
        return node;
    }
}

 

拽啥98K爆你哦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
双向链表的增删查改
weixin_69081438的博客
08-05 720
双向链表详解
双向链表的增删改查
03-16
本文将详细探讨如何实现双向链表的增、删、改、查操作，并通过C++编程语言的DLink.cpp文件进行实际应用。 首先，我们需要定义双向链表的节点结构。一个双向链表节点包含两个指针，分别指向其前一个节点和后一个节点...
双向链表的创建、增加和删除，销毁
changke的博客
06-10 5029
双向链表的创建，增加，删除和查看 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef struct student{ int id; char name[20]; struct student*pre,*next; }Student; Student* Create();//创建双向循环链表 void Pr...
双向链表实现增删改查的操作
佳佳鸽的博客
07-22 688
更多资料请点击：我的目录 本篇仅用于记录自己所学知识及应用，代码仍可优化，仅供参考，如果发现有错误的地方，尽管留言于我，谢谢! 此篇是单向循环链表实现增删改查的操作，其中： "增"包括在链尾、链中增加节点 "删"包括在链头、链中、链尾删除单个或多个节点 "改"包括在链头、链中、链尾更改单个或多个节点数值 "查"只是显示整个链表所有节点数值 #include <stdio.h> #include <stdlib.h> //设置节点 struct node { int data;
双向链表增删查改详解及完整代码
云小逸的博客
04-27 1940
1.链表的分类：2.双向链表的初始化：2.双向链表的打印3.双向链表的尾插： 4.双向链表的尾删 5.双向链表的头插：6.双向链表的头删：7.双向链表的查找 8.双向链表的中间插 9.双向链表的中间删除
C语言实例_双向链表增删改查
08-25 1531
双向链表（Doubly Linked List）是一种常见的数据结构，在单链表的基础上增加了向前遍历的功能。与单向链表不同，双向链表的每个节点除了包含指向下一个节点的指针外，还包含指向前一个节点的指针。
双链表的增删改查（c语言）
weixin_46323638的博客
03-28 1809
链表的分类 1：单向或双向 2：带头或不带头 3： 循环或非循环 此上所属种类便可组成八种不同的链表，但其实最常用的链表也就两种： 1：无头单项非循环链表 结构简单，不会单独用来存储数据，更偏向于作为其他数据结构的子结构。 2：带头双向循环链表 结构复杂，一般用来单独存储数据，一般实际使用的链表都是双向带头循环链表。 双向带头链表的实现： 双向循环链表的节点由三部分组成： 节点的创建： typedef int LTDataType; typ...
【数据结构】—— 双链表的增删改查
周小末天天开心的博客
11-25 1937
双链表基础以及案例演示
数据学习记录之双向链表基本操作增删查改
qq_44623261的博客
10-26 476
通常，双向链表同单链表一样，都仅有一个头指针。因此，双链表查找指定元素的实现同单链表类似，都是从表头依次遍历表中元素。双链表删除结点时，只需遍历链表找到要删除的结点，然后将该节点从表中摘除即可。将新数据元素添加到表头，只需要将该元素与表头元素建立双层逻辑关系即可。将 head 移至 temp，重新指向新的表头；新节点先与其直接后继节点建立双层逻辑关系；新节点的直接前驱节点与之建立双层逻辑关系；让新节点与最后一个节点进行双层逻辑关系；找到双链表中最后一个节点；
数据结构双向链表，实现增删改查
小钱努力学C的博客
07-19 1218
双向链表的描述以及存储结构定义，头插、尾插、头删、尾删以及双向链表逆置等基本操作的实现
C语言实例-双向链表增删改查
09-11
- 撤销和重做功能：在文本编辑器中，每次编辑操作的结果可以存储为双向链表的一个节点，通过指针链接，方便地在操作历史中进行撤销和重做。 - 浏览器导航历史：每个浏览页面作为一个节点，双向链表可以记录前进和...
C/C++链表增删改查排序操作
11-21
使用C++实现双向循环链表的增删改查排序等操作，可查看个人博客的【[数据结构和算法]C/C++双向循环链表实现(增删改查排序)】--链接https://blog.csdn.net/slimmm/article/details/84317806
用c语言实现链表增删改查
11-07
根据提供的文件信息，本文将详细解释如何使用C语言来实现链表的基本操作——增加、删除、修改和查询。这些操作是数据结构学习中的基础部分，对于理解更复杂的数据结构非常有帮助。 ### 一、链表简介 链表是一种...
C语言之航空信息查询系统-使用双向循环链表实现系统的增删改查操作
09-20
最后，为了测试和验证系统的正确性，需要编写单元测试用例，确保增删改查操作在各种情况下都能正确执行。此外，还要考虑异常处理，如处理不存在的航班号或无效的输入。 总结来说，这个项目展示了如何使用C语言和...
uuidgen.exe
08-29
Windows 8 SDK 此 SDK 于 2012 年 11 月发布，可用于创建适用于 Windows 8 或更早版本的 Windows 应用 () 使用 Web 技术、本机和托管代码;或使用本机或托管编程模型的桌面应用。
vb爬虫程序爬取音乐QZQ.zip
08-29
vb爬虫程序爬取音乐QZQ.zip
Matlab查看机器人地图
08-29
基于Matlab，读取txt数据，以figure窗口图片的形式查看机器人地图，并在其中显示机器人的位置和方向
72编辑距离.zip（算法）
最新发布
08-29
72编辑距离.zip（算法）
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值