数据结构中的几个排序冒泡排序算是最简单的一个了,基本的思路就是从最开始的一个元素依次和后面的元素比较,如果后面的元素比较小,那就和第一个元素交换,就这样,从第一个比较到最后一个. 代码实现:
/**
* 冒泡排序
*/
public class BubbleSort {
/**
* 移动次数少,循环次数多
* @param arr
*/
public static void sort1(int[] arr){
int times = 0;
//依次遍历整个数组
for (int i = 0; i < arr.length-1; i++) {
//将当前的元素与后面的元素依次比较,如果后面的元素比较大,则交换位置
for (int j = i+1; j < arr.length; j++) {
times++;
if(arr[i]>arr[j]){
int temp=arr[i];
arr[i]=arr[j];
arr[j] = temp;
}
}
}
System.out.println("sort1执行了"+times+"次");
}
public static void sort2(int[] arr){
int times = 0;
for (int i = 0; i < arr.length-1; i++) {
for (int j = 0; j < arr.length-1-i; j++) {
times++;
if(arr[j]>arr[j+1]){
int temp=arr[j+1];
arr[j+1]=arr[j];
arr[j] = temp;
}
}
}
System.out.println("sort2执行了"+times+"次");
}
public static void sort3(int[] arr){
int times = 0;
boolean flag = true;
for (int i = 0; i < arr.length-1; i++) {
flag = true;
for (int j = 0; j < arr.length-1-i; j++) {
times++;
if(arr[j]>arr[j+1]){
int temp=arr[j+1];
arr[j+1]=arr[j];
arr[j] = temp;
flag = false;
}
}
if(flag)
break;
}
System.out.println("sort3执行了"+times+"次");
}
public static void sort4(int[] arr){
int times = 0;
int flag = 0;
int n = arr.length-1;
for (int i = 0; i < arr.length-1; i++) {
for (int j = 0; j < n; j++) {
times++;
if(arr[j]>arr[j+1]){
int temp=arr[j+1];
arr[j+1]=arr[j];
arr[j] = temp;
flag = j;
}
}
n = flag;
if(i>=n)
break;
}
System.out.println("sort4执行了"+times+"次");
}
public static void print(int[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+"\t");
}
}
public static void main(String[] args) {
int[] arr = {1,5,4,11, 18,20};
sort1(arr);
print(arr);
System.out.println();
int[] arr2 = {1,5,4,11, 18,20};
sort2(arr2);
print(arr2);
System.out.println();
int[] arr3 = {1,5,4,11, 18,20};
sort3(arr3);
print(arr3);
System.out.println();
int[] arr4 = {1,5,4,11, 18,20};
sort4(arr4);
print(arr4);
System.out.println();
}
}
第一种排序和第二种排序执行的次数是一样的.
第三种和第四种是基于第二种进行的改进.
第三种排序进行了是否移位的判断,如果一次内循环过后,没有进行交换,则代表数组的顺序已经是排序完成的.
第四种排序每次内循环的时候记录最后一次交换的位置,然后下次循环的时候只循环到上次交换的位置.(因为最后一次交换的位置之后的顺序都是正常排序后的)
