2021-09-04

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

LinkedList实现类

ArrayList:数据结构：

物理结构：紧密结构

逻辑结构：线性表（数组）

LinkedList数据结构：

物理结构：跳转结构

逻辑结构：线性表（链表）

（链表：双向链表）

import java.util.LinkedList;
public class LinkedList_01 {
    public static void main(String[] args) {
        LinkedList<String> ls1 = new LinkedList<>();
//        可以添加重复元素
        ls1.add("aaa");
        ls1.add("bbb");
        ls1.add("ccc");
        ls1.add("eee");
        ls1.add("fff");
        ls1.add("bbb");
//        System.out.println(ls1);

        ls1.addFirst("jj");
        ls1.addLast("lll");
//        添加元素在尾端
        ls1.offer("zh");
//        System.out.println(ls1);

        ls1.offerFirst("rt");
        ls1.offerLast("pp");
        System.out.println(ls1);
//        删除元素首段
//        ls1.poll();
//        System.out.println(ls1);
//        System.out.println(ls1.pollFirst());//删除首元素
//        System.out.println(ls1.pollLast());//删除尾元素
//        System.out.println(ls1.removeFirst());//删除首元素
//        System.out.println(ls1.removeLast());//删除末尾元素


//        System.out.println(ls1);
//        ls1.clear();

//        System.out.println(ls1.pollFirst());元素为空会显示null
//        System.out.println(ls1.removeFirst());元素为空会报错
        System.out.println("-------------------------------------");
//        普通for循环
       /* for (int i = 0; i < ls1.size(); i++) {
            System.out.println(ls1.get(i));
        }*/
//        增强for循环
        /*for (String s : ls1) {
            System.out.println(s);
        }*/
//        迭代器
       /* Iterator it = ls1.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }*/
//        其他,节省内存
        /*for (Iterator it = ls1.iterator();it.hasNext();) {
            System.out.println(it.next());
        }*/
        
    }
}

链表

//节点类
public class Node {
//    三个属性
//    上一个元素的地址
    private Node pre;
//    当前存入的元素
    private Object obj;
//    下一个元素地址
    private Node next;

    public Node getPre() {
        return pre;
    }

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

    public Object getObj() {
        return obj;
    }

    public void setObj(Object obj) {
        this.obj = obj;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

    @Override
    public String toString() {
        return "Node{" +
                "pre=" + pre +
                ", obj=" + obj +
                ", next=" + next +
                '}';
    }

}
public class MyLikedList {
//    链首节点
    Node first;
//    链尾节点
    Node last;
//    计数器
    int count = 0;

    public MyLikedList() {

    }
    public void add(Object o){//证明你添加的元素是第一个节点
        if (first == null){
//            将添加的元素封装为一个Node对象
            Node n = new Node();
            n.setPre(null);
            n.setObj(o);
            n.setNext(null);
//            当前链表中的第一个节点为n
            first = n;
//            当前链表中最后一个节点为n
            last = n;

        }else{
//            证明已经不是链表中的第一个节点
//            将添加的元素封装为一个Node对象
            Node n = new Node();
            n.setPre(last);//n的上一个节点一定是当前链中的最后一个节点
            n.setObj(o);
            n.setNext(null);
//            当前链中的最后一个节点的下一个元素一定指向n
            last.setNext(n);
//            将最后一个节点变为n
            last = n;

        }
//        链中元素数量加1
        count++;
    }
    public int  getSize(){
        return count;
    }
    public Object get(int index){
//        获取链表的头元素
        Node n = first;
//        通过next得到想要的元素
        for (int i = 0; i < index; i++) {
            n = n.getNext();
        }
        return n.getObj();
    }
}
class TestMyLikedList{
    public static void main(String[] args) {
        MyLikedList m1 = new MyLikedList();
        m1.add("aaa");
        m1.add("bbb");
        m1.add("ccc");
//        System.out.println(m1.count);
        System.out.println(m1.get(2));


    }
}

加入字符串操作

public class LinkedList_02 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        list.add("dd");
        list.add("ee");
//        在"cc"后面加一个字符串"kk"
        Iterator it = list.iterator();
        while (it.hasNext()){
            if ("cc".equals(it.next())){
                list.add("kk");
            }
        }

    }
}
//ArrayList与it同时对集合进行操作导致报错
//报错，并发修改异常
Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
	at java.util.ArrayList$Itr.next(ArrayList.java:859)
	at Otherport.LinkedList_02.main(LinkedList_02.java:23)

