简单实现链表增删改查

最新推荐文章于 2024-04-30 17:28:01 发布
最新推荐文章于 2024-04-30 17:28:01 发布
阅读量1k 收藏
点赞数 2
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aierken2/article/details/124020782
版权

学习目标：

  • 简单实现链表增删改查

学习内容：

  1. 外部类和内部类
  2. 封装方法
  3. 其他类使用内部类私有方法
  4. 递归算法

代码块：

class test{
  public static void main(String[] args){
    Nodelianbiao nlb = new Nodelianbiao();
        nlb.add(10);
        nlb.add(9);
        nlb.add(8);
        nlb.add(7);		//添加数据
        nlb.print();	//输出所有数据
        nlb.del(9);		//删除元素为9的数据
        nlb.print();	
        System.out.println(nlb.find(11));	//查询元素是否存在
        nlb.update(7,8);	//修改元素（7改成8）
        nlb.print();		
        nlb.insert(3,11);	//插入元素（在小标为3的位置插入元素为11的数据）
        nlb.print();
  }
}

class Nodelianbiao{
    private Node root;      //根节点
    private int countindex = 0;
    public void add(int data){
        if(root == null){
            root = new Node(data);
            countindex++;
        }else{
            root.addNode(data);
        }
    }
    public void del(int data){
        if(root.getData() == data){
            root = root.next;
            countindex--;
        }else{
            root.delNode(data);
        }
    }
    public void print(){
        if(root!=null){
            System.out.print(root.data+"=>");
            root.printNode();
            System.out.println();
        }
    }
    public boolean find(int data){
        if (root.getData() == data) return true;
        else{
            if (root.findNode(data)) return true;
        }
        return false;
    }
    public void update(int olddata,int newdata){
        if(find(olddata)){
            if(root.getData() == olddata){
                root.setData(newdata);
            }
            else{
                root.updateNode(olddata,newdata);
            }
        }
        else{
            System.out.println("无此数据");
        }
    }
    public void insert(int index,int data){
        if(this.countindex>=index){
            int temp = 0;
            if(index == 0){
                Node root1 = new Node(data);
                root1.next = root;
                root = root1;
            }
            else{
                temp++;
                root.insertNode(index,data,temp);
            }
        }
    }

    private class Node{
        private int data;
        private Node next;

        private Node(int data){
            this.data = data;
        }
        private void setData(int data){
            this.data = data;
        }
        private int getData(){
            return data;
        }
        //添加节点
        private void addNode(int data){
            if(this.next == null){
                this.next = new Node(data);
                countindex++;
            }else{
                this.next.addNode(data);
            }
        }
        //删除节点
        private void delNode(int data){
            if(this.next!=null){
                if(this.next.data == data){
                    this.next = this.next.next;
                    countindex--;
                }
                else{
                    this.next.delNode(data);
                }
            }
        }
        //输出所有节点
        private void printNode(){
            if(this.next!=null){
                System.out.print(this.next.data+"=>");
                this.next.printNode();
            }
        }
        //查找节点是否存在
        private boolean findNode(int data){
            if (this.next!=null) {
                if (this.next.data == data) return true;
                else if (this.next.findNode(data)) return true;
            }
            return false;
        }
        //修改节点
        private void updateNode(int olddata,int newdata){
            if(this.next.data == olddata){
                this.next.setData(newdata);
            }
            else{
                this.next.updateNode(olddata,newdata);
            }
        }
        //插入节点
        private void insertNode(int index,int data,int temp){
            if(index == temp){
                Node count = new Node(data);
                count.next = this.next;
                next = count;
            }else{
                temp++;
                this.next.insertNode(index,data,temp);
            }
        }
    }
}

代码解析：

编写外部类和内部类

首先我们编写一个外部类叫Nodewaibulei

class Nodewaibulei{

}

在外部类中再编写一个私有的内部类叫Node

class Nodewaibulei{
	private class Node{
	
	}
}

