Java链表的定义和使用

最新推荐文章于 2024-08-17 08:59:42 发布
最新推荐文章于 2024-08-17 08:59:42 发布
阅读量836 收藏
点赞数 1
文章标签： 链表 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43982741/article/details/126621428
版权

​ 链表的本质是一个动态的数组，它可以实现若干对象的存储。

链表使用简介

​ 传统对象数组的开发操作依赖于脚标（索引）的控制，如果想要实现内容的动态维护，那么难度太高了，而且复杂度攀升，对于一成不变的数据可以使用对象数组来实现，但是对于随时可能变化的数据，就需要一个 可以动态扩充的对象数组。

​ 链表的实质是利用引用的逻辑关系来实现类似于数组处理操作。

链表的结构：

在这里插入图片描述

数据增加

​ 在进行链表操作的过程中，为了避免转型的异常应该使用泛型，同时也应该设计一个链表的标准接口。同时具体实现该接口时还应该通过Node类做出节点的关系描述。

interface ILink<E>{//设置泛型避免安全隐患
    public void add(E e);
}
class LinkImpl<E> implements ILink<E>{
    //-------------Node保存数据的节点以及关系---------------
    private class Node{
		//没有设置set和get方法时因为外部类可以直接访问内部类的私有成员
        private E data;
        private Node next;
        public Node(E data){
            this.data=data;
        }
        public void addNode(Node newNode){//保存新的数据
            if(this.next==null){
                this.next=newNode;//保存当前节点
            }else{
                this.next.addNode(newNode);
            }

        }
    }
    //-------------以下为Link类中定义的成员-----------------
    private Node root;
    //-------------以下为Link类中定义的方法-----------------

    @Override
    public void add(E e) {
        if(e==null){
            return ;//数据为空
        }
        Node node = new Node(e);
        if(this.root==null){
            this.root=node;//第一个节点作为根节点
        }else {//根节点存在
            this.root.addNode(node);//将新节点保存到合适的位置

        }


    }
}
    public class JavaDemo {

        public static void main(String[] args) {

            LinkImpl<String> link = new LinkImpl<>();
            link.add("a");
            link.add("b");

        }
    }

获取集合个数

  1. ILink中增加

    public int size()

  2. LinkImpl实现子类中追加统计属性private int count

  3. add（）方法执行后this.count++;

空集合判断

  1. ILink中增加

    public boolean isEmpty()

  2. LinkImpl覆写 return this.count==0或者this.root=null

返回集合数据

​ 链表本身就属于一个动态对象数组，既然是一个数组，就应该可以把所有的数据以数组的形式返回来。

  1. ILink中增加

    public Object[] toArray();

  2. LinkImpl中追加两个属性

    private int foot;//描述的是数组操作的脚标
private Object[] returnDate;//返回的数据保存

  3. 在Node类中根据递归获取数据

    public void toArray(){//以数组形式返回数据
            LinkImpl.this.returnDate[LinkImpl.this.foot++]=this.data;
            if(this.next!=null){
                this.next.toArray();
            }

        }

  4. LinkImpl中覆写方法 获取数据时一定要先进行非空判断

    public Object[] toArray() {
        if(this.isEmpty()){
            return null;//没有数据
        }
        this.foot=0;//脚标清零
        this.returnDate=new Object[this.count];//根据已有的长度开辟数组
        //利用Node类进行递归数据获取
        this.root.toArray();
        return this.returnDate;

    }

根据索引取得数据

  1. 在ILink中增加

    public E get(int Index)

  2. 在Node 中增加根据索引获取数据的方法

     public E get(int index){
            if(LinkImpl.this.count==index){
                return this.data;
            }else{
                return this.next.get(index);
            }
        }

  3. LinkImpl中实现方法

    public E get(int index) {
        if(index>=this.count){
            return null;//索引应该在指定的范围内
        }
        this.foot=0;//重置索引的下标

        return  this.root.get(index);
    }

