改进的冒泡排序算法二

/**
 * Project Name:Algorithm
 * File Name:BubbleSortImprove2.java
 * Package Name:
 * Date:2017年9月14日上午11:30:48
 * Copyright (c) 2017, [email protected] All Rights Reserved.
 *
 */

/**
 * ClassName:BubbleSortImprove2
 * Function: 改进的冒泡排序算法, 测试数据集:6 3 5 7 0 4 12.
 * Reason:    (基于改进方法一的基础上) 在对数据集进行从小到大排序的过程中,在进行第一次排序后,发现后面几位数字基本有序了,没必要再做对比。
 *              如果R[0..i]已是有序区间,上次的扫描区间是R[i..n],记上次扫描时最后 一次执行交换的位置为lastSwapPos,
 *             则lastSwapPos在i与n之间,不难发现R[i..lastSwapPos]区间也是有序的,否则这个区间也会发生交换;
 *             所以下次扫描区间就可以由R[i..n] 缩减到[lastSwapPos..n]。
 * Date:     2017年9月14日 上午11:30:48
 * @author   michael
 * @version
 * @since    JDK 1.7
 * @see
 */
public class BubbleSortImprove2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String input = "";
        while (sc.hasNext()) {
            input = sc.nextLine();
            System.out.println("输入值:" + input);
            long startTime = System.currentTimeMillis();
            String[] str = input.split(" ");
            int[] arr = new int[str.length];
            // 字符串数组转化成int数组
            for (int i = 0; i < str.length; i++) {
                arr[i] = Integer.parseInt(str[i]);
            }
            int pos = arr.length-1;
            boolean isChange = false;
            for (int i = 0; i < arr.length - 1; i++) {
                for (int j = 0; j < pos; j++) {
                    int temp;
                    if (arr[j] > arr[j + 1]) {
                        temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                        isChange = true;
                    }
                    if(!isChange){
                        pos = j;
                        continue;
                    }
                }
                System.out.println();
                System.out.print("第" + (i + 1) + "次循环结果:");
                for (int j = 0; j < arr.length; j++) {
                    System.out.print(arr[j]);
                }
            }
            long endTime = System.currentTimeMillis();
            System.out.println();
            System.out.println();
            System.out.println("最终排序结果:");
            for (int j = 0; j < arr.length; j++) {
                System.out.print(arr[j]);
            }
            System.out.println("程序运行时间:" + (endTime - startTime) + "ms");
        }
    }
}

时间: 2024-08-24 04:26:07

改进的冒泡排序算法二的相关文章

改进的冒泡排序算法一

/** * Project Name:Algorithm * File Name:BubbleSortImprove1.java * Package Name: * Date:2017年9月14日上午11:07:21 * Copyright (c) 2017, [email protected] All Rights Reserved. * */ /** * Project Name:Algorithm * File Name:BubbleSortImprove1.java * Package

一个名声不好的排序算法(二)——冒泡排序算法

转载请注明出处,谢谢! 冒泡排序算法思想: 自下而上(或上而下)扫描记录序列,相邻的两条记录Ri与Ri-1(或Ri+1)如果是逆序,则交换位置. 交换排序 冒泡排序 快速排序 算法说明 一个名声不太好的算法 排序是稳定的 ArrayList实现: import java.util.ArrayList; import java.util.Random; public class Bubble { public static void sort(ArrayList<Integer> al) { i

js冒泡排序算法改进

// 冒泡排序算法 function bubbleSort(arr) { console.log('排序算法第0次:' + arr.join(',')); var len = arr.length; var lastIndex = 0; // 最后标记的脚标 var sortBorder = len - 1; // 需交换最大的次数 for (var i = 0; i < len - 1; i++) { let isSort = true; for (var j = 0; j < sortBo

冒泡排序算法(Java)

 冒泡排序即每次遍历.相邻数字间进行比較,前者大于后者进行交换,不断将最大值后移,直至沉至最后位置:算法关键要点在于确定每次循环的边界. 后面两种算法则是对冒泡排序一定程度上的改良,但相对于其它排序算法,冒泡排序性能依旧较差. //冒泡排序 public class Bubble_Sort { //最原始的解法 public void bubble_sort1(int[] data) { int n = data.length; for(int i = 0; i < n; i++) { //

白话经典算法二叉堆排序之思想简介

常用的排序算法有冒泡排序,插入排序和选择排序.他们的时间复杂度是o(n2),与数据量的平方成正比.他们的效率还是比较低的.现在来说说他们的效率为什么比较低下.以冒泡排序为例,它每一轮都是与相邻的元素进行交换,交换的距离为1,每次每个(没有冒泡出来的)元素都要与前一个比较再交换.每次相邻的比较只能比较出两个元素的大小,不能以整个数组进行参照来确定在整个数组里的大小,也就是说每次的比较不能确定其他元素的相对位置,因而每次比较的贡献不大,所以这样的比较是笨拙的,进而需要完全比较O(n2)次才能得出正确

冒泡排序算法-python实现

1 ''' 2 冒泡排序算法及其优化 3 冒泡排序的基本特征是只能交换相邻的元素. 4 从下边界开始,一趟扫描下来,可以把当前最大值顶到上边界: 5 如果没有发生交换操作,则表示数组是有序的. 6 ''' 7 8 9 # 算法一:基本冒泡排序 10 def BubbleSort_1(arr): 11 # 外层循环累计排序轮数,同时控制待排序数组的上边界,即A[0..i]为待排序部分 12 # 内层循环扫描A[0..i-1],比较相邻元素,并通过交换元素值的方式将最大值顶到最上方 13 for i

两种改进的模拟退火算法求解大值域约束满足问题1.0

0引言 约束满足问题(Constraint Satisfaction Problem,CSP)是人工智能研究领域中一个非常重要的分支,现已成为理论计算机科学.数学和统计物理学等交叉学科研究中的热点问题.人工智能.计算机科学和自动控制等领域中的许多问题都可以归结为约束满足问题.同时,约束满足问题在实际问题如模式识别.决策支持.物流调度及资源分配等领域也有着非常广泛的应用. CSP由一个变量集合和一个约束集合组成.每个变量都有一个非空的可能值域,每个约束描述了一个变量子集与子集内各变量的相容赋值,所

冒泡排序算法

冒泡排序(Bubble Sort)是一种简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端. 本文地址:http://www.cnblogs.com/archimedes/p/bubble-sort-algorithm.html,转载请注明源地址. 冒泡排序对n个项目需要O(n2)的比较次数,且可以原地排序.尽

[整理]改进的冒泡排序

冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端,故名. /// <summary> /// 改进的冒泡排序 /// </summary> /// <param name="array">待排序的数组&l