在内部类定义一个私有的int类型数据data
再定义一个私有的内部类类型的数据next
给内部类定义构造方法
给data编写get，set方法

private class Node{
	private int data;
	private Node next;
	
	private Node(int data){
		this.data = data;
	}
	private void setData(int data){
		this.data = data;
	}
	private int getData(){
		return data;
	}
}

在内部类再编写六个方法，分别是：
addNode() \t添加
delNode() 删除
findNode() 查
printNode() 输出所有
updateNode() 修改
insertNode() 插入

private class Node{
	private int data;
	private Node next;

	private void setData(int data){
		this.data = data;
	}
	private int getData(){
		return data;
	}
	private void addNode(int data){		//添加数据

	}
	private void delNode(int data){			//删除数据
	
	}
	private boolean findNode(int date){		//查询数据（返回boolean)
		return false;
	}
	private void printNode(){		//输出所有数据
	
	}
	private void updateNode(int olddate,int newdata){		//修改数据，olddata为原数据，newdata新数据

	}
	private void insertNode(int index,int data){	//插入数据，index插入索引位置

	}
}

内部类私有方法虽然外部类可以使用，但其他类中无法调用，所以在外部类中编写共有的方法
外部类中：

class Nodewaibulei{
	public void add(int data){

	}
	public void del(int data){

	}
	public boolean find(int data){
		return false;
	}
	public void print(){

	}
	public void update(int olddate,int newdata){

	}
	public void insert(int index,int data){

	}
}

在外部类中定义内部类类型的数据，这也叫根节点。

class Nodewaibulei{
	private Node root;
}

添加数据

咱们回到main方法中
先创建一个Nodewaibulei类
再用add方法添加一个数据

public static void main(String[] args){
	Nodewaibulei nwbl = new Nodewaibulei();
	nwbl.add(10);
	
}

此时add方法接收到一个参数，我们要判断链表根节点是否为null，

  1. 如果是，创建根节点并把参数直接赋给根节点
  2. 如果否，调用内部类中的addNode()方法
public void add(int data){
	if(root == null){
		root = new Node(data);
	}else{
		root.addNode(data);
	}
}

		咱们回到内部类中的addNode()方法中，

判断内部类中的next是否为空

  • 如果是，新建一个内部类，data数据赋给新类，并把新类赋给next
  • 如果否，调用next中的addNode()方法，并把参数递过去。
private void addNode(int data){
    if(this.next == null){
        this.next = new Node(data);
    }else{
        this.next.addNode(data);
    }
}

这里有点绕，next本身就是一个内部类类型的数据，每次创建一个新的内部类时，它都会定义一个空的内部类对象next。也就是说每添加一个数据，就会多出一个空的next，为下一次添加新值准备。

比如咱们添加第一个数据时，在外部类中给内部类类型的root 创建一个新的内部类，

public void add(int data){
	if(root == null){
		root = new Node(data);
	}else{
		root.addNode(data);
	}
}

因为是第一个数据，所以root为空，当我们给root创建新的内部类时，内部类就定义了两个参数，一个是int类型的数据data，另一个是内部类类型的next。
data是有构造方法，定义类时就得提供参数，而next就不需要，所以定义一个新的内部类，就得空出一个next；
那什么时候用next？就是又要新添加数据时，new一个新的内部类，并把它赋给next。当然了，new出来的内部类又会空出一个next;

	回过头来看一下内部类中的add方法，

判断next是否为空：

  • 如果是，新建一个内部类，data数据赋给新类，并把新类赋给next
  • 如果否，调用next中的addNode()方法，并把参数递过去。

添加数据完成。

private void addNode(int data){
    if(this.next == null){
        this.next = new Node(data);
    }else{
        this.next.addNode(data);
    }
}

输出所有数据

		我们回到main方法中

咱们通过add方法多加几个数据，然后通过print方法输出所有数据。

