交换排序(冒泡排序)

一、冒泡排序

第一次外循环( i=0):      n个数未排序,    要比较 n-1 次
第二次外循环(i=1):       n-1个数未排序, 要比较 n-2 次
第 n-1 外循环(i=n-2):   剩2个未排序,    要比较1次

(1+2+...+n-1)=n(n-1)/2

method1:

每次外循环过后,都有一个大的数沉底。

    public static void method1(int[] array){
        int n=array.length;
        for (int i = 0 ;i < n-1 ;i++ ) {
            for (int j = 0 ; j < (n-i)-1; j++ ){
                if ( array[j] > array[j+1] ){
                    int tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                 }
             }
        }
     }   

method2:

每次外循环过后,都有一个小的数浮上。

    public static void method2 ( int[] array ){
        int n=array.length;
        for ( int i = 0; i < n-1; i++ ){
            for ( int j = i + 1; j < n; j++ ){
                if (array[i] > array[j]){
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
    }

测试效果:

    public static void main(String[] args) {
        int[] array1 = {-5, 23,-5,99,-9, 2, 5, 10, 7, 16, 17};
        method1(array1);
        System.out.println (Arrays.toString (array1));  

        int[] array2 = {-5, 23,-5,99,-9, 2, 5, 10, 7, 16, 17};
        method2(array2);
        System.out.println (Arrays.toString (array2));
    }
时间: 2024-10-12 16:26:41

交换排序(冒泡排序)的相关文章

八大排序算法之五--交换排序—冒泡排序(Bubble Sort)

基本思想: 在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒.即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换. 算法实现:(HDU 1040 亲测 AC) #include<iostream> using namespace std; const int N =1005; void BubbleSort(int a[],int ); void print(int a[],int num); vo

交换排序—冒泡排序(Bubble Sort)

基本思想: 最简单的排序,也是最耗时间的排序 在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒.即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换. 冒泡排序的示例: 算法的实现: void bubbleSort(int a[], int n){ for(int i =0 ; i< n-1; ++i) { for(int j = 0; j < n-i-1; ++j) { if(a[j] > a

交换排序—冒泡排序(Bubble Sort)算法原理以及Java实现

基本思想: 在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒.即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换. 冒泡排序的示例: 算法实现 1 /** 2 * 3 * @author zhangtao 4 */ 5 public class BubbleSort 6 { 7 public static void main(String[] args) 8 { 9 int arr[]={3,1,5,

交换排序 —— 冒泡排序 + 改进

冒泡排序 冒泡排序是通过无序区相邻两个元素之间进行比较和位置交换,达到排序的目的. 插入排序是设定序列的 1 到 n-1 元素为无序区,初始有序区就只有 0 这个元素,然后将无序区中的元素和有序区中的元素逐个进行比较插入.从而是不断扩大有序区的范围.减少无序区的范围直至排序完成. 而冒泡排序则视整个序列均为无序区.即从 0 到 n-1 这些元素都位于无序区.直接对其中的元素进行比较,根据相邻元素大小比较的结果和想要的最终排序结果,对相邻元素的位置进行调整. 如:想要从小到大的排序结果,那么就对相

交换排序---冒泡排序

1 //冒泡排序 2 /** 3 * 5,8,3,15,14,68,17 4 * 5 * @param arr 6 */ 7 public static void bubbleSort(int[] arr){ 8 //控制比较多少轮 9 for(int i=0;i<arr.length-1;i++){ 10 for(int j=0;j<arr.length-1-i;j++){ 11 if(arr[j]>arr[j+1]){ 12 int temp=arr[j]; 13 arr[j]=ar

交换排序---冒泡排序算法(Javascript版)

比较相邻的元素.如果第一个比第二个大,就交换他们两个.对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应该会是最大的数.针对所有的元素重复以上的步骤,除了最后一个.持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较. function sort(elements){ for(var i=0;i<elements.length-1;i++){ for(var j=0;j<elements.length-i-1;j++){ if(elements[

冒泡排序(内排序)

主要是相邻2个记录的比较交换 1 package com.trfizeng.changesort; 2 3 /** 4 * @author trfizeng 内部排序 交换排序—冒泡排序(Bubble Sort) 5 */ 6 public class BubbleSort { 7 public static int[] bubbleSort(int[] array) { 8 if (array != null && array.length != 0) { 9 // 最外层循环控制需要多

(转载)排序一 冒泡排序

排序一 冒泡排序 目录 要点 算法思想 算法分析 冒泡排序算法的性能 时间复杂度 算法稳定性 优化 完整参考代码 JAVA版本 要点 冒泡排序是一种交换排序. 什么是交换排序呢? 交换排序:两两比较待排序的关键字,并交换不满足次序要求的那对数,直到整个表都满足次序要求为止. 算法思想 它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成. 这个算法的名字由来是因为越小的元素会经由交换慢慢"浮&q

#排序算法#【1】概述、冒泡排序、选择排序

排序算法分类: 内部排序(在排序过程中不需要访问外存就可以完成排序) 外部排序 内部排序分类: 交换排序 冒泡排序 快速排序 选择排序 直接选择排序 堆排序 插入排序 直接插入排序 希尔排序 合并排序 外部排序: 常见的是多路归并算法,即将原文件分为多个能够一次装入内存一部分,分别把每一部分调入内存完成排序,然后对已经排序的子文件进行归并排序 冒泡排序法: 冒泡排序法是一种相邻数据交换的排序方法. 冒泡排序法的基本思想是:对待排序记录关键字从后往前(逆序)进行多遍扫描,当发现相邻两个关键字的次序

八大排序算法的python实现(三)冒泡排序

代码: #coding:utf-8 #author:徐卜灵 #交换排序.冒泡排序 L = [1, 3, 2, 32, 5, 4] def Bubble_sort(L): for i in range(len(L)): for j in range(i+1,len(L)): if L[i]>L[j]: # temp = L[j] # L[j] = L[i] # L[i] = temp L[i], L[j] = L[j], L[i]#交换顺序 print L Bubble_sort(L) 冒泡排序应