排序方法之冒泡排序

冒泡排序

冒泡排序:是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，将较大的元素往后放,第一次比较完毕,最大值放在最后,依次这样比较,直到数列没有在需要交换,排序完成。

冒泡排序的规律

1) 两两比较,将数据大的放后面
2)第一次比较,所有的数据都进行比较
	第二次比较,最大的数不比较,其他都比较
	第三次比较,最大的两位不比较,其他都比较
	......
	最终剩余的两位数据比较

实现冒泡排序的几种代码

第一种

第一次比较,排序
第二次比较,排序
第三次比较,排序
…
比较完成,排序
实现:

class ArrayTest{
	public static void main(String[] args){
		//定义一个静态数组
		int arr[] = {14,4,36,5,1};
		System.out.println("遍历数组的对象:");
		printArray(arr);
		//这样遍历时,数组里的值过多时,费时又费力,不划算
		//不建议使用这种遍历方式
		//复杂的,写的最多的排序
		//第一次比较
		for(int x=0;x<arr.length-1-0;x++){
			if(arr[x]>arr[x+1]){
				int temp = arr[x];
				arr[x] = arr[x+1];
				arr[x+1] = temp;
			}
		}
		System.out.println("第1次比较之后的结果:");
		printArray(arr);
		//第二次比较
		for(int x=0;x<arr.length-1-1;x++){
			if(arr[x]>arr[x+1]){
				int temp = arr[x];
				arr[x] = arr[x+1];
				arr[x+1] = temp;
			}
		}
		System.out.println("第2次比较之后的结果:");
		printArray(arr);
		//第三次比较
		for(int x=0;x<arr.length-1-2;x++){
			if(arr[x]>arr[x+1]){
				int temp = arr[x];
				arr[x] = arr[x+1];
				arr[x+1] = temp;
			}
		}
		System.out.println("第3次比较之后的结果:");
		printArray(arr);
		//第四次比较
		for(int x=0;x<arr.length-1-3;x++){
			if(arr[x]>arr[x+1]){
				int temp = arr[x];
				arr[x] = arr[x+1];
				arr[x+1] = temp;
			}
		}
		System.out.println("第4次比较之后的结果:");
		printArray(arr);
		//第五次比较
		for(int x=0;x<arr.length-1-4;x++){
			if(arr[x]>arr[x+1]){
				int temp = arr[x];
				arr[x] = arr[x+1];
				arr[x+1] = temp;
			}
		}
		System.out.println("第5次比较之后的结果:");
		printArray(arr);
	}
	//遍历数组对象
	public static void printArray(int[] array){
		System.out.print("[");
		for(int x=0;x<array.length;x++){
			//判断x的取值,是否是最大索引值,
			//是,输出x的值,否,输出中间的数
			if(x==array.length-1){
				System.out.println(array[x]+"]");
			}else{
				System.out.print(array[x]+", ");
			}
		}
	}
}

实现结果:

第二种

对第一种代码进行初始优化
使用循环嵌套,对一维数组中的数据进行简单优化,一维数组中的数据较少时可以使用.
实现:

class ArrayTest{
	public static void main(String[] args){
		//定义一个静态数组
		int arr[] = {14,4,36,5,1};
		System.out.println("遍历数组的对象:");
		printArray(arr);
		//使用循环,对上述代码进行优化
		for(int x=0;x<5;x++){
			for(int y=0;y<arr.length-1-x;y++){
				if(arr[y]>arr[y+1]){
					int temp = arr[y];
					arr[y] = arr[y+1];
					arr[y+1] = temp;
				}
			}
		}
		System.out.println("冒泡排序之后的结果为:");
		printArray(arr);
	}
	//遍历数组对象
	public static void printArray(int[] array){
		System.out.print("[");
		for(int x=0;x<array.length;x++){
			//判断x的取值,是否是最大索引值,
			//是,输出x的值,否,输出中间的数
			if(x==array.length-1){
				System.out.println(array[x]+"]");
			}else{
				System.out.print(array[x]+", ");
			}
		}
	}
}

是直接输出冒泡排序之后的结果

第三种

对第二种代码进行优化,当一维数组中的数据较多,数不过来时.,使用第三种方法…
实现:

class ArrayTest{
	public static void main(String[] args){
		//定义一个静态数组
		int arr[] = {14,4,36,5,1};
		System.out.println("遍历数组的对象:");
		printArray(arr);
		for(int x=0;x<arr.length-1;x++){
			for(int y=0;y<arr.length-1-x;y++){
				if(arr[y]>arr[y+1]){
					int temp = arr[y];
					arr[y] = arr[y+1];
					arr[y+1] = temp;
				}
			}
		}
		System.out.println("优化后冒泡排序的结果为:");
		printArray(arr);
	}
	//遍历数组对象
	public static void printArray(int[] array){
		System.out.print("[");
		for(int x=0;x<array.length;x++){
			//判断x的取值,是否是最大索引值,
			//是,输出x的值,否,输出中间的数
			if(x==array.length-1){
				System.out.println(array[x]+"]");
			}else{
				System.out.print(array[x]+", ");
			}
		}
	}
}

也是直接输出冒泡排序之后的结果

第四种

使用功能定义对数组进行冒泡排序
实现:

class ArrayTest{
	public static void main(String[] args){
		//定义一个静态数组
		int arr[] = {14,4,36,5,1};
		System.out.println("遍历数组的对象:");
		printArray(arr);
		//使用功能定义对数组进行冒泡排序
		System.out.println("使用功能定义对数组进行冒泡排序:");
		bubbleSort(arr);
		printArray(arr);
	}
	//进行冒泡排序(Bubble sort:冒泡排序)
	public static void bubbleSort(int[] array){
		for(int x=0;x<array.length-1;x++){
			for(int y=0;y<array.length-1-x;y++){
				if(array[y]>array[y+1]){
					int temp = array[y];
					array[y] = array[y+1];
					array[y+1] = temp;
				}
			}
		}
	}
	//遍历数组对象
	public static void printArray(int[] array){
		System.out.print("[");
		for(int x=0;x<array.length;x++){
			//判断x的取值,是否是最大索引值,
			//是,输出x的值,否,输出中间的数
			if(x==array.length-1){
				System.out.println(array[x]+"]");
			}else{
				System.out.print(array[x]+", ");
			}
		}
	}
}

最终结果参考前面几种方法所求出的结果
以上就是本初学者对冒泡排序的一些理解了