修改指定索引数据

  1. 在ILink中增加方法

    public void set(int index,E data);

  2. 在Node中增加方法

     public void addNode(Node newNode){
            if(this.next==null){
                this.next=newNode;//保存当前节点
            }else{
                this.next.addNode(newNode);
            }
        }

  3. LinkImpl中覆写方法

     public E get(int index) {
        if(index>=this.count){
            return null;//索引应该在指定的范围内
        }
        this.foot=0;//重置索引的下标

        return  this.root.get(index);
    }

判断数据是否存在

  1. ILink中增加方法

    public boolean contains(E data)

  2. 在Node类中进行判断

    public boolean contains(E data){
            if(data.equals(this.data)){ //!!!!!注意这里把data放在前面进行比较能够避免链表中有空数据而产生的错误
                return true;
            }else{
                if(this.next==null){
                    return false;
                }
                else{
                    return this.next.contains(data);
                }
            }
        }

  3. LinkImpl实现类

      public boolean contains(E data) {
        if(data==null){
            return false;//判断数据是否为空
        }
        return root.contains(data);
    }

数据删除

要注意删除的节点是root结点还是中间结点

  1. ILink中增加方法

    public void remove(E data)

  2. Node中增加方法

     public void remove(Node previous,E data){
            if(this.data.equals(data)){
                previous.next=this.next;//空出当前节点
            }
            else{
                if(this.next!=null){//有后续节点
                    this.next.remove(this,data);
                }
            }
        }

  3. LinkImpl中覆写方法

    public void remove(Node previous,E data){
            if(this.data.equals(data)){
                previous.next=this.next;//空出当前节点
            }
            else{
                if(this.next!=null){//有后续节点
                    this.next.remove(this,data);
                }
            }
        }

清空链表

  1. ILink中增加方法

    public void clean()

  2. LinkImpl覆写方法

    public void clean() {
        this.root=null;
        this.count=0;
    }

链表相关操作完整代码


interface ILink<E>{//设置泛型避免安全隐患
    public void add(E e);//增加数据
    public int size();//获取数据个数
    public boolean isEmpty();//集合空集合判断
    public Object[] toArray();//将集合元素以数组的形式返回
    public E get(int Index);//根据索引获取数据
    public void set(int index,E data);//修改指定索引数据
    public boolean contains(E data);//判断数据是否存在
    public void remove(E data);//删除数据
    public void clean();//清空链表
}
class LinkImpl<E> implements ILink<E>{
    //-------------Node保存数据的节点以及关系---------------
    private class Node{
        private E data;
        private Node next;
        public Node(E data){
            this.data=data;
        }
        //保存新的数据
        public void addNode(Node newNode){
            if(this.next==null){
                this.next=newNode;//保存当前节点
            }else{
                this.next.addNode(newNode);
            }
        }
        //以数组形式返回数据
        public void toArray(){
            LinkImpl.this.returnDate[LinkImpl.this.foot++]=this.data;
            if(this.next!=null){
                this.next.toArray();
            }
        }
        //根据索引获取数据
        public E get(int index){
            if(LinkImpl.this.foot++==index){
                return this.data;
            }else{
                return this.next.get(index);
            }
        }
        //更改指定索引数据
        public void setNode(int index,E data){
            if (LinkImpl.this.foot++==index){
                this.data=data;
            }
            else{
                this.next.setNode(index,data);
            }
        }
        //判断数据是否存在
        public boolean contains(E data){
            if(data.equals(this.data)){
                return true;
            }else{
                if(this.next==null){
                    return false;
                }
                else{
                    return this.next.contains(data);
                }
            }
        }
        //数据删除
        public void remove(Node previous,E data){
            if(this.data.equals(data)){
                previous.next=this.next;//空出当前节点
            }
            else{
                if(this.next!=null){//有后续节点
                    this.next.remove(this,data);
                }
            }
        }
    }
    //-------------以下为Link类中定义的成员-----------------
    private Node root;
    private int count;//保存数据个数
    private int foot;//描述的是数组操作的脚标
    private Object[] returnDate;//返回的数据保存
    //-------------以下为Link类中定义的方法-----------------

