我理解的冒泡排序

图文解释冒泡排序 冒泡排序(Bubble Sort),又被称为气泡排序或泡沫排序。它会遍历若干次需要排序的数列,每次遍历时,它都会从前往后依次的比较相邻两个数的大小;如果前者比后者大,则交换它们的位置。这样,一次遍历之后,最大的元素就在数列的末尾! 采用相同的方法再次遍历时,第二大的元素就被排列在最大元素之前。重复此操作,直到整个数列都有序为止! 阅读详情
package demo09;

import java.util.Arrays;

/**
 * @Author: micro cloud fly
 * @Description: 冒泡排序
 * @Date: Created in 4:39 下午 2020/9/27
 */
public class Test {
    public static void main(String[] args) {

        int[] arr = new int[]{
                1, 90, 9, 8, 5, 7, 10
        };
        System.out.println(Arrays.toString(mySort(arr)));
    }

    /**
     * 我理解的冒泡排序
     * @param arr
     * @return
     */
    public static int[] mySort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }
        for (int i = 0; i < arr.length - 1; i++) {
            System.out.println("第 --i--" + i + "次排序:" + Arrays.toString(arr));
            //第一轮,我取出第一个值和第二个值进行比较
            //如果第一个值大于第二个值,那么他们的位置进行交换
            //然后第一个值和第三个值进行比较,如果第一个值大于第三个,继续进行交换
            //那么此时,第一轮过后,数组的第一个值就应该是最小的那个数字了
            
            //-------------
            //第二轮,我取出第二个值和第三个值进行比较
            //如果第二个值大于第三个值,那么他们的位置进行交换
            //然后第二个值和第4个值进行比较,如果第二个值大于第四个,继续进行交换
            //那么此时,第二轮过后,数组的第二个值就应该是第二小的那个数字了
            
            //--------
            //直到最后一轮,最大的数字就在最后面了
            //我的思想跟老师教的思想的不同点就是,老师教的每一轮比较大小都把最大的数字放在最后面,
            //而如果我的代码的if (arr[i] > arr[j]) 改为if (arr[i] < arr[j]),那么我的思想就是每一轮比较把最大的值放在最前面
            for (int j = i + 1; j < arr.length; j++) {
                int x = arr[i];
                int y = arr[j];
                if (arr[i] < arr[j]) {
                    arr[j] = x;
                    arr[i] = y;
                }
                System.out.println("第  --j--" + i + "次排序:" + Arrays.toString(arr));
            }
            System.out.println("-----------------------------------------------");

        }
        return arr;
    }

    /**
     * 老师教的冒泡排序
     * @param arr
     * @return
     */
    private static int[] bubbleSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }
        for (int i = 0; i < arr.length - 1; i++) {
            System.out.println("第 --i--" + i + "次排序:" + Arrays.toString(arr));

            for (int j = 0; j < arr.length - i - 1; j++) {   // 这里说明为什么需要-1
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
                System.out.println("第  --j--" + i + "次排序:" + Arrays.toString(arr));

            }
            System.out.println("-----------------------------------------------");

        }
        return arr;
    }
}

 

冒泡排序 理解 1. 什么是冒泡排序? 冒泡排序是一种较简单的排序算法。因为在算法过程中,最大的数会慢慢“浮”到数列顶端,就像泡泡一样慢慢浮上去,所以叫冒泡排序。 2. 冒泡排序的思路 举个例子,有一群人,站成一排,我们要把他们按个子从高到矮排序,我们会把个子最高的人挑出来,让他站最前面,然后把剩下人里面个子最高的挑出来站刚刚那个人后面,继续这样挑下去直到所有人挑完了,我们的排序也就完成了。对于数组,机器无法一眼... 阅读详情

相关推荐

Blender点云渲染实战:用Geometry Nodes快速搞定论文配图(附Cycles渲染技巧)

本文详细介绍了如何利用Blender的Geometry Nodes系统,高效地将三维点云数据转化为高质量的科研论文配图。通过实战步骤,从数据导入、节点化几何处理、材质赋予到Cycles渲染引擎的优化设置,手把手教你制作出专业、美观的可视化图像,助力科研成果展示。

hp777的博客 265

