JAVA算法系列 冒泡排序

简介: java算法系列之排序手写冒泡冒泡算是最基础的一个排序算法,简单的可以理解为,每一趟都拿i与i+1进行比较,两个for循环,时间复杂度为 O(n^2),同时本例与选择排序进行了比较,选择排序又叫直接排序,之所以直接,就是简单粗暴,不像冒泡,冒泡是紧挨着的两个小伙伴两两比较,直接排序是每一趟直接拿当前i与整个数组中所有元素进行比较,如果大小不一致,直接替换,相当于跳跃过去了,根本不考虑小伙伴的感受,我看到哪个小伙伴比我小,我就占领它的位置,彼此替换。

java算法系列之排序

手写冒泡

冒泡算是最基础的一个排序算法,简单的可以理解为,每一趟都拿i与i+1进行比较,两个for循环,时间复杂度为 O(n^2),同时本例与选择排序进行了比较,选择排序又叫直接排序,之所以直接,就是简单粗暴,不像冒泡,冒泡是紧挨着的两个小伙伴两两比较,直接排序是每一趟直接拿当前i与整个数组中所有元素进行比较,如果大小不一致,直接替换,相当于跳跃过去了,根本不考虑小伙伴的感受,我看到哪个小伙伴比我小,我就占领它的位置,彼此替换。


package com.rsc.sort;

import java.util.Arrays;

/**
 * 冒泡排序
 * 
 * @author 落雨 2015年6月5日09:33:13 http://ae6623.cn
 */
public class BubbleSort {
    /**
     * 直接排序(选择排序)
     * i与j进行比较,如果大小不一致,直接将a[i]与a[j]元素进行置换
     * @param array
     */
    public static void selectionSort(int[] array) {
        int temp = 0;
        int total = 1;
        for (int i = 0; i < array.length; i++) {// 循环length次
            //System.out.println("第"+i+"趟");
            for (int j = i + 1; j < array.length; j++) {// 从i+1开始和i进行比较,找到大小不一致的,直接与a[i]进行置换

                if (array[i] > array[j]) {
                    temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                    for (int k : array) {
                        System.out.print(k + " ");
                    }
                    System.out.println("交换" + total++ + "次 【" + array[j] + "交换"
                            + array[i] + "】");
                }
            }
        }

    }
    
    /**
     * 冒泡排序
     * 只置换相邻的两个元素
     * @param array
     */
    public static void bubbleSort(int[] array) {
        int temp = 0;
        int total = 1;
        boolean flag = false;
        //对于length个元素,只需要比较length-1即可 比如 5个数字,只需要循环比较4次
        for(int i=0;i<array.length-1;i++){
            
            //由于是冒泡排序,第一个位置肯定是最小的,每循环i次,就不用再判断前i个位置,所以length-1-i
            for(int j=0;j<array.length-i-1;j++){
                if(array[j]>array[j+1]){
                    /*
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    */
                    array[j] = array[j] ^ array[j+1];
                    array[j+1] = array[j] ^ array[j+1];
                    array[j] = array[j] ^ array[j+1];
                     
                    flag = true;//发生了置换
                    for (int k : array) {
                        System.out.print(k + " ");
                    }
                    System.out.println("交换" + total++ + "次 【" + array[j+1] + "交换"
                            + array[j] + "】");
                }
            }
            if(!flag){//如果无置换,则跳出循环
                break;
            }else{
                flag = false;//有置换,把标志位重新置为false,方便下一次判断
            }
            System.out.println("完成第"+(i+1)+"趟冒泡");
        }
    }

    public static void swap(int a,int b){
        
        a = a^b;
        b = a^b;
        a = a^b;
        System.out.println(a+","+b);
    }
    
    public static void main(String[] args) {
        
        //swap(5,3);
        
        int[] array = { 4, 1, 3, 2, 5 , 6 , 8 , 7 , 9  };
        int[] array2 = Arrays.copyOf(array, array.length) ;
        
        System.out.println("直接排序如下:");
        selectionSort(array); 
        
        System.out.println("冒泡排序如下:");
        bubbleSort(array2); 

    }
}

打印结果如下:

直接排序如下:
1 4 3 2 5 6 8 7 9 交换1次 【4交换1】
1 3 4 2 5 6 8 7 9 交换2次 【4交换3】
1 2 4 3 5 6 8 7 9 交换3次 【3交换2】
1 2 3 4 5 6 8 7 9 交换4次 【4交换3】
1 2 3 4 5 6 7 8 9 交换5次 【8交换7】
冒泡排序如下:
1 4 3 2 5 6 8 7 9 交换1次 【4交换1】
1 3 4 2 5 6 8 7 9 交换2次 【4交换3】
1 3 2 4 5 6 8 7 9 交换3次 【4交换2】
1 3 2 4 5 6 7 8 9 交换4次 【8交换7】
完成第1趟冒泡
1 2 3 4 5 6 7 8 9 交换5次 【3交换2】
完成第2趟冒泡

