冒泡排序(内排序)

主要是相邻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             // 最外层循环控制需要多少趟
10             for (int i = 0; i < array.length; i++) {
11                 // 内层循环控制每趟需要比较多少次,内循环走完时,最大的一个记录已经被挪到当前循环长度的末尾了,下一趟就劈开他不再跟他进行比较了,大数沉底了
12                 for (int j = 0; j < array.length - i - 1; j++) {
13                     // 如果发现后面的记录比当前记录大就进行交换
14                     if (array[j] > array[j + 1]) {
15                         int temp = array[j];
16                         array[j] = array[j + 1];
17                         array[j + 1] = temp;
18                     }
19                 }
20             }
21         }
22         return array;
23     }
24 }

 1 package com.trfizeng.test;
 2
 3 import com.trfizeng.changesort.BubbleSort;
 4 import com.trfizeng.insertionsort.StraightInsertionSort;
 5 import com.trfizeng.selectionsort.SimpleSelectionSort;
 6
 7 /**
 8  * 测试类
 9  *
10  * @author trfizeng
11  *
12  */
13 public class SortTest {
14     // 待排序数组
15     static int[] array = new int[] { 6, 1, 4, 10, 11, 8, 7, 1, 0 };
16
17     /**
18      * 直接插入排序法测试
19      */
20     public static void straightInsertionSortTest() {
21         System.out.print("待排序数组:[ ");
22         for (int i = 0; i < array.length; i++) {
23             System.out.print(array[i] + " ");
24         }
25         System.out.print("]   ");
26
27         array = StraightInsertionSort.straightInsertionSort(array);
28         System.out.print("排好序的数组:[ ");
29         for (int i = 0; i < array.length; i++) {
30             System.out.print(array[i] + " ");
31         }
32         System.out.print("]");
33     }
34
35     /**
36      * 选择排序
37      */
38     public static void simpleSelectionSort() {
39         System.out.print("待排序数组:[ ");
40         for (int i = 0; i < array.length; i++) {
41             System.out.print(array[i] + " ");
42         }
43         System.out.print("]   ");
44
45         array = SimpleSelectionSort.simpleSelectionSort(array);
46         System.out.print("排好序的数组:[ ");
47         for (int i = 0; i < array.length; i++) {
48             System.out.print(array[i] + " ");
49         }
50         System.out.print("]");
51     }
52
53     /**
54      * 冒泡排序
55      */
56     public static void bubbleSort() {
57         System.out.print("待排序数组:[ ");
58         for (int i = 0; i < array.length; i++) {
59             System.out.print(array[i] + " ");
60         }
61         System.out.print("]   ");
62
63         array = BubbleSort.bubbleSort(array);
64         System.out.print("排好序的数组:[ ");
65         for (int i = 0; i < array.length; i++) {
66             System.out.print(array[i] + " ");
67         }
68         System.out.print("]");
69     }
70
71     public static void main(String[] args) {
72         // SortTest.straightInsertionSortTest();
73
74         // SortTest.simpleSelectionSort();
75
76         SortTest.bubbleSort();
77     }
78 }

时间: 2024-10-05 04:58:31

冒泡排序(内排序)的相关文章

内排序-冒泡排序