排序算法之冒泡排序,通俗易懂,简单明了

通俗易懂的去理解冒泡排序以及对冒泡排序进行优化

ocean&21的博客 5265

【scratch音乐课】天空之城:音符与节拍、消息与链表

scratch是一个非常小巧的青少年编程工具,自带程序编写语句,积木式语句非常直观、易用,可创作数学、科学、音乐、绘画等方面作品。本文用scratch“演奏”一首大家非常熟悉的《天空之城》,并向大家介绍一些基本乐理知识,以及scratch中消息、链表的使用。

★·°立芯;︶︵︶ 1万+

从零开始理解冒泡排序

冒泡排序是一种基础的入门级别的算法,它的效率比较低,但是理解它的好处是让我们对算法有初步的了解,理解了冒泡排序,不仅仅是让我们写出一个简单算法,完成入门,笔者认为写出一段程序除了能够给我们带来收入以外,如果你能从写的代码中感受到一丝快乐,这是一种精神享受。下面就让我们开始理解冒泡排序算法,然后尝试着自己去把它写出来。哪怕过了两年之后,你仍然能手到拿来,不用过多思考,那么就算是真正掌握了。 首先,...

夜猫 2115

利用pyGAM实现广义可加模型(GAM)的实战指南

本文提供了利用pyGAM库实现广义可加模型(GAM)的完整实战指南。通过乳腺癌和房价预测案例,详细讲解了从环境配置、模型构建、核心可视化(部分依赖图)到参数调优(n_splines, lam)的每一步。重点展示了GAM如何平衡模型准确性与可解释性,帮助数据科学家在Python中高效应用这一强大工具。

weixin_29053383的博客 329

从零搭建私有AI工作站:Ollama+DeepSeek+Dify本地化部署全攻略

本文提供了一份详尽的本地化AI工作站搭建指南,核心在于实现数据安全与离线可用。通过整合Ollama、DeepSeek与Dify三大工具,手把手教你完成从环境配置、模型部署到可视化应用构建的全过程,重点解决了Dify连接Ollama等关键步骤,助你打造一个完全自主可控的私有AI开发环境。

weixin_28396629的博客 311

冒泡排序理解