public static void main(String[] args){
	Nodewaibulei nwbl = new Nodewaibulei();
	nwbl.add(10);
	nwbl.add(9);
	nwbl.add(11);
	nwbl.add(13);
	nwbl.add(15);
	nwbl.print();	//输出所有数据
}

		我们回到外部类print方法中。

首先要判断根节点是否为空，也就是第一个数字是否为空

  • 如果否，就输出根节点（说明根节点有数据）
  • 调用内部类中的printNode方法（继续输出其他节点上的数据）
public void print(){
    if(root!=null){
        System.out.print(root.data+"=>");
        root.printNode();
        System.out.println();
    }
}

		内部类中的printNode方法：

判断内部类中的next是否为空

  • 如果否，输出该节点数据（说明该节点存在）
  • 继续调用next中的printNode方法，直到nex为空。

输出所有数据完成。

private void printNode(){
    if(this.next!=null){
        System.out.print(this.next.data+"=>");
        this.next.printNode();
    }
}

删除数据

		我们回到main方法中

通过del方法删除数据

public static void main(String[] args){
	Nodewaibulei nwbl = new Nodewaibulei();
	nwbl.add(10);
	nwbl.add(9);
	nwbl.add(11);
	nwbl.add(13);
	nwbl.add(15);
	nwbl.del(11);		//删除元素为11的数据。
}

		我们回到外部类del方法中。

判断参数是否跟根节点相同

  • 如果是，把第二个节点赋给第一个节点（根节点被覆盖，从而达到删除效果）
  • 如果否，调用内部类中delNode方法，并把参数传递过去。
public void del(int data){
    if(root.getData() == data){
        root = root.next;
        countindex--;
    }else{
        root.delNode(data);
    }
}

		内部类中的delNode方法

判断next是否为空，
如果否，再判断数据data跟参数data是否相等。

  • 如果是，把数据next中的下一个next赋给现在的next。
  • 如果否，继续调用next中的delNode()方法，并把参数传递过去。

删除数据完成。

private void delNode(int data){
    if(this.next!=null){
        if(this.next.data == data){
            this.next = this.next.next;
        }
        else{
            this.next.delNode(data);
        }
    }
}

其他几个方法也同样利用递归算法实现查找，插入，修改等操作。

