java使用单向链表解决数据存储自定义排序问题_Java教程

java使用单向链表解决数据存储自定义排序问题

2022-10-24 14:53_灯火阑珊处 Java教程

本文主要介绍了java使用单向链表解决数据存储自定义排序问题，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下

表设计

				?

									CREATE TABLE `test` (

									  `id` bigint NOT NULL COMMENT '主键id',

									  `name` varchar(50) COLLATE NOT NULL COMMENT '名称',

									  `next_id` bigint DEFAULT NULL COMMENT '指向下一个节点的主键id',

									) ;

1. 新增一条记录

指定位置插入
- 参数传递前一条数据的主键 id，根据 id 查询出该条数据的 next_id 记为 A
- 设置新增数据的 next_id 为 A 并保存，
- 修改前一条数据的 next_id 为新增数据的主键 id
尾插
- 默认 next_id 为 -1，表示为新增的数据，排序在最后，需要先查询出新增前最后一条数据，并将其 next_id 修改为新增数据的 id

2. 修改排序

参数传递
被移动数据，移动前，前一条数据的 id （C）

被移动数据，移动后，前一条数据的 id （A）

被移动数据的 id （D）
查询 A 的 next_id （记为 B ）
查询 D 的 next_id （记为 E ）
修改 A 的 next_id 为 D 的主键 id
修改 D 的 next_id 为 B
修改 C 的 next_id 为 E

移动思路如下

java使用单向链表解决数据存储自定义排序问题

3. 删除

参数传递前一条数据的id、和要删除数据的id，查询出删除数据的 next_id 记为 A
修改前一条数据的 next_id 为 A
对要删除的数据执行删除

代码实现

1. 简单对象

				?

									@Data

									public class Tag {

									    private Integer id;

									    private String name;

									    private Integer nextId;

									}

2. 对数据按照 nextId 排序

				?

									public class Test {

									    public static void main(String[] args) {

									        // 添加测试数据

									        // 这里生成的链表应为：10 -> 40 -> 20 -> 30 -> 50

									        List<Tag> tags = addData();

									        // 根据每项数据的nextId建立map

									        Map<Integer, Tag> map = tags.stream().collect(Collectors.toMap(Tag::getNextId, t -> t));

									        // -1 默认为最后一项

									        Tag lastTag = map.get(-1);

									        LinkedList<Tag> tagLinkedList = new LinkedList<>();

									        tagLinkedList.addFirst(lastTag)

									        // 使用递归从map中提取数据

									        get(lastTag.getId(), map, tagLinkedList);

									        tagLinkedList.forEach(System.out::println);

									    }

									    private static void get(int preId, Map<Integer, Tag> map, LinkedList<Tag> tagList) {

									        Tag tag = map.get(preId);

									        if (tag == null) {

									            return;

									        }

									        tagList.addFirst(tag);

									        get(tag.getId(), map, tagList);

									    }

									    private static List<Tag> addData() {

									        List<Tag> tagList = new ArrayList<>();

									        Tag tag1 = new Tag();

									        tag1.setId(10);

									        tag1.setName("tag1");

									        tag1.setNextId(40);

									        tagList.add(tag1);

									        Tag tag4 = new Tag();

									        tag4.setId(40);

									        tag4.setName("tag4");

									        tag4.setNextId(20);

									        tagList.add(tag4);

									        Tag tag2 = new Tag();

									        tag2.setId(20);

									        tag2.setName("tag2");

									        tag2.setNextId(30);

									        tagList.add(tag2);

									        Tag tag3 = new Tag();

									        tag3.setId(30);

									        tag3.setName("tag3");

									        tag3.setNextId(50);

									        tagList.add(tag3);

									        Tag tag5 = new Tag();

									        tag5.setId(50);

									        tag5.setName("tag5");

									        tag5.setNextId(-1);

									        tagList.add(tag5);

									        return tagList;

									    }

									}

3. 输出结果

Tag(id=10, name=tag1, nextId=40)
Tag(id=40, name=tag4, nextId=20)
Tag(id=20, name=tag2, nextId=30)
Tag(id=30, name=tag3, nextId=50)
Tag(id=50, name=tag5, nextId=-1)

到此这篇关于java使用单向链表解决数据存储自定义排序问题的文章就介绍到这了,更多相关java 数据存储自定义排序内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://juejin.cn/post/7078583337199239205