LinkedList实现的插入式升/降序排序算法

最新推荐文章于 2024-08-15 22:17:06 发布
原创 最新推荐文章于 2024-08-15 22:17:06 发布 · 2.9k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #LinkedList #插入式升 #降序排序算法

本文介绍了一种使用Java LinkedList实现的插入式升序和降序排序算法。该算法在插入新元素的同时进行排序，确保列表始终保持有序状态。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

package myPackage;

import java.util.LinkedList;

/**
 * 此排序算法是通过 java 中LinkedList实现的插入式升/降序排序算法
 * 所谓插入式：一边向LinkedList中插入数据一边排序
 * <b>以Integer类型为例</b>
 *
 */
public class InsertSortLinkedList {

    public static void main(String[] args) {
    	LinkedList<Integer> elemList = new LinkedList<Integer> ();
    	try {
    		long start = System.currentTimeMillis();
			upSort(6, elemList);
			upSort(5, elemList);
			upSort(4, elemList);
			upSort(3, elemList);
			upSort(2, elemList);
			upSort(1, elemList);
			upSort(8, elemList);
			upSort(6, elemList);
			upSort(5, elemList);
			upSort(4, elemList);
			upSort(3, elemList);
			upSort(2, elemList);
			upSort(1, elemList);
			upSort(8, elemList);
			upSort(6, elemList);
			upSort(5, elemList);
			upSort(4, elemList);
			upSort(3, elemList);
			upSort(2, elemList);
			upSort(1, elemList);
			upSort(8, elemList);
			upSort(6, elemList);
			upSort(5, elemList);
			upSort(4, elemList);
			upSort(3, elemList);
			upSort(2, elemList);
			upSort(1, elemList);
			upSort(8, elemList);
			upSort(6, elemList);
			upSort(5, elemList);
			upSort(4, elemList);
			upSort(3, elemList);
			upSort(2, elemList);
			upSort(1, elemList);
			upSort(8, elemList);
			upSort(6, elemList);
			upSort(5, elemList);
			upSort(4, elemList);
			upSort(3, elemList);
			upSort(2, elemList);
			upSort(1, elemList);
			upSort(8, elemList);
			upSort(6, elemList);
			upSort(5, elemList);
			upSort(4, elemList);
			upSort(3, elemList);
			upSort(2, elemList);
			upSort(1, elemList);
			upSort(8, elemList);
			upSort(6, elemList);
			upSort(5, elemList);
			upSort(4, elemList);
			upSort(3, elemList);
			upSort(2, elemList);
			upSort(1, elemList);
			upSort(8, elemList);
			upSort(6, elemList);
			upSort(5, elemList);
			upSort(4, elemList);
			upSort(3, elemList);
			upSort(2, elemList);
			upSort(1, elemList);
			upSort(8, elemList);
			upSort(6, elemList);
			upSort(5, elemList);
			upSort(4, elemList);
			upSort(3, elemList);
			upSort(2, elemList);
			upSort(1, elemList);
			upSort(8, elemList);
			upSort(6, elemList);
			upSort(5, elemList);
			upSort(4, elemList);
			upSort(3, elemList);
			upSort(2, elemList);
			upSort(1, elemList);
			upSort(8, elemList);
			upSort(6, elemList);
			upSort(5, elemList);
			upSort(4, elemList);
			upSort(3, elemList);
			upSort(2, elemList);
			upSort(1, elemList);
			upSort(8, elemList);
			upSort(6, elemList);
			upSort(5, elemList);
			upSort(4, elemList);
			upSort(3, elemList);
			upSort(2, elemList);
			upSort(1, elemList);
			upSort(8, elemList);
			upSort(6, elemList);
			upSort(5, elemList);
			upSort(4, elemList);
			upSort(31, elemList);
			upSort(21, elemList);
			upSort(1, elemList);
			upSort(81, elemList);
			upSort(16, elemList);
			upSort(5, elemList);
			upSort(14, elemList);
			upSort(3, elemList);
			upSort(2, elemList);
			upSort(21, elemList);
			upSort(8, elemList);
			upSort(6, elemList);
			upSort(5, elemList);
			upSort(41, elemList);
			upSort(3, elemList);
			upSort(2, elemList);
			upSort(1, elemList);
			upSort(18, elemList);
			
			upSort(6, elemList);
			upSort(5, elemList);
			upSort(4, elemList);
			upSort(3, elemList);
			upSort(12, elemList);
			upSort(1, elemList);
			upSort(8, elemList);
			upSort(61, elemList);
			upSort(5, elemList);
			upSort(4, elemList);
			upSort(332, elemList);
			upSort(2, elemList);
			upSort(13, elemList);
			upSort(8, elemList);
			upSort(6, elemList);
			upSort(5, elemList);
			upSort(2344, elemList);
			upSort(3423, elemList);
			upSort(2, elemList);
			upSort(1, elemList);
			upSort(8, elemList);
			long end = System.currentTimeMillis();
			System.out.println(end - start);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    	for(Integer intgeter: elemList){
    		System.out.println(intgeter);
    	}
    }
    /**
     *     升序算法含义：
     * 1、首先判断新增元素和元素集合不能为null;
     * 2、判断元素集合是否为空，如果为空则将当前新增元素插入到链表的表头
     * 3、如果不是第二种情况则需要遍历整个链表，查看是否有已存在元素比当前新增元素大，
     * 如果有则将当前元素插入到已存在元素的位置
     * 4、如果遍历到最后一个位置没有比当前新增元素大，那么就将新增元素插入到链表的最后一个位置
     *
     */
    public static void upSort(Integer element,LinkedList<Integer> elemList) throws Exception{
        if(element == null)
        {
            throw new Exception("插入元素为null");
        }
        if(elemList == null)
        {
            throw new Exception("元素集合为null");
        }
        if(elemList.size() == 0)
        {
            elemList.add(element);
        }else{
            if(element < elemList.getFirst())
            {
                elemList.addFirst(element);
            }else {
                boolean insertFlag = false;
                for (Integer e : elemList)
                {
                    if(element < e)
                    {
                        int index = elemList.indexOf(e);
                        elemList.add(index, element);
                        insertFlag = true;
                        break;
                    }
                }
                if(!insertFlag)
                {
                    elemList.addLast(element);
                }
            }
        }
    }
    /**
     ** 降序同升序的设计思想相同
     *
     */
    public static void downSort(Integer element,LinkedList<Integer> elemList) throws Exception
    {
        if(element == null)
        {
            throw new Exception("插入元素为null");
        }
        if(elemList == null)
        {
            throw new Exception("元素集合为null");
        }
        if(elemList.size() == 0)
        {
            elemList.add(element);
        }else{
            if(element > elemList.getFirst())
            {
                elemList.addFirst(element);
            }else {
                boolean insertFlag = false;
                for (Integer e : elemList)
                {
                    if(element > e)
                    {
                        int index = elemList.indexOf(e);
                        elemList.add(index, element);
                        insertFlag = true;
                    }
                }
                if(!insertFlag)
                {
                    elemList.addLast(element);
                }
            }
        }
    }

}


19、掌握Python中的高级数据结构与算法
rice5的博客
06-02 19
本文深入探讨了Python中各种高级数据结构及其应用场景，包括列表、元组、字典、集合等基础结构，并介绍了字符串处理、正则表达式、堆、优先队列、链表、树与图等复杂数据结构和相关算法。同时结合实战案例，如社交网络好友推荐系统、文本自动摘要生成、高性能缓存系统等，展示了如何在实际项目中灵活运用这些技术。此外，还展望了数据结构与算法的未来发展趋势，涵盖量子计算、人工智能、分布式系统等多个方向。
备战大厂—— Leetcode 刷题（二叉树、三数和、回文子串、公共祖先、TOP K、栈与对列的互相实现等大厂常考算法 【56】 题）
10-01 334
最近面了京东（已拿offer）、百度（等待二面）、字节（二面挂）、蚂蚁金服（等待三面中），大厂都考了算法，一般算法占面试的20%，但是算法挂了希望就不大了（面试字节，面试官让手写代码的地方有两个：一个是手写静态内部类型的单例模式，这个写出来了，另一个就是全排列算法，没写出来，挂了），这里梳理总结下已经考到的算法以及常考的算法，不打无准备之仗！（给自己梳理的，就不对大家可见了，如果想看那就私信我！）
LinkedList插入排序实现
weixin_30248399的博客
03-08 299
　　昨天遇到一个集合排序的问题，要求在list中插入后数据有序，首先考虑使用集合自带的排序方法，但需要把list转成数组，排序后再转回list。后来发现使用插入算法是最省事的，因为既然是在插入里排序，那么在插入前就先找好插入点，插入后序列就是有序的，以此类推。代码贴上： package com.wulinfeng.io; import java.util.Collections; i...
基于LinkedList实现桶排序
weixin_30677475的博客
02-14 139
需要考虑以下问题： 　　1、桶的大小，这里我们可以根据输入的元素的个数来确定桶的大小。 　　2、怎么样确定当前元素进入哪一个桶，这里我们使用到的是通过一个哈希函数来进行计算。 int index = (element * length) / (max + 1); element为当前元素的值，length为桶的大小，max为数组中最大元素的值 　　3、因为输入的数据是随机的，所...
JAVA LinkList插入排序
zhangze4123的专栏
11-10 2104
编程实现链表：       要求：1.循环输入学生学号和成绩。并将学生信息加入到链表中；                   2.链表中的信息按学生成绩的高-->低进行排序；                   3.如果输入的学生信息中,学号重复,则仅更新学生成绩,不添加新的节点。   import java.util.Scanner; public class TestLink {
借助java的LinkedList实现插入排序
qq_19439605的博客
09-02 1228
List<Integer> a=new ArrayList(); a.add(1); a.add(2); a.add(7); a.add(7); a.add(0); a.add(3); a.add(4); a.add(212); List<Integer> sortedList=new LinkedList(); a.forEach(sortNum ->{ ...
Java中如何对LinkedList排序呢？
qq_25073223的博客
08-19 2516
Java中对LinkedList排序的方法分享
【C++算法结合】：线性表中的排序与搜索算法深度探索
本文对线性表与算法进行了全面的探讨，涵盖了基本排序算法、高级搜索算法的理论与实现，以及在C++标准模板库中的应用。在介绍线性表的基本概念和操作接口后，本文详细讨论了简单排序和高效排序算法的原理与实践，...
单链表应用------根据两个升序单链表,生成一个降序单链表（头插法）
goging的博客
09-23 2778
2018/9/28  17:19    数据结构笔记(一) 数据结构中一种特别重要的结构就是链表，和链表有关的应用有很多，很多语言的容器api的底层实现就是链表，所以掌握链表也是一名计算机级专业的学生必备，下面我们就来看看一下单链表的小应用-----------将两个升序单链表,合并为一个降序单链表（不拆分升序链表），这里将会涉及的知识有:       1.单链表创建以及插入       2...
算法笔记|Day25贪心算法III
最新发布
m0_57632621的博客
08-15 1228
算法笔记|Day25贪心算法III
java LinkedList的添加删除操作
06-21
java LinkedList的添加删除操作 java LinkedList的添加删除操作
java数据结构和算法——单链表（Linked List）单链表反转（反转后链表的结构是原始链表顺序的倒序）的应用示例
小志的博客
07-22 500
实现单链表反转的目录一、单链表反转的思路分析示意图二、单链表反转的实现步骤的分解图三、单链表反转的代码示例 一、单链表反转的思路分析示意图 二、单链表反转的实现步骤的分解图 三、单链表反转的代码示例 1、定义一个人员节点类，每一个PersonNode对象就是一个节点 package com.rf.springboot01.dataStructure.singleLinkedList; /** * @description: 定义一个人员节点类，每一个PersonNode对象就是一个节点 * @au
使用LinkedList 实现 冒泡 插入 选择 排序
qq_43059674的博客
05-09 604
/** * 这是使用链表来实现冒泡排序 * * @param linkedList * @param n */ public static void bubbleSort(LinkedList<Integer> linkedList, int n) { if (n < 1) { ...
java linkedlist排序_Java LinkedList排序
weixin_42588877的博客
02-13 2093
首页>基础教程>集合框架>LinkedList类Java LinkedList排序LinkedList通过Collections.sort进行排序，代码如下：降序public class Person1 implements Comparable < Person1 > {private Float height;private String name;P...
算法：逆序局部链表 Reverse Linked List II
AI架构师易筋
09-27 208
题目 92. Reverse Linked List II Reverse a linked list from position m to n. Do it in one-pass. Note: 1 ≤ m ≤ n ≤ length of list. Example: Input: 1->2->3->4->5->NULL, m = 2, n = 4 Output: 1->4->3->2->5->NULL 解答 逆序局部链表，关键是要记录逆序的开
[LeetCode] Reverse Linked List II 倒置链表之二（算法分析）
weixin_41157881的博客
06-27 142
指针的巧妙使用，和虚节点在链表中的使用。 比较容易想到的算法（先找到需要翻转的链表段，保存该段的头一个节点和后一个节点，链表段翻转后再和两个节点拼接） LinkNode* reverse(LinkNode *head, LinkNode *end) { LinkNode *front = nullptr; LinkNode *cur = head; LinkNode curnext = h...
Java对LinkedList进行排序
allway2的博客
03-08 8260
链表是一个线性数据结构，其中的元素是不能存储在连续的存储单元。 按升序对单链接列表的节点进行排序： 原始清单 排序清单 我们可以通过许多排序技术对LinkedList进行排序： 气泡排序 插入排序 快速分类 合并排序 方法1：使用冒泡排序进行排序 为了完成此任务，我们维护两个指针：current和index。 最初，当前指向头节点，索引将指向当前旁边的节点。 通过将当前数据与索引数据进行比较，遍历列表直到当前指向null。 对于每个当前值，索引是当前节点的下一个节点，它
数据结构线性表之顺序表LinkedList
Shen_Dong的博客
03-24 200
根据LinkedList内部数据结构特性，非常适合增加，删除操作。凡事不是绝对的，只是和ArrayList相比之下更适合，真正的使用还得放到生产环境中去决定到底是用什么合适。
LinkedList 的插入和删除 （双向链表）
Sean'Xu Blogs
11-15 6484
LinkedList底层是双向链表的结构，内部维护了3个成员变量，一个是当前链表的头节点，一个是尾部节点，还有是链表长度。 双向链表 ：有序，可重复 ，插入删除快，查找效率慢。 下面我们创建一个LinkedList 集合，看看到底是如何进行插入和删除操作的。 插入一个元素 add方法，调用linkLast方法 直接看linkLast方法 最后一个节点指向l, 创建一个Node对象，将我们...
Java算法与数据结构深入解析
7. 排序和搜索算法：排序算法用于将一组数据按照特定顺序（通常是升序或降序）进行排列，常见的排序算法有冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序等。搜索算法用于在数据集中查找特定元素，常见...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值