aierken2
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
基于C语言实现unordered-map的增删改查（源码）
03-21
使用链表实现了哈希表，定义了节点结构体 struct Node 和哈希表结构体 struct Hashtable。 实现了创建哈希表的函数 createHashtable，哈希函数 hash，插入键值对的函数 insert，查找键对应值的函数 get，删除指定键...
JDBC实现增删改查（含所有代码）
m0_57448314的博客
10-18 2972
JDBC完整版实现增删改查，这里包含增删改查所有代码，还有对于每行代码详细的注释。
数据结构：链表实现增删查改的基本功能【内含详细代码，建议收藏】
weixin_53472920的博客
09-15 2480
hello，大家好，这期文章继续用来更新数据结构方面的知识——链表。。这期文章依旧是对之前的文章[数据结构：红玫瑰与白玫瑰之争](https://blog.csdn.net/weixin_53472920/article/details/115463675)的补充，希望对大家有所帮助。我们在之前的文章中已经介绍过顺序表，链表和顺序表有很大的不同，相对于顺序表，链表无疑是更加灵活的。顺序表在实现过程中头部插入数据时需要挪动数据，在增容的过程中也会消耗性能，并且以倍数的方式增容也会造成空间的浪费。链表 ...
数据结构：单链表增、删、查、改的实现
元清的博客
05-11 3141
链表是一种、非顺序的存储结构，数据元素的是通过链表中的次序实现的。
【数据结构】链表-增删查改
weixin_44930735的博客
07-31 2322
链表是一种物理结构上非连续、非顺序的存储结构，数据元素的逻辑是通过链表中的指针链接次序实现的。 链表创建完成后不需要初始化，链表过于简单，就是由一个个的结构体通过指针域串起来的，在不存储数据的时候，可以没有任何节点，即没有结构体，在主函数中将指向结构体的指针置为空就行了。......
实现简单的增删改查（Asp.Net MVC+Layui）
zeron01的博客
10-27 6540
实现简单的增删改查（Asp.Net MVC+Layui）
C语言-链表(操作：增、删、改、查)
qq_27751235的博客
07-19 833
链表是一种物理存储上非连续，数据元素的逻辑顺序通过链表中的指针链接次序，实现的一种线性存储结构。链表的操作：增、删、改、查。
简单的增删改查
墨染的博客
10-18 589
增删改查
数据库 增删查改
GoodManS的CSDN
03-08 380
增删查改的一些基础
【数据结构】链表——增、删、查、改
2301_77003537的博客
07-31 1641
本文结束了链表的概念与使用，用图解的方式阐明了链表的增删查改，让我们一起来学习链表吧。
数据结构之链表，实现单链表的增删查改
jolly0514的博客
04-07 1091
本文主要介绍了链表，以及对链表的操作：增删查改等，如有错误，敬请指正。
电话号码管理项目功能包括简易菜单、单链表、包括增删改查等基本操作 链表插入采用尾插法
03-05
电话号码管理项目是一个简单的软件，可以用于存储和管理用户的电话号码、姓名和其他相关信息。该项目通常会涉及一些常见的...在代码实现中，可以使用C语言来实现链表数据结构，并编写对应的函数来实现操作链表的功能。
C语言链表实现图书管理系统
01-01
之前参照网上的资料用链表实现了图书管理系统，包括简单的增删改查功能以及借书还书功能，我是VC6.0下写的一个控制台程序，格式参照的网上的。在动手编码之前，你需要理清自己的思路。首先，需要确定图书馆里系统中...
用C语言实现简单的员工管理系统(新建、增、删、改、查、排序)
06-01
问题描述：每个员工的信息包括：编号、姓名、性别、出生年月、学历、职务、电话、住址等。系统能够完成员工信息的查询、更新、插入、删除、排序等功能。 基本要求：排序：按不同关键字，对所有员工的信息进行排序；...
C语言实现通讯录功能
08-28
主要为大家详细介绍了C语言实现通讯录功能，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 919
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 875
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
链表刷题集
最新发布
yajunjiao的专栏
04-30 275
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
Lambda表达式特点
weixin_57763462的博客
04-24 791
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
C语言实现结构体动态链表的增删改查
04-02
C语言可以通过结构体和指针来实现动态链表的增删改查操作。下面是一个简单的示例代码： 首先，定义一个结构体表示链表的节点： ```c typedef struct Node { int data; // 节点数据 struct Node* next; // 指向下一个节点的指针 } Node; ``` 接下来，定义一些基本的操作函数： 1. 创建一个新节点： ```c Node* createNode(int data) { Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = data; newNode->next = NULL; return newNode; } ``` 2. 在链表末尾插入一个节点： ```c void insertNode(Node** head, int data) { Node* newNode = createNode(data); if (*head == NULL) { *head = newNode; } else { Node* current = *head; while (current->next != NULL) { current = current->next; } current->next = newNode; } } ``` 3. 删除指定数值的节点： ```c void deleteNode(Node** head, int data) { if (*head == NULL) { return; } Node* current = *head; Node* prev = NULL; while (current != NULL && current->data != data) { prev = current; current = current->next; } if (current == NULL) { return; } if (prev == NULL) { *head = current->next; } else { prev->next = current->next; } free(current); } ``` 4. 修改指定数值的节点： ```c void modifyNode(Node* head, int oldData, int newData) { Node* current = head; while (current != NULL && current->data != oldData) { current = current->next; } if (current != NULL) { current->data = newData; } } ``` 5. 查找指定数值的节点： ```c Node* searchNode(Node* head, int data) { Node* current = head; while (current != NULL && current->data != data) { current = current->next; } return current; } ``` 使用这些函数，你可以实现对动态链表的增删改查操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值