import java.util.ArrayList;
import java.util.ListIterator;
import java.util.Scanner;

public class LinkedList_02 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        list.add("dd");
        list.add("ee");

//        在"cc"之后添加一个字符串为"kk"
        ListIterator<String> it = list.listIterator();
        while (it.hasNext()){
//            System.out.println(it.next());
            if ("cc".equals(it.next())){
                it.add("kk");
            }
        }
//        System.out.println(it.hasNext());
//        System.out.println(it.previous());
//
//        System.out.println(list);
//        逆向遍历
        while (it.hasPrevious()){
            System.out.println(it.previous());
        }
        Scanner input = new Scanner(System.in);
        String k = input.nextLine();


    }
}

List 接口不唯一，有序

Set (这个无序是相对于List接口而言，无序不等于随机) 唯一，无序

没有更索引相关的方法
在这里插入图片描述

HashSet

import java.util.HashSet;

public class TestInteger {
    public static void main(String[] args) {
//        创建一个HashSet集合
        HashSet<Integer> hs = new HashSet<>();
        hs.add(19);
        hs.add(32);
        hs.add(19);
        hs.add(35);
        hs.add(19);
        hs.add(176);
        System.out.println(hs.size());
        System.out.println(hs);

    }
}
// 结果
4
[32, 176, 19, 35]

public class Student_01 {
    private int age;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Student_01{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    public Student_01(int age, String name) {
        this.age = age;
        this.name = name;
    }
}

public class TestStudent_01 {
    public static void main(String[] args) {
//        上面自定义的类型不满足 唯一,无序的特点
        HashSet<Student_01> hs = new HashSet<>();
        hs.add(new Student_01(19,"lili"));
        hs.add(new Student_01(20,"lulu"));
        hs.add(new Student_01(18,"feifei"));
        hs.add(new Student_01(19,"lili"));
        hs.add(new Student_01(10,"nana"));
        System.out.println(hs.size());
        System.out.println(hs);

    }
}
//结果
5
[Student_01{age=18, name='feifei'}, Student_01{age=10, name='nana'}, Student_01{age=20, name='lulu'}, Student_01{age=19, name='lili'}, Student_01{age=19, name='lili'}]

在这里插入图片描述

HashSet的底层原理：数组+链表=哈希值

注意：如果放入HashSet的数据，一定要重写两个方法: hashCode, equals

//在Student_01重写hashCode,equals方法
public class TestStudent_01 {
    public static void main(String[] args) {
//        上面自定义的类型不满足 唯一,无序的特点
        HashSet<Student_01> hs = new HashSet<>();
        hs.add(new Student_01(19,"lili"));
        hs.add(new Student_01(20,"lulu"));
        hs.add(new Student_01(18,"feifei"));
        hs.add(new Student_01(19,"lili"));
        hs.add(new Student_01(10,"nana"));
        System.out.println(hs.size());
        System.out.println(hs);

    }
}
//结果
4
[Student_01{age=18, name='feifei'}, Student_01{age=19, name='lili'}, Student_01{age=20, name='lulu'}, Student_01{age=10, name='nana'}]


public class LinkedHashSet_01 {
    public static void main(String[] args) {
//        LinkedHashSet  有序,不唯一
//        其实就是在HashSet的基础上，多了一个总的链表，这个总链表将放入的元素串在了一起，方便有序的遍历        
        LinkedHashSet<Integer> lhs = new LinkedHashSet<>();
        lhs.add(19);
        lhs.add(1);
        lhs.add(199);
        lhs.add(19);
        lhs.add(21);
        lhs.add(40);
        lhs.add(0);

        System.out.println(lhs.size());
        System.out.println(lhs);

    }
}

内部比较器

public class Student_02 implements Comparable<Student_02>{
    private int age;
    private double height;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Test_01{" +
                "age=" + age +
                ", height=" + height +
                ", name='" + name + '\'' +
                '}';
    }