    @Override
    public void add(E e) {
        if(e==null){
            return ;//数据为空
        }
        Node node = new Node(e);
        if(this.root==null){
            this.root=node;//第一个节点作为根节点
        }else {//根节点存在
            this.root.addNode(node);//将新节点保存到合适的位置
        }
        this.count++;
    }

    @Override
    public int size() {
        return this.count;
    }

    @Override
    public boolean isEmpty() {
        return this.count==0;
    }

    @Override
    public Object[] toArray() {
        if(this.isEmpty()){
            return null;//没有数据
        }
        this.foot=0;//脚标清零
        this.returnDate=new Object[this.count];//根据已有的长度开辟数组
        //利用Node类进行递归数据获取
        this.root.toArray();
        return this.returnDate;
    }

    @Override
    public E get(int index) {
        if(index>=this.count){
            return null;//索引应该在指定的范围内
        }
        this.foot=0;//重置索引的下标
        return  this.root.get(index);
    }

    @Override
    public void set(int index, E data) {
        if(index>=this.count){//判断索引
            return;
        }
        this.foot=0;//重置
        this.root.setNode(index,data);
    }

    @Override
    public boolean contains(E data) {
        if(data==null){
            return false;//判断数据是否为空
        }
        return root.contains(data);
    }

    @Override
    public void remove(E data) {
        if(this.contains(data)){
            if(this.root.data.equals(data)){
                this.root=this.root.next;//根节点为要删除的节点
            }else{//删除的节点为中间节点
                this.root.remove(this.root,data);

            }
            this.count--;
        }
    }

    @Override
    public void clean() {
        this.root=null;
        this.count=0;
    }
}
    public class JavaDemo {

        public static void main(String[] args) {

            LinkImpl<String> link = new LinkImpl<>();
            //增加数组
            link.add("a");
            link.add("b");
            link.add("c");
            //链表的长度
            System.out.println(link.size());
            //返回数据
            Object[] result=link.toArray();
            for (Object obj : result) {
                System.out.println(obj);
            }
            //根据索引查询数据
            System.out.println(link.get(0));
            //根据索引修改数据
//            link.set(0,"hhahahha");
//            System.out.println(link.get(0));
            //判断数据是否存在
            System.out.println(link.contains("b"));
            //删除数据
            link.remove("b");
            System.out.println(link.get(1));
        }
    }

综合实战:宠物商城

​ 假设有一个宠物商店，里面可以出售各种宠物，要求可以实现宠物的上架处理、下架处理、也可以根据关键字查询出宠物的信息。

在这里插入图片描述

interface ILink<E>{//设置泛型避免安全隐患
    public void add(E e);//增加数据
    public int size();//获取数据个数
    public boolean isEmpty();//集合空集合判断
    public Object[] toArray();//将集合元素以数组的形式返回
    public E get(int Index);//根据索引获取数据
    public void set(int index,E data);//修改指定索引数据
    public boolean contains(E data);//判断数据是否存在
    public void remove(E data);//删除数据
    public void clean();//清空链表
}
class LinkImpl<E> implements ILink<E>{
    //-------------Node保存数据的节点以及关系---------------
    private class Node{
        private E data;
        private Node next;
        public Node(E data){
            this.data=data;
        }
        //保存新的数据
        public void addNode(Node newNode){
            if(this.next==null){
                this.next=newNode;//保存当前节点
            }else{
                this.next.addNode(newNode);
            }
        }
        //以数组形式返回数据
        public void toArray(){
            LinkImpl.this.returnDate[LinkImpl.this.foot++]=this.data;
            if(this.next!=null){
                this.next.toArray();
            }
        }
        //根据索引获取数据
        public E get(int index){
            if(LinkImpl.this.foot++==index){
                return this.data;
            }else{
                return this.next.get(index);
            }
        }
        //更改指定索引数据
        public void setNode(int index,E data){
            if (LinkImpl.this.foot++==index){
                this.data=data;
            }
            else{
                this.next.setNode(index,data);
            }
        }
        //判断数据是否存在
        public boolean contains(E data){
            if(data.equals(this.data)){
                return true;
            }else{
                if(this.next==null){
                    return false;
                }
                else{
                    return this.next.contains(data);
                }
            }
        }
        //数据删除
        public void remove(Node previous,E data){
            if(this.data.equals(data)){
                previous.next=this.next;//空出当前节点
            }
            else{
                if(this.next!=null){//有后续节点
                    this.next.remove(this,data);
                }
            }
        }
    }
    //-------------以下为Link类中定义的成员-----------------
    private Node root;
    private int count;//保存数据个数
    private int foot;//描述的是数组操作的脚标
    private Object[] returnDate;//返回的数据保存
    //-------------以下为Link类中定义的方法-----------------