这里写自定义目录标题冒泡排序理解 冒泡排序理解 冒泡排序通过每个元素都与其他元素比较一遍的方式,将数组中的元素按照从小到大或者从大到小的方式重新排序 具体的比较规可以这么理解 外循环循环变量每+1,就将剩余元素中最大的值找出来放到元素的最后边 先写出代码 let numbers=[22,3,4] for(var i=0;i<numbers.length-1;i++){ for(var j=0;j<numbers.length-1-i;j++){

csdn姚宏波 444

STM32duino LSM6DSO驱动库:低功耗IMU工程化实践

惯性测量单元(IMU)是智能终端与工业设备实现运动感知的核心传感器,其性能关键在于数据精度、实时响应与系统功耗的协同优化。LSM6DSO作为集成加速度计与陀螺仪的六轴MEMS器件,依托片上有限状态机(FSM)和机器学习核心(MLC),支持自由落体检测、计步器、6D方向识别等硬件自治功能,显著降低主控CPU负载。在STM32平台下,通过深度耦合HAL/LL库、显式引脚管理、DMA加速SPI传输及EXTI中断协同,可实现亚毫秒级事件响应与微安级待机功耗。本文聚焦STM32duino生态中LSM6DSO驱动的工程

weixin_36304957的博客 551

关于理解冒泡排序的经历

 我是一菜鸟新手, 学习Java 刚入门不久,最近想好好理解下冒泡排序算法,可是好像看来挺多的例子和网上的解释,好像都没有真正的理解,可能是自己在这方面没有DOWER 吧。   然后试着去用debug一步一步的调着一个冒泡排序的例子,看着每一步debug出来的结果,终于理解了这个算法。

认真做事,开心生活 639

vasp-自旋轨道耦合(SOC)计算步骤

在VASP中执行自旋轨道耦合(SOC)计算,具体的计算步骤如下: 结构优化获取CONTCAR文件 自洽计算(collinear normal VASP calculations)获取IBZKPT,CHGCAR和WAVECAR文件。 SCF+SOC计算,在此步骤中,将步骤2中的IBZKPT复制为KPOINTS,以便两个步骤具有相同的k网格,因此可以读取步骤2中的CHGCAR和WAVECAR文件。 能带结构计算,在此步骤中,将KPOINTS改为高对称点,读取步骤3中的CHGCAR和WAVECAR文件。

懒散的鱼与消失的猫 3万+

File does not exist: /user/anonymous/.staging/job_1628851608378_6064/报错问题解决

user/admin/.staging/job_1571397171638_0001/job_1571397171638_0001_1.jhist 所以为什么没有下发,这里面jhist,只是被引发的错误,它还不是根本的错误。看到上面错误,我们就可以判断,这是网络问题,然而网络无非是ip地址,防火墙,端口,hosts等。我们正常的hosts是这样的。在回头复盘想想,我们找不到jhist,跟我们的网络问题二者是很难找到关联的,所以大家在遇到问题的时候,一定多排查和思考,而不是看到一个错误,就以为是它的问题。

石榴姐yyds 2170

一篇文章让你真正理解冒泡排序

本文简明讲解冒泡排序算法,适合初学者理解。

baidu_33719384的博客 827

DFT笔记 DC/AC mode与Func

DFT scan可以分为DC和AC两种,区别如下图。

m0_61544122的博客 5723

.net C#带你理解冒泡排序

相信能够搜到该文章的程序员应该多数都在面试中碰到了这个问题,其实冒泡排序也不算是太难,如果你真的想搞懂,调试去跑一边就差不多能够懂了,光靠看,里面的逻辑有的时候有点绕,包括那个递归的一个面试题也是的,代码这种东西别靠死记,要懂得理解,理解后多实践一下,这个代码就会被深深的印到你的脑子里面了 接下来上代码与解析 int[] array = { 94,33,61,1 };//定义一个需要排序的数组 for (int i = 0; i < (array.Length-1); i++

qq_40256322的博客 422

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

冒泡排序理解以及算法优化

冒泡排序理解与算法优化 冒泡排序为基本内部排序算法(即不借助外部空间,内部自我排序), 如上图,冒泡排序经过不断比较相邻的元素的值,进行交换,第一次从第一个元素到最后一个元素的交换,会将该数组的最大值交换到最后一项,以此循环,我们不断地找出剩余元素中的最大值,并将该最大值移动到剩余元素中的最大值.最终排序成功. (本文中语言使用c语言,算法利用函数实现,编译器参考DEV C++) void Bubble_sort(int *a,int len)//函数传递数组名字以及数组长度 { int i,j,k

weixin_52333983的博客 1027

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

冒泡排序的理解

每次准备面试,都要看下冒泡算法,因为不会!工作三年多,这个算法算个试题吧,每次死记硬背,却没有理解,悲哀啊,其实也没多复杂,代码几行,第一个循环,代表比较次数,多少个数,就比较多少次-1,int i=0;i<a.length-1;i++这个是控制循环的。从第一个数开始比,比较几次呢,假如两个数,比较一次,假如三个数,二次,规律是减一,第二个循环,控制指针,从第几个数开始比,先看语法int j...

weixin_30922589的博客 102

SIMATIC S7-1200, S7-1500 PID 控制[手册]

SIMATIC S7-1200, S7-1500 PID 控制[手册]

冒泡排序法的理解

方便回忆: 冒泡排序法是先排序好最大的那个数字在数组最后面,再排倒数第二大的数字。。。以此类推。 void Bubble_Sort(int *num, int n) {     int i, j;     for(i = 0; i      {         for(j = 0; i + j          {             if(num[j] > 

qweasdzxcpkh的博客 2112

冒泡排序再理解

今天重新学习这个人人皆知的算法–冒泡排序 冒泡排序 1、从头依次访问数组每个元素,进行相邻元素之间的交换 2、元素之间两两交换,把小的换到前面,大的放到后面。 3、所有元素交换完成后,一趟交换完成,此时最大的元素会到数组尾部。 4、反复执行以上步骤,直到所有元素都排序完。   这个冒泡算法基本大家都学过,本人愚笨一直也没有深入理解这个算法,往往都是记住大概的代码样子,导致过了很久完全不记得冒泡...

无痕之意的博客 2366

深入理解冒泡排序

>> 冒泡排序 冒泡排序可能非你所想。 冒泡排序的思路: 给定一个数组,每次循环出最大的数依次向后排,并将较小的数向前冒。 平均时间复杂度: O(n^2) 最好情况: O(n) 已经排好序 最坏情况: O(n^2) 倒叙的时候 空间复杂度: O(1) 没有占用额外的空间 稳定性: 稳定 排序前相等的两个数,排序后位置不变 : ) 快速排序值得注意的是:第一层循...

qq_37744360的博客 271

冒泡排序理解难点的解析

如果代码标记起始的符号是1,那么你的理解没有任何问题,但是,java代码计算循环次数的符号是0,那么记录第一趟循环的标记符号是0,内层循环的次数是9,那么0+9 = 9。冒泡排序在学习过程中,很多人感觉很难学习,其实主要的难点在于内外两层循环次数的控制次数的理解,内部循环体,也就是两个相邻数据的交换并不是难于理解。如果代码标记起始的符号是1,那么记录第一趟循环的标记符号是1,内层循环的次数是9,那么1+9 = 10。难于理解的地方需要我们解释一下,java代码中重要的两行代码如下,其余的就不写了。

weixin_39357208的博客 319

冒泡排序简单理解

原理 冒泡排序 人如其名 就像泡泡一样,较大的数从下面一个一个与其他数进行比较,如果依然较大则继续往上浮。 一个数列有 $n$个数字,我们每个数字循环一遍(外层循环),第i个数在最坏情况下(完全与目标结果相反)还需要交换$ n-i $次(内层循环)所以冒泡排序并不是很稳定的 最坏情况达到 $O(n^2)$ 依然不理解的话,可以手动模拟一下,其实就相当于每一轮外层循环会确定一个第n大(小)值。在 $n$轮后就是有序的了。 ## 2.2 代码 ```cpp #include <bits/std

weixin_44608143的博客 189

冒泡排序深入理解

冒泡排序深入理解 题目全部来自洛谷 对于冒泡排序有一个小性质: 每一次都会把序列未排好序的最大数"沉底", 即推到序列尾部 1.P4378 Out of Sorts S 留意着农场之外的长期职业生涯的可能性,奶牛Bessie开始在不同的在线编程网站上学习算法。 她到目前为止最喜欢的算法是“冒泡排序”。这是Bessie的对长度为N的数组A进行排序的奶牛码实现。 sorted = false wh...

qq_42720646的博客 501

好记好理解的冒泡排序

给出一个数组,如何通过冒泡排序的方法进行排序? 代码如下: package pb.com.home; public class Maopao { public static void main(String[] args) { int[] nums ={0,80,7,8,22,110}; //外层循环:轮 内层循环:每轮比较几次

qacjava的博客 331

Java中对冒泡排序的深入理解

程序员不仅要学会敲代码,更要学会算法与数据结构,算法与数据结构是程序员的必修课程,今天我就来讲讲如何理解并进行实践冒泡排序。 对冒泡排序的理解: 题目:请把(3 2 1 8 10 6 4 9)按照从小到大的顺序用冒泡排序排列出来 参与排序的数字;3 2 1 8 10 6 4 9 第一次循环: 2 3 1 8 10 6 4 9(2与3比较):不交换 2 1 3 8 10 6 4 9(3与1比较):交换 2 1 3 8 10 6 4 9(3与8比较):不交换 2 1 3 8 10 6 4 9(8与10比较).

优快云_XHC的博客 168

关于js冒泡排序的理解

呈上冒泡排序的代码 var arr=[2,7,3,1,4,8,9,0]; for(var i=0;i<arr.length-1;i++){ for(var j=0;j<arr.length-1-i;j++){ if(arr[j]<arr[j+1]){ var temp=arr[j]; arr[j]=arr...

Locker的博客 364
上一篇: 转载 关于bufferedInputStream的理解
下一篇: mac搭建elk
micro_cloud_fly
博客等级 码龄12年 321粉丝 222原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

micro_cloud_fly

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值