    public Student_02(int age, double height, String name) {
        this.age = age;
        this.height = height;
        this.name = name;
    }

    @Override
    public int compareTo(Student_02 o) {
//        return this.getAge()-o.getAge();
        return ((Double)(this.getHeight())).compareTo((Double) (o.getHeight()));
    }
}

public class TestStudent_02 {
    public static void main(String[] args) {
        Student_02 stu1 = new Student_02(10,16.5,"lili");
        Student_02 stu2 = new Student_02(14,17.05,"nana");
        System.out.println(stu1.compareTo(stu2));

    }
}

外部比较类（外部比较类比内部好）

import java.util.Comparator;

public class Student_03 {
    private int age;
    private double height;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Test_01{" +
                "age=" + age +
                ", height=" + height +
                ", name='" + name + '\'' +
                '}';
    }

    public Student_03(int age, double height, String name) {
        this.age = age;
        this.height = height;
        this.name = name;
    }
}
//扩展性好，用于实际开发外部比较器
class Rather implements Comparator<Student_03> {
    @Override
    public int compare(Student_03 o1, Student_03 o2) {
        return o1.getAge() -o2.getAge();

    }
}

import java.util.Comparator;

public class TestStudent_03 {
    public static void main(String[] args) {
        Student_03 stu1 = new Student_03(10,16.5,"lili");
        Student_03 stu2 = new Student_03(14,17.05,"nana");

        Comparator ca = new Rather();
        System.out.println(ca.compare(stu1, stu2));
        
    }
}

1 排序规则实现的方法不同

Comparable接口的方法：compareTo(Object o)

Comparator接口的方法：compare(T o1, To2)

2 类设计前后不同

Comparable接口用于在类的设计中使用；设计初期，就实现这个借口，指定排序方式。

Comparator接口用于类设计已经完成，还想排序（Arrays）。
在这里插入图片描述

etherealiu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2021-11-04
m0_53575762的博客
11-20 6620
一、Linux命令和windows区别？ 1、Linux命令全部严格区分大小写；而windows命令大小写都识别。 2、Linux所有的文件都是没有扩展名的，而windows是文件是有扩展名的。 创建一个新用户 [root@localhost mxh]# useradd mxh2 # 创建一个user [root@localhost mxh]# password mxh2 #12345678 [root@localhost xxx]# gr...
2021-09-02
weixin_45156147的博客
09-12 649
DeepT orrent: a deep learning-based approach for predicting DNA N4-methylcytosine sites前言一、前言一、介绍2.读入数据总结 for predicting DNA N4-methylcytosine sites) 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例
2021-04-09
HCZ_hhh的博客
04-09 359
2021-01-18
weixin_54641072的博客
01-18 1775
找程序猿哥哥！！！！编制App或者小程序
2021-04-09_bookNotice_log.txt
06-01
2021-04-09_bookNotice_log.txt
Demo-2021-08-04-09-29
04-08
GithubDemo 项目更新 Github演示。 如果您想了解更多信息，请查看 GitHub培训 我的GitHub培训课程列表 （第6小时） （16小时）
wiznote-windows-x86-2021-06-09.exe
06-22
为知笔记windows客户端
SpringMVC请求参数处理-2021-04-09.txt
04-09
SpringMVC的参数请，整理了常见的参数处理方法
2021-03-04-raspios-buster-armhf-lite.zip
04-24
标题“2021-03-04-raspios-buster-armhf-lite.zip”揭示了该文件的关键信息：这是2021年3月4日发布的Raspberry Pi OS Lite系统镜像的压缩包，基于Debian的Buster分支，并且是针对ARMHF架构的。ARMHF是指适用于ARMv7...
【初阶数据结构篇】单链表的实现（赋源码）
2301_79849925的博客
07-25 1462
​ 链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表主要有两个部分：当前结点要保存的数据和保存下⼀个结点的地址（指针变量）。本篇主要介绍单链表的实现方法。
《Java初阶数据结构》----5.＜二叉树的概念及使用＞
m0_73456341的博客
07-24 1407
1.树的基本概念、2.二叉树概念及特性、3.二叉树的基本操作、4.二叉树相关编程题
数据结构——单链表OJ题（上）
2301_81888634的博客
07-24 843
一起加油，敬请期待“单链表OJ题（下）”~
数据结构（2）
m0_62881487的博客
07-23 1136
为建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息之外，还需要存放一个指向其后继的指针。为指针域，存放其后继结点的地址。由于单链表的元素离散地分布在存储空间中，因此是非随机存取的存储结构。1. 线性表的链式存储又称单链表。它是指通过一组任意的存储单元来存储线性表中的数据元素。的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理地址上也相邻。3. 顺序表的特点是表中元素的逻辑顺序与其存储的物理顺序相同。2. 线性表的顺序存储又称顺序表。，分别指向其直接前躯和直接后继。
2024.7.24 作业
qq_64434282的博客
07-24 2026
【代码】2024.7.24 作业。
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 446
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 244
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 617
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
花几千上万学习Java，真没必要！（三十五）
最新发布
wehpd的博客
07-30 275
集合之Map
使用python中的pymsql完成如下：表结构与数据创建 1. 建立 `users` 表和 `orders` 表。 `users` 表有用户ID、用户名、年龄字段，（id，name，age） `orders` 表有订单ID、订单日期、订单金额，用户id字段。（id，order_date，amount，user_id） 2 两表的id作为主键，`orders` 表用户id为users的外键 3 插入数据 `users` (1, '张三', 18), (2, '李四', 20), (3, '王五', 22), (4, '赵六', 25), (5, '钱七', 28); `orders` (1, '2021-09-01', 500, 1), (2, '2021-09-02', 1000, 2), (3, '2021-09-03', 600, 3), (4, '2021-09-04', 800, 4), (5, '2021-09-05', 1500, 5), (6, '2021-09-06', 1200, 3), (7, '2021-09-07', 2000, 1), (8, '2021-09-08', 300, 2), (9, '2021-09-09', 700, 5), (10, '2021-09-10', 900, 4); 查询语句 1. 查询订单总金额 2. 查询所有用户的平均年龄，并将结果四舍五入保留两位小数。 3. 查询订单总数最多的用户的姓名和订单总数。 4. 查询所有不重复的年龄。 5. 查询订单日期在2021年9月1日至9月4日之间的订单总金额。 6. 查询年龄不大于25岁的用户的订单数量，并按照降序排序。 7. 查询订单总金额排名前3的用户的姓名和订单总金额。 8. 查询订单总金额最大的用户的姓名和订单总金额。 9. 查询订单总金额最小的用户的姓名和订单总金额。 10. 查询所有名字中含有“李”的用户，按照名字升序排序。 11. 查询所有年龄大于20岁的用户，按照年龄降序排序，并只显示前5条记录。 12. 查询每个用户的订单数量和订单总金额，并按照总金额降序排序。
06-03
cur.execute('SELECT SUM(amount) FROM orders WHERE order_date BETWEEN "2021-09-01" AND "2021-09-04"') print(cur.fetchone()[0]) # 6. 查询年龄不大于25岁的用户的订单数量，并按照降序排序。 cur.execute('''...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值