排序算法总结——交换排序(冒泡排序和快速排序)

1.冒泡排序：

      也就是两两相互比较，最终完成排序。

package cn.liu.made;

/**
 * 数组两个数字进行交换
 * @author Dick
 *
 */
public class Sort {
	//交换m和n的值
	public static void sort(int[] arr,int m,int n) {
		int temp = arr[n];
		arr[n]=arr[m];
		arr[m]=temp;
	}
}

 

 冒泡排序和其改进版本（所谓的改进就是加一个标志位，当标志位没有变化的时候说明已经排好了，不用再比较直接退出）

package cn.liu.made;

import java.util.Arrays;

/**
 * 交换排序，冒泡算法实现,最大数往arr[arr.length-1]放，最小的在arr[0];
 * i+j恒等于arr.length-1
 * @author Dick
 *
 */
public class BubbleSort {
	public static int[] bubbleSort(int[] arr) {
		if(arr.length<2) {
			return arr;
		}
		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]) {
					Sort.sort(arr, j, j+1);
				}
			}
			System.out.println("第"+i+"趟："+Arrays.toString(arr));
		}
		return arr;
	}
	
 
 //冒泡的改进版
	public static int[] bubbleSortTwo(int[] arr){
		if(arr.length<2) {
			return arr;
		}
		boolean sign = false;//标志位
		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]) {
					Sort.sort(arr, j, j+1);
					sign=true;
				}else {
					sign=false;
				}
			}
			//标志位没变说明后面的顺序已经是排好顺序的
			if(sign==false) break;
			System.out.println("第"+i+"趟："+Arrays.toString(arr));
		}
		return arr;
	}
}

 

2.快速排序

        所谓的快排就是，通过一次排序让某个基准数（K）的左面都比这个K小，右面比K大。然后在让其基准数的左面部分或右面部分继续重复上面的排序，最后整个数组达到一个从小到大的顺序，反之则从大到小的顺序。

 

排序具体为：挖坑，栽萝卜。

（1）.假设数组下标0为i，数组下标arr.length-1为 j 。将数组左面第一个位置作为基准数，挖出来保存在K中。

（2）.从j开始查找，找到小于或等于k的数，挖出来，栽到 K（也就是 i 的位置）中去。

（3）从 i 开始找，找到大于K的数，挖出来，载到j中去。

循环上面的（2）（3）直到 i<j 这个条件不满足（说明本次所有数都已经比较过去）则跳出，此时 i 的位置还有一个坑把K栽进去。本次排序完成。

 

来源：https://www.runoob.com/w3cnote/quick-sort.html

 

package cn.liu.made;

import java.util.Arrays;

public class QuickSort {
	private static int m = 0;
	//对快排进行进一步封装
	public static int[] quick(int[] arr) {
		quickSort(arr, 0, arr.length-1);
		return arr;
	}
	
	
	private static void quickSort(int[] arr,int left,int right) {
		//递归结束条件   !!(right-left+1)<2一定要加1,是判断数量
		if((right-left+1)<2 || arr == null) return;
		int i = left;
		int j = right;
		int k = arr[left];//把基准数储存在k中，相当于把arr[0]的位置挖出来
		while(i<j) {
			//从数组右边开始找大的数
			while(i<j && arr[j]>k) j--;
			//找到小于等于arr[k]的数
			if(i<j) {
				//第一次i在0的位置，也是k得的位置
				arr[i]=arr[j];
			}
			//从数组左边开始找小的数
			while(i<j && arr[i]<=k) i++;
			//找到大于arr[k]的数
			if(i<j) {
				arr[j] = arr[i];
			}
		}
		//数组所有元素都搜找完，空的那个位置把基准数填进去
		arr[i] = k;
		m++;
		System.out.println("第"+m+ ":"+Arrays.toString(arr));
		//再递归调用，进行下一次
		quickSort(arr, left,i-1);
		quickSort(arr, i+1, right);
	}
}