    @Override
    public void add(E e) {
        if(e==null){
            return ;//数据为空
        }
        Node node = new Node(e);
        if(this.root==null){
            this.root=node;//第一个节点作为根节点
        }else {//根节点存在
            this.root.addNode(node);//将新节点保存到合适的位置
        }
        this.count++;
    }

    @Override
    public int size() {
        return this.count;
    }

    @Override
    public boolean isEmpty() {
        return this.count==0;
    }

    @Override
    public Object[] toArray() {
        if(this.isEmpty()){
            return null;//没有数据
        }
        this.foot=0;//脚标清零
        this.returnDate=new Object[this.count];//根据已有的长度开辟数组
        //利用Node类进行递归数据获取
        this.root.toArray();
        return this.returnDate;
    }

    @Override
    public E get(int index) {
        if(index>=this.count){
            return null;//索引应该在指定的范围内
        }
        this.foot=0;//重置索引的下标
        return  this.root.get(index);
    }

    @Override
    public void set(int index, E data) {
        if(index>=this.count){//判断索引
            return;
        }
        this.foot=0;//重置
        this.root.setNode(index,data);
    }

    @Override
    public boolean contains(E data) {
        if(data==null){
            return false;//判断数据是否为空
        }
        return root.contains(data);
    }

    @Override
    public void remove(E data) {
        if(this.contains(data)){
            if(this.root.data.equals(data)){
                this.root=this.root.next;//根节点为要删除的节点
            }else{//删除的节点为中间节点
                this.root.remove(this.root,data);

            }
            this.count--;
        }
    }

    @Override
    public void clean() {
        this.root=null;
        this.count=0;
    }
}
interface Pet{//1.定义宠物标准
    public String getName();//获得宠物名字
    public String getColor();//获得宠物颜色
}
class PetShop{//2.宠物商店 以宠物的标准为主
    private ILink<Pet> allPets=new LinkImpl<Pet>();//保存多个宠物
    //追加宠物 宠物上架
    public void add(Pet pet){
        this.allPets.add(pet);
    }
    //删除宠物 宠物下架
    public void delete(Pet pet){
        this.allPets.remove(pet);
    }
    //查询宠物
    public ILink<Pet> search (String keyword){
        ILink<Pet> searchResult = new LinkImpl<>();//保存查询的数据
        Object[] result = this.allPets.toArray();//查询所有的结果
        for (Object obj : result) {
            Pet pet=(Pet)obj;
            if(pet.getName().contains(keyword)||pet.getColor().contains(keyword)){
                searchResult.add(pet);//保存查询结果
            }
        }
        return searchResult;
    }
}
//3.根据宠物标准获得宠物信息
class Cat implements Pet{
    private String name;
    private String color;
    public Cat(String name,String color){
        this.name=name;
        this.color=color;
    }
    //覆写equals方法
    public boolean equals(Object obj){
        if(obj==null){
            return false;
        }
        if(!(obj instanceof Cat)){
            return false;
        }
        if(this==obj){
            return true;
        }
        Cat cat=(Cat)obj;
        return this.name.equals(cat.name)&&this.color.equals(cat.color);
    }
    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                '}';
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public String getColor() {
        return this.color;
    }
}
class Dog implements Pet{
    private String name;
    private String color;
    public Dog(String name,String color){
        this.name=name;
        this.color=color;
    }
    //覆写equals方法   该方法必须覆写，不覆写的话无法进行删除
    public boolean equals(Object obj){
        if(obj==null){
            return false;
        }
        if(!(obj instanceof Cat)){
            return false;
        }
        if(this==obj){
            return true;
        }
        Dog dog=(Dog)obj;
        return this.name.equals(dog.name)&&this.color.equals(dog.color);
    }
    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                '}';
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public String getColor() {
        return this.color;
    }
}
public class JavaDemo{
    public static void main(String[] args) {
        PetShop shop=new PetShop();
        shop.add(new Dog("黄狗","黄色"));
        shop.add(new Dog("黄猫","黄色"));
        Object[] result = shop.search("黄").toArray();
        for (Object obj : result) {
            System.out.println(obj);

        }
    }
}

