排序算法 —— 快速排序 && 冒泡排序

快速排序

快排是一种不稳定的排序方法。

啥是 稳定性？：
稳定：原先a在b的前面，若a=b，排序后仍然是a在b的前面；
不稳定：原先a在b的前面，若a=b，排序后b可能在a的前面。

快速排序
思路：就像是不断的给基准值找位置的过程；
1.首先将原数组中的第1个数当作基准值（主元），借助左右指针移位，使得基准值左边的数都小于它，右边的都大于它。将此时基准值的下标返回作为分割的下标。
2.得到分割的下标后，递归实现左右两部分。
3.左右两部分处理过程同步骤一。

快排之单向扫描法
单向扫描法思路：step1:建立头尾指针，头指针开始扫描，当碰到比主元小的元素，头指针继续扫描；
step2:当碰到比主元大的元素，将其与尾指针指向的元素进行交换，并将尾指针向前移；
step3:然后继续从头指针开始扫描，…(同step1)

public class Main{
   //快排
	private static void quicksort(int []A,int p,int r){
		if(p < r){  //勿忘
		  int q = partition(A,p,r);
		  quicksort(A,p,q-1);
	      quicksort(A,q+1,r);
		}
	}
	
	//寻找分割下标的函数
	private static int partition(int[] A, int p, int r) {
		int pivot = A[p];  //基准值
		int sp = p+1;  //头指针，即扫描指针
		int bigger = r; //尾指针
		
		//当sp指针与bigger指针交错时即找到下标
		while (sp <= bigger){ 
			if(A[sp] <= pivot)  //扫描元素小于主元，左指针向右移
				sp++;
			else{
				swap(A,sp,bigger); //扫描元素大于主元，两指针的元素交换
				bigger--;
			}
		}
		swap(A,p,bigger);  
		return bigger;  
	}

	public static void swap(int[] A, int sp, int bigger) {
		int t = A[sp];
		 A[sp] = A[bigger];
		 A[bigger] = t; 
	}

	public static void main(String[] args) {
		int []A = {8,2,9,10,1,3};
		quicksort(A,0,5);
		for(int i=0;i<6;i++)
			System.out.print(A[i]);	
    }
}

快排之双向扫描法
思路：头尾指针往中间扫描，从左找大于主元的元素，从右找小于等于主元的元素二者交换，继续扫描，直到左侧无大元素，右侧无小元素。

	private static int parttion2(int[] A, int p, int r) {
		int t = A[p]; //基准值
		int left = p+1; //左扫描指针
		int right = r; //右扫描指针
		
		while(left <= right){
			while(A[left] > t)  left++;
			while(A[right] <= t)  right--;
			swap(A,left,right); //交换
		}
		swap(A,p,right);
		return right;
}

冒泡排序

思路:n个数，比较n-1趟，每趟比较n-1次，将大数逐步沉底。即后移。

import java.util.Scanner;

public class Main{  
	public static void main(String[] args)
	{
	  Scanner sc = new Scanner(System.in);
	  int n = sc.nextInt();
	  int []arr = new int[n];
	  for(int i=0;i<n;i++)
		  arr[i] = sc.nextInt();
      for(int i = 0;i<n-1;i++){  //n-1趟
    	  for(int j=0;j<n-1;j++){ //每趟比较n-1次
    		  if(arr[j] > arr[j+1])  
    			  swap(arr,j,j+1);  //交换	  
    	  }
      }
      for(int i=0;i<n;i++)
    	  System.out.print(arr[i]+" ");
   }

	private static void swap(int[] arr, int i, int j) {
			int t;
			t = arr[i];
			arr[i] = arr[j];
			arr[j] = t;
	}	
}

各排序方法的比较