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

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;iarr[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;iarr[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

 

来源：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(ik) j--;
			//找到小于等于arr[k]的数
			if(i