​ 所有的程序开发都是以接口为标准进行的，这样在进行后期程序处理的时候就可以非常的灵活。只要符合标准的对象就都可以保存。

综合实战：超市购物车

​ 使用面向对象概念表示出下面的生活场景：小明去超时买东西，所有买到的东西都放在购物车中，最后到收银台一起结账。

在这里插入图片描述

interface ILink<E>{...}
classs LinkImpl<E> implements ILink<E>{...}//代码同上
interface IGoods{//1.定义商品标准
    public String getName();
    public double getPrice();
}
interface IShopCar{//2.定义购物车标准
    public void add(IGoods good);
    public void delete(IGoods good);
    public Object[] getAll();

}
class ShopCarImpl implements IShopCar{//3.实现购物车
    private ILink<IGoods> allGoods=new LinkImpl<IGoods>();
    @Override
    public void add(IGoods good) {
            this.allGoods.add(good);
    }

    @Override
    public void delete(IGoods good) {
        this.allGoods.remove(good);
    }

    @Override
    public Object[] getAll() {
        return this.allGoods.toArray()  ;
    }
}

//4.收银台
class Crashier{
    private IShopCar shopCar;
    public Crashier(IShopCar shopCar){
        this.shopCar=shopCar;
    }
    public double getAllPrice(){//获得总价
        double sum=0.0;
        Object[] all = this.shopCar.getAll();
        for (Object obj : all) {
            IGoods good=(IGoods) obj;
            sum+=good.getPrice();
        }
        return sum;
    }
    public int getAllCount(){//获得总数
        return this.shopCar.getAll().length;
    }

}
//5.实现商品
class Book implements IGoods{
    private String name;
    private double price;
    public Book(String name,double price){
        this.name=name;
        this.price=price;
    }
    //覆写equals方法
    public boolean equals(Object obj){
        if(obj==null){
            return false;
        }
        if(!(obj instanceof Book)){
            return false;
        }
        if(this==obj){
            return true;
        }
        Book book=(Book)obj;
        return this.name.equals(book.name)&&this.price==book.price;
    }
    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", price='" + price + '\'' +
                '}';
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public double getPrice() {
        return this.price;
    }
}

