冒泡排序

1、算法步骤：

1)比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2)对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

3)针对所有的元素重复以上的步骤，除了最后一个。

4)持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

2、代码

import java.util.Arrays;

/**

* 实现冒泡排序

* @author dell

*

*/

public class BubbleSort {

public static void main(String[] args) {

int[] arr = {1,200,19,55,10,22,3,7};

//API实现

Arrays.sort(arr);

System.out.println(Arrays.toString(arr));

//冒泡实现

int temp;

for(int i =0;i

for(int j = 0;j

if(arr[j]>arr[j+1]){

temp = arr[j];

arr[j]=arr[j+1];

arr[j+1]=temp;

}

}

}

System.out.println(Arrays.toString(arr));

}

}

优化的冒泡排序

由于可能在前几次就已经排好序，但是在上一种冒泡排序中仍然需要一直遍历到最后。

优化措施：设置一个标志，如果这一趟发生了交换，则为true，否则为false。明显如果有一趟没有发生交换，说明排序已经完成。

package bubbleSort;

import java.util.Arrays;

import org.junit.Test;

/**

* 冒泡排序的性能分析和算法优化(外层循环优化)

* @author dell

*

*/

public class BubbeSort02 {

@Test

public void test1(){

boolean flag = true;

int[] arr = {2,1,3,4,5};

int temp;

for (int i = 0; i < arr.length-1; i++) {

for (int j = 0; j < arr.length-1-i; j++) {

if(arr[j]>arr[j+1]){

temp=arr[j];

arr[j]=arr[j+1];

arr[j+1]=temp;

flag=false;

}

}

if(!flag){

//没有发生交换则退出循环；

break;

}

}

System.out.println(Arrays.toString(arr));

}

}

选择排序

1、算法步骤：

1)首先在未排序序列中找到最小(大)元素，存放到排序序列的起始位置

2)再从剩余未排序元素中继续寻找最小(大)元素，然后放到已排序序列的末尾。

3)重复第二步，直到所有元素均排序完毕

2、代码

public static int[] ChoseSort(int[] a) {

for (int i=0;i

int lowIndex = i;

for (int j=i+1;j

if (a[j]

lowIndex=j;

}

}

int temp = a[i];

a[i] = a[lowIndex];

a[lowIndex] = temp;

}

return a;

}

public static void main(String[] args) {

int[] a = { 10, 20, 9, 2, 22, 49, 1 };

Arrays.sort(a);

System.out.println(Arrays.toString(a));

System.out.println("================");

int[] bubbleSort = ChoseSort(a);

System.out.println(Arrays.toString(bubbleSort));

}