冒泡排序

对于一个初级程序员的我一直对算法不是很吃透，所以这几天补习了一些排序算法。 这篇博文分析冒泡排序的思想和实现。 如有错误请大家指正！！！ 1.冒泡排序的思想 它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。（百度百科） 2.冒泡排序的实现 package com . imun . test . sort ; public class NumSort { private static final int [ ] NUM_ARR = { 54 , 26 , 93 , 17 , 77 , 31 , 44 , 55 , 20 } ; public static void bubbleSort ( ) { int [ ] numArr = NUM_ARR ; // 临时变量，用于交换位置 int temp = 0 ; // 交换次数 int swapCount = 0 ; for ( int i = 0 ; i < numArr . length - 1 ; i ++ ) { for ( int j = 0 ; j < numArr . length - 1 - i ; j ++ ) { if ( numArr [ j ] > numArr [

冒泡排序：共比较n-1趟，每次让最大的元素沉底。 void bubble_sort ( int a [ ] , int length ) { int i , j ; for ( i = 0 ; i < length - 1 ; i ++ ) { for ( j = 0 ; j < length - 1 - i ; j ++ ) { if ( a [ j ] > a [ j + 1 ] ) { swap ( & a [ j ] , & a [ j + 1 ] ) ; } } } } 选择排序：共比较n-1趟，每一趟将最小的元素放在顶端 void select_sort ( int a [ ] , int length ) { int i , j ; for ( i = 0 ; i < length - 1 ; i ++ ) { for ( j = i + 1 ; j < length ; j ++ ) { if ( a [ i ] > a [ j ] ) { swap ( & a [ i ] , & a [ j ] ) ; } } } } 插入排序：共插n-1趟，每一趟的操作对象都是已经排好序的子数组，整个插入操作从第二个数开始即可。 void insert_sort ( int a [ ] , int length ) { int i , j ; for ( i = 1 ; i <

一. 概念 把相邻的两个元素进行比较，当一个元素大于右侧相邻元素时，交换他们的位置；否则，位置不变。 二. 举例 常规的冒泡排序——时间复杂度为O(n^2） 原始数列 进行第一趟排序 第一趟排序后的结果 进行第二趟排序 第二趟排序后的结果 第三到七趟的排序结果 冒泡排序改进 改进1：在第六轮排序后，整个数列已经有序，无需进行第七轮排序 ； 改进2：右边的很多元素已经排序过，已经是有序的，无需每次都比较。 三. Java实现 代码 import java.util.Arrays; public class MySort { public static void sort (int[] array) { //最后一次交换的位置 int lastExchangeIndex = 0; //无序数列的边界，每次比较到此为止 int sortBorder = array.length - 1; for (int i = 0; i < array.length - 1; i++) { //有序标记，每一轮的初始值都是true boolean isSorted = true; for (int j = 0; j < sortBorder; j++) { int temp = 0; if (array[j] > array[j+1]) { temp = array[j]; array[j] =

从中学习的代码 自己练习加深记忆 思想: 冒泡排序就是两层for循环，每次让一个最大的数放在最后，循环arr.length-1后他就会排好顺序，当然，也有可能不到哪个次数他就会排好循序 最好时间复杂度:O(n) 最坏时间复杂度:O(n2) 平均时间复杂度:O(n2) import java.util.Arrays; public class Sort { public static void main(String[] args) { int[] arr = {19,91,8,17,1,9,5,99,9,56,2,94,56,22}; // quickSort(arr, 0, arr.length - 1); maoSort(arr); System.out.println(Arrays.toString(arr)); } public static void maoSort(int[] arr) { for(int i=0;i<arr.length;i++) { //加个判断条件 如果那一次循环p没有变，没么证明已经排序好了，那就跳出循环，结束 boolean p=true; for(int j=0;j<arr.length-1;j++) { if(arr[j]>arr[j+1]) { int temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp

算法思想 　　冒泡排序属于一种典型的交换排序。 交换排序顾名思义就是通过元素的两两比较，判断是否符合要求，如过不符合就交换位置来达到排序的目的。冒泡排序名字的由来就是因为在交换过程中，类似水冒泡，小（大）的元素经过不断的交换由水底慢慢的浮到水的顶端。 冒泡排序的思想就是利用的比较交换，利用循环将第 i 小或者大的元素归位，归位操作利用的是对 n 个元素中相邻的两个进行比较，如果顺序正确就不交换，如果顺序错误就进行位置的交换。通过重复的循环访问数组，直到没有可以交换的元素，那么整个排序就已经完成了。 　　 这里引用了一位博主的一张图片感觉画的挺好！！！ 博主原文链接 程序代码 /** * 冒泡排序的实现 * 优点：简单、稳定 * @author qiu * 最好情况:顺序T=o(N) * 最坏情况:逆序T=o(N^2) */ public class BubbleSort { static void Bubble_Sort ( int [ ] a , int N ) { for ( int p = N - 1 ; p >= 0 ; p -- ) { int flag = 0 ; //设置一个标志位 for ( int i = 0 ; i < p ; i ++ ) { System . out . print ( " " + i ) ; ; if ( a [ i ] > a [ i +

这里写自定义目录标题 欢迎使用Markdown编辑器 新的改变 功能快捷键 合理的创建标题，有助于目录的生成 如何改变文本的样式 插入链接与图片 如何插入一段漂亮的代码片 生成一个适合你的列表 创建一个表格 设定内容居中、居左、居右 SmartyPants 创建一个自定义列表 如何创建一个注脚 注释也是必不可少的 KaTeX数学公式 新的甘特图功能，丰富你的文章 UML 图表 FLowchart流程图 导出与导入 导出 导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示； 增加了 图片拖拽 功能，你可以将本地的图片直接拖拽到编辑区域直接展示； 全新的 KaTeX数学公式 语法； 增加了支持 甘特图的mermaid语法 1 功能； 增加了 多屏幕编辑 Markdown文章功能； 增加了 焦点写作模式、预览模式、简洁写作模式

数据 结构 是 计算机 存储、组织 数据 的方式。数据结构是指相互之间存在一种或多种特定关系的 数据元素 的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储 效率 。数据结构往往同高效的检索 算法 和 索引 技术有关。 图形结构 树形结构 线性结构 集合结构 1.冒泡排序 在进行冒泡法排序（升序）时，将第一个数与后继的数进行比较，如果顺序则继续第二个数与后继的数进行比较；如果逆序则交换位置，继续和后继的数进行比较，完成第一趟冒泡排序。同理，直到数组有序。 如果经过一趟冒泡排序不发生数据交换说明数组原本有序。 最好时间复杂度：O(n) 平均时间复杂度：O(n^2) 最坏时间复杂度： O(n^2) 空间复杂度： O(1) 代码示例 /** * 冒泡排序 * * @param array * @return 相邻数据对比，交互位置 */ public static int[] bubblingSort(int[] array) { //从后一位开始循环对比，直到循环完。 for (int i = array.length - 1; i > 0; i--) { boolean flag = true; //把最大的筛选到最后 for (int j = 0; j < array.length - 1; j++) { if (array[j] > array[j + 1]) {

选择排序和冒泡排序不管是在算法的思路上还是代码的实现上都差别不大。不同在于，选择排序可以算作是冒泡排序的一种改进，这种改进主要体现在数据的移动次数上面。冒泡排序每次比较后，如果后面的元素有和比当前的元素大或者小，就会交换位置。而选择排序，比较后是记录当前的最小值得位置，一趟比较完成后才做交换。这样的话，就减少了交换的次数。 选择排序的代码实现如下： #include "stdafx.h" #include <iostream> using namespace std; void print(int data[], int n) { for (int i = 0; i < n; i++) { cout << data[i] << " "; } cout << endl; } void select_ascending_sort(int data[], int len) { int i = 0, j = 0, temp = 0, x = 0; for (i = 0; i < len; i++) { temp = data[i];//temporarily store this value for (j = i + 1; j < len; j++) { if (temp > data[j]) { temp = data[j];//save this sort fo minimum x =

快速排序 快速排序是通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数都比另外一部分的所有数都要小，然后再按这个方法对这两部分数据分别进行排序。这里初始化i=-1，p=0,r=7,j从0至7，这里有一个循环过程，就是拿序列里面的六个元素与第六个元素（基准元素）进行比较，如果元素小于基准元素，i+=1，交换list[i]和list[j]的顺序，当j=0时，就是list[0]与list[0]置换，这里不变，但是第一个子空间已经增大了一个元素，list[0]<=list[r]；当j=1时，list[1]>=list[r]，这时不交换任何位置，但第二个子空间会随着j的增大而增加一个元素，这时的第三个子空间已经减少了两个元素了。依次的当j=6时，list[6]>=list[r]，不交换任何位置，而第三个子空间已经没有任何元素了。 def quicksort ( list , p , r ) : if p < r : q = partion ( list , p , r ) quicksort ( list , p , q ) quicksort ( list , q + 1 , r ) def partion ( list , p , r ) : i = p - 1 for j in range ( p , r ) : if list [ j ] <= list [ r ] :

冒泡排序，从列表头开始，将相邻两个元素进行比较，较大元素放后面，一轮下来，最大元素将会放在列表最后。进行多轮排序，元素将按顺序排好。 def bubble_sort ( self ) : for j in range ( len ( self ) - 1 ) : for i in range ( len ( self ) - 1 - j ) : if self [ i ] > self [ i + 1 ] : self [ i ] , self [ i + 1 ] = self [ i + 1 ] , self [ i ] a = [ 2 , 4 , 0 , 6 , 7 , 3 , 8 ] print ( len ( a ) ) bubble_sort ( a ) print ( a ) 来源： CSDN 作者： 奇遇猴头茹 链接： https://blog.csdn.net/houtougujx/article/details/104141372