目录
相关文章
|
4月前
|
负载均衡 算法 关系型数据库
大数据大厂之MySQL数据库课程设计:揭秘MySQL集群架构负载均衡核心算法:从理论到Java代码实战,让你的数据库性能飙升!
本文聚焦 MySQL 集群架构中的负载均衡算法,阐述其重要性。详细介绍轮询、加权轮询、最少连接、加权最少连接、随机、源地址哈希等常用算法,分析各自优缺点及适用场景。并提供 Java 语言代码实现示例,助力直观理解。文章结构清晰,语言通俗易懂,对理解和应用负载均衡算法具有实用价值和参考价值。
大数据大厂之MySQL数据库课程设计:揭秘MySQL集群架构负载均衡核心算法:从理论到Java代码实战,让你的数据库性能飙升!
|
4月前
|
存储 缓存 监控
上网行为监控系统剖析:基于 Java LinkedHashMap 算法的时间序列追踪机制探究
数字化办公蓬勃发展的背景下,上网行为监控系统已成为企业维护信息安全、提升工作效能的关键手段。该系统需实时记录并深入分析员工的网络访问行为,如何高效存储和管理这些处于动态变化中的数据,便成为亟待解决的核心问题。Java 语言中的LinkedHashMap数据结构,凭借其独有的有序性特征以及可灵活配置的淘汰策略,为上网行为监控系统提供了一种兼顾性能与功能需求的数据管理方案。本文将对LinkedHashMap在上网行为监控系统中的应用原理、实现路径及其应用价值展开深入探究。
102 3
|
4月前
|
人工智能 算法 NoSQL
LRU算法的Java实现
LRU(Least Recently Used)算法用于淘汰最近最少使用的数据,常应用于内存管理策略中。在Redis中,通过`maxmemory-policy`配置实现不同淘汰策略,如`allkeys-lru`和`volatile-lru`等,采用采样方式近似LRU以优化性能。Java中可通过`LinkedHashMap`轻松实现LRUCache,利用其`accessOrder`特性和`removeEldestEntry`方法完成缓存淘汰逻辑,代码简洁高效。
183 0
|
3月前
|
存储 算法 安全
Java中的对称加密算法的原理与实现
本文详细解析了Java中三种常用对称加密算法(AES、DES、3DES)的实现原理及应用。对称加密使用相同密钥进行加解密,适合数据安全传输与存储。AES作为现代标准,支持128/192/256位密钥,安全性高;DES采用56位密钥,现已不够安全;3DES通过三重加密增强安全性,但性能较低。文章提供了各算法的具体Java代码示例,便于快速上手实现加密解密操作,帮助用户根据需求选择合适的加密方案保护数据安全。
336 58
|
2月前
|
搜索推荐 算法 Go
Go语言数组排序(冒泡排序法)—— 用最直观的方式掌握排序算法
本案例介绍使用冒泡排序对整数数组进行升序排序的实现方法,涵盖输入处理、错误检查与排序逻辑。通过代码演示和算法解析,帮助理解排序原理及Go语言切片操作,为学习更复杂排序算法打下基础。
|
2月前
|
存储 负载均衡 算法
我们来说一说 Java 的一致性 Hash 算法
我是小假 期待与你的下一次相遇 ~
100 1
|
2月前
|
搜索推荐
冒泡排序与其它排序算法比较
本内容比较了冒泡排序、选择排序和插入排序的特性。三者时间复杂度均为O(n²),但交换次数和稳定性不同。冒泡排序稳定,交换次数多,可优化至O(n);选择排序不稳定,交换次数少;插入排序交换次数最少,且二者均为稳定排序。对于有序数组,冒泡和插入可优化提升效率。
44 0
|
2月前
|
存储 监控 算法
企业上网监控场景下布隆过滤器的 Java 算法构建及其性能优化研究
布隆过滤器是一种高效的数据结构,广泛应用于企业上网监控系统中,用于快速判断员工访问的网址是否为违规站点。相比传统哈希表,它具有更低的内存占用和更快的查询速度,支持实时拦截、动态更新和资源压缩,有效提升系统性能并降低成本。
60 0
|
5月前
|
存储 机器学习/深度学习 监控
如何监控员工的电脑——基于滑动时间窗口的Java事件聚合算法实现探析​
在企业管理场景中,如何监控员工的电脑操作行为是一个涉及效率与合规性的重要课题。传统方法依赖日志采集或屏幕截图,但数据量庞大且实时性不足。本文提出一种基于滑动时间窗口的事件聚合算法,通过Java语言实现高效、低资源占用的监控逻辑,为如何监控员工的电脑提供一种轻量化解决方案。
127 3
|
7月前
|
存储 算法 Java
解锁“分享文件”高效密码:探秘 Java 二叉搜索树算法
在信息爆炸的时代,文件分享至关重要。二叉搜索树(BST)以其高效的查找性能,为文件分享优化提供了新路径。本文聚焦Java环境下BST的应用,介绍其基础结构、实现示例及进阶优化。BST通过有序节点快速定位文件,结合自平衡树、多线程和权限管理,大幅提升文件分享效率与安全性。代码示例展示了文件插入与查找的基本操作,适用于大规模并发场景,确保分享过程流畅高效。掌握BST算法,助力文件分享创新发展。

热门文章

最新文章