public class JavaDemo{
    public static void main(String[] args) {
        IShopCar shopCar = new ShopCarImpl();
        shopCar.add(new Book("book1",999));
        shopCar.add(new Book("book2",99));
        Crashier crashier = new Crashier(shopCar);
        Object[] all = shopCar.getAll();
        for (Object obj : all) {
            System.out.println((IGoods)obj);
        }

    }
}
forwardMing
关注
怎么使用java初始化链表_Java链表基本操作和Java.util.ArrayList
weixin_42467518的博客
02-28 1360
Java链表基本操作和Java.util.ArrayList今天做了一道《剑指offer》上的一道编程题“从尾到头打印链表”，具体要求如下：输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。一开始我想的是通过两次遍历链表，第一次遍历得到链表元素的个数count。然后定义一个ArrayList 变量，由于ArrayList是动态数组，不能在未初始化的情况下对任意位置进行插入指定的值。所...
Java面向对象编程-链表
qq_50743381的博客
05-06 1091
链表 1、链表的基本定义 链表的本质是一个动态的对象数组 在实际的开发之中对象数组是一项非常实用的技术，并且利用其可以描述出“多”方的概念，例如：一个人有多少本数，则在人的类里面一定要提供有一个对象数组保存书的信息，但是传统的对象数组依赖于数组的概念，所以数组里面最大的缺点在于：长度是固定的，正是因为如此所以在实际开发之中，传统数组应用是非常有限的（数组的接受以及循环处理），但是如果要想进行灵活的数据保存，那么就必须自己来实际结构 传统对象数组的开发操作依赖于脚标（索引）的控制，如果要想实现内容的动态维护，
Java“链表“——数据结构（这一篇就够了）
最新发布
m0_73158088的博客
08-17 1399
本篇对数据结构中的"链表"进行详细的讲解 本期会分成一下五部分进行讲解： 1.链表的概念 2.链表的种类 3.链表的实现方法 4.代码实现链表 5.链表的常见使用场景
java定义链表_Java数据结构之简单链表的定义与实现方法示例
weixin_29109261的博客
02-12 283
本文实例讲述了Java数据结构之简单链表的定义与实现方法。分享给大家供大家参考，具体如下：一、概述：1、原理：只有一个数据项(链接点Link)，每个数据插入时都是对第一个数据的引用。2、插入数据说明：当链表没有数据时，插入的值就是第一个数据，如果链表里有数据，就把当前的数据的next指针指向第一个数据。3、插入数据图：4、特点：先进后出5、实现功能：数据插入，指定位置插入，显示，查询，删除等6、删...
Java数据结构-认识链表
weixin_55752048的博客
01-28 3853
一.链表的概念及结构 1.链表的概念 链表是一种物理存储结构上非连续的存储结构。数据元素中的逻辑顺序是通过链表中的引用链接次序实现的 2.链表的分类
数据结构-链表（Java实现）
cj13106811623的博客
02-27 1416
链表又叫做线性表的链式存储，有一个个节点组成，类似生活中火车车厢一节一节串在一起。链表是一种的存储结构，数据元素的是通过链表的次序实现的。链表中的每个结点包含两部分：一个叫存储数据元素信息；另一个叫存储下一个结点的存储地址。
Java模拟单链表和双端链表数据结构的实例讲解
09-02
在Java中，我们可以创建一个类`Link`来表示链表的节点，该类通常包含一个数据域（如`data`）和一个指向下一个节点的引用（如`next`）。下面是一个简单的`Link`类的定义： ```java public class Link<T> { private ...
Java数据结构之简单链表的定义与实现方法示例
08-29
Java数据结构之简单链表的定义与实现方法示例 Java数据结构之简单链表是指一种链式存储结构，通过节点之间的链接来存储数据。这种数据结构的特点是先进后出，即最后插入的数据将被最先删除。 定义 在Java中，简单...
Java基础——链表
qq_52519008的博客
06-14 3294
　　单向链表只有一个指针域，在整个节点中数据域用来存储数据元素，指针域用于指向下一个具有相同结构的节点。 单向链表中，每个节点的数据域都是通过一个 Object 类的对象引用来指向数据元素的，与数组类似，单向链表中的节点也具有一个线性次序，即如果节点 a1 的 next 引用指向节点 a2，则 a1 就是 a2 的直接前驱，a2 是 a1 的直接后续。只能通过前驱节点找到后续节点，而无法从后续节点找到前驱节点。 特点： 　　数据元素的存储对应的是不连续的存储空间，每个存储结点对应一个需要存储的数据元素。每个
java链表含义,Java数据结构----链表
weixin_27298377的博客
03-11 386
用C实现链表是使用了指针，但是JAVA并没有指针这个名词。指针究竟是什么？链表的指针又代表了什么含义？这就是解题的具体思路。在java中，用引用来代替指针的功能，不过区别：就是指针在指向目标地址的同时本身也占有内存，而引用就是单纯的指向一块内存。链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成，结...
Java数据结构中的链表
m0_56186047的博客
12-17 412
链表是一种常见的数据结构，它由一组节点组成，每个节点都包含一个数据元素和一个指向下一个节点的指针。与数组相比，链表具有动态性，可以在运行时灵活地添加、删除和修改节点。本文将介绍链表的来源、使用场景，编写一个链表的示例，并给出使用链表的注意事项。// 头节点// 节点类T data;// 节点数据// 下一个节点链表是一种常见的动态数据结构，通过节点之间的指针关系实现元素的添加、删除和修改。它的灵活性使得它在队列、栈等数据结构的实现以及存储大量数据的场景中发挥重要作用。
java定义链表_Java实现单链表
weixin_33124479的博客
02-12 1106
一、分析单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点由元素和指针构成。在Java中，我们可以将单链表定义成一个类，单链表的基本操作即是类的方法，而结点就是一个个实例化的对象，每个对象中都有“元素值”和“下一结点地址”两个属性。在“下一结点地址”属性中存储的是下一个对象的引用，这样，一个个对象连在一起就成为了单链表。单链表有以...
链表：Java中链表定义--单向链表与双向链表
扶苏葳蕤
04-29 559
很多初学的小伙伴都不知道如何在Java中自定义链表，今天它来了，Java的核心就是面向对象编程，因此我们可以把链表看成一个对象。 单向链表定义 我们可以定义一个类，ListNode，属性next（下一节点的引用），value（存储当前节点的值）单链表定义如下： class ListNode { int val; ListNode next;//引用指向下一节点 Li...
Java面向对象编程 链表的定义及使用
Lefroid的博客
11-07 531
链表的定义及使用 链表 链表的本质是一个动态的对象数组，它可以实现若干个对象的存储。 链表的基本定义 在实际的开发之中对象数组是一项非常实用的技术，并且利用其可以描述出“多”方的概念，例如:一个人有多本书,则在人的类里面一定要提供有一个对象数组保存书的信息，但是传统的对象数组依赖于数组的的概念，所以数组里面最大的缺点在于：长度是固定的，正是因为如此所以在实际的开发之中，传统的数组应用是非常有限的（数组的接收以及循环处理)，但是如果要想进行灵活的数据保存，那么就必须自己来实现结构。 链表结构：
Java链表
zhanghaha0的博客
09-19 268
链表代码
01 29Java中级之链表的定义及使用
weixin_43762330的博客
03-05 169
文章目录1 链表实现简介2 数据增加3 获取集合个数4 空集合判断5 返回集合数据6 根据索引取得数据7 链表（修改指定索引数据）8 链表（判断数据是否存在）9 链表（数据删除）10 链表（清空链表）11 综合实战（宠物商店）12 综合实战（超市购物车） 1 链表实现简介 2 数据增加 3 获取集合个数 4 空集合判断 5 返回集合数据 6 根据索引取得数据 7 链表（修改指定索引数据） 8 链表...
Java自定义链表
lilei的博客
06-18 1091
public class LinkedList<E> { private class Node{ public E e; public Node next; public Node(E e , Node next){ this.e = e; this.next = next; ...
Java实现单链表与双向链表详解及代码示例
本篇文章主要介绍了如何使用Java编程语言实现单链表和双向链表的数据结构。单链表是一种线性数据结构，每个节点包含一个数据元素和一个指向下一个节点的引用，而双向链表则在单链表的基础上增加了指向前一个节点的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值