算法思想:从前往后对相邻的元素进行两两比较交换,每一趟会将最小或最大的元素"浮"到末端,最终达到完全有序 package Sort; import fangwei.DirectSort; public class BubbleSort { public static void main(String[] args) { int[] a = new int[] { 20, 30, 90, 40, 70, 110, 60, 10, 100, 50, 80, 1, 2 }; BubbleSo

算法 排序lowB三人组 冒泡排序 选择排序 插入排序

参考博客:基于python的七种经典排序算法   [经典排序算法][集锦]     经典排序算法及python实现 首先明确,算法的实质 是 列表排序.具体就是操作的列表,将无序列表变成有序列表! 一.排序的基本概念和分类 所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作.排序算法,就是如何使得记录按照要求排列的方法. 排序的稳定性: 经过某种排序后,如果两个记录序号同等,且两者在原无序记录中的先后秩序依然保持不变,则称所使用的排序方法是稳定的,反之是不稳定

内排序—数组实现(c++)

1 参考资料:数据结构与算法分析(第三版)(c++) 2 http://blog.csdn.net/theprinceofelf/article/details/6672677 3 4 5 6 7 内排序,均采用数组实现,数组有较多的局限性,这些实现是为了去了解排序算法 8 的操作流程 9 10 #include<iostream> 11 using namespace std; 12 13 void Swap(int &a,int &b); 14 void Print(int

Lua中table内建排序与C/C++/Java/php/等内排序算法的排序效率比较

Lua这类脚本语言在处理业务逻辑作为配置文件的时候方便省事 但是在大量需要 运算的地方就显得略微不足   按照 Lua内建排序算法 对比C/C++ PHP Java等的快速排序算法进行一下比较. 快速排序算法是基于冒泡排序,优化而来,时间复杂度T(n)=O(nLog2n)  ,可见内部采用了二分策略 . 发现在LuaIDE LDT下直接运行效率要比 通过C++加载运行Lua脚本效率高的多  拿500W个数据排序 来说  ,脚本如下 同样的排序脚本Lua解释器的内置排序算法在LDT下,运行速度比通

常见排序集合(冒泡排序,选择排序,直接插入排序,二分插入排序,快速排序,希尔排序,归并排序)

一下是一些常见的排序算法: 交换元素(后面算法都有用到): // 交换元素 private static void swap(int[] a, int i, int j) { int temp; temp = a[i]; a[i] = a[j]; a[j] = temp; } 冒泡排序(有优化): // 冒泡排序(优化①,②,③,④) private static void bubbleSort(int[] a) { boolean flag = false;// ①表示整个序列是无序的 for

复习数据结构:排序算法(二)——冒泡排序

这篇复习冒泡排序.     冒泡排序也是一种稳定排序.内排序. 冒泡排序的基本思想:对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒.即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换. 插入排序比冒泡排序快! 上面说的是普通的冒泡排序算法,时间复杂度是O(n^2),这种方法只能一趟排序操作只能找到一个最大值或最小值,消耗时间太多.     改进方法1:我们可以让每趟排序中进行正向和反向两遍冒泡的方法,一次就可以同时得到

数据结构--内排序

直接插入排序 #include <STDIO.H>typedef int Keytype;typedef struct{ Keytype key; int data; }RecType;void InsertSort(RecType R[],int n){ int i; int j; RecType temp; for(i=1;i<n;i++) { temp=R[i]; j=i-1; while (j>=0&&temp.key<R[j].key) { R[j+

常用排序算法实现[交换排序之冒泡排序、快速排序]

相关知识 1. 稳定排序和非稳定排序: 稳定排序算法会依照相等的关键(换言之就是值)维持纪录的相对次序. 如果排序算法是稳定的,就是当有两个有相等关键的纪录R和S,且在原本的列表中R出现在S之前,在排序过的列表中R也将会是在S之前. 2. 内排序和外排序 在排序过程中,所有需要排序的数都在内存,并在内存中调整它们的存储顺序,称为内排序: 在排序过程中,只有部分数被调入内存,并借助内存调整数在外存中的存放顺序排序方法称为外排序. 3.算法分类 排序算法从理论上分为如下几类: (1) 交换排序法:

排序 之 冒泡排序 简单选择排序 直接插入排序 希尔排序

排序的基本概念 假设含有n个记录的序列为{r1,r2,--,rn},其相应的关键字分别为{k1,k2,--,kn},需确定1,2,--,n的一种排序p1,p2,--,pn,使其相应的关键字满足kp1≤kp2≤--≤kpn非递减(或非递增)关系,即使得序列称为一个按关键字有序的序列{rp1,rp2,--,rpn},这样的操作就称为排序. 排序的稳定性 假设ki=kj(1≤i≤n,1≤j≤n,i≠j),且在排序前的序列中ri领先于rj(即i<j).如果排序后ri仍领先于rj,则称所用的排序方法是稳定