快速排序算法2（java）

这里是换了一种开始排序的形式的方法：

这个算法是算法老师所给，据我手调后发现，其只能实现没有相同数字的数组的排序

package QK;

/**
 * 
 * @author YuYunTan(谭淇蔚)
 *
 *这里是我学习的分治法求解快速排序的算法。
 *之前的算法，算是我看书改变了一点。
 *现在这个算法是按照老师所教进行实现
 *
 *快速排序：
 *由著名的计算机科学家霍尔给出的排序方法
 *算法是根据分治策略的一种高效率的排序算法。
 *它虽然也是把A[1...n]分成两个子文件，但是与归并排序算法有所不同
 *
 *在被分成的两个子文件以后，不再需要归并。于是，被分成的两个子文件至少必须满足一子文件中的所有元素都小于或等于另一个子文件的任何一个元素
 *
 *
 *快速排序的分治策略：
 *选取A的某个元素，t=A[s],然后将其他元素重新排列。
 *使A[1...n]中所有在t以前出现的元素都小于或者等于t
 *所有在t后面出现的元素都大于或者等于t
 *文件的这种重新整理叫做划分，元素t称为划分元素
 *
 *快速排序就是反复对产生的文件进行划分来实现的
 *
 *快速排序算法(抽象)
 *QuickSort(p,q)
 *global n,A[1...n]
 *if(p<q)then
 *{
 *  j=Partition(p,q+1);
 *  QuickSort(p,j-1);
 *  QuickSort(j+1,q);
 *}
 *
 *procedure PARTITION(m,p)
 *global A[1...n]
 *v = A[m];
 *i=m;//A[m]是被分割元素
 *loop 
 *   loop i=i+1 until A[i]>=v;
 *   loop p=p-1 until A[p] <=v;
 *   if(i<p) then
 *      INTERCHANGE(A[i],A[p])
 *    else return n;
 * repeat
 * A[m] = A[p];
 * A[p] = v;//划分元素在位置P
 * 
 *
 */

public class QuickSortArray {

	
	public static void main(String[] args) {
		int []A = {5,9,10,3,8,7,6,18,23};
		System.out.println("原始数组：");
		print(A);
		QuickSort(A,0,A.length-1);
		System.out.println("最后结果：");
		print(A);
	}

	private static void print(int[] a) {
		// TODO 自动生成的方法存根
		for(int i=0;i<a.length;i++){
			System.out.print(a[i]+" ");
		}
		System.out.println("  ");
		
	}

	private static void QuickSort(int[] A, int i, int length) {
		// TODO 自动生成的方法存根
		int j;
		if(i < length){
			j = Partition(A,i,length);
			System.out.println("划分元素的下标为: "+(j)+" 划分元素为"+A[j]);
			print(A);
			QuickSort(A,i,j-1);//递归调用
			QuickSort(A,j+1,length);//递归调用
		}
		
	}

	private static int Partition(int[] A, int m, int p) {
		// TODO 自动生成的方法存根
		int v = A[m];//A[m]是划分元素
		int i=m;
		while(i < p){
			while(A[i] < v && i<A.length)i++;//使得找到一个比区分的值小的，i往左移
			while(A[p] > v && p >= 0)p--;//找到一个比区分的值大的，p往右移
			if(i < p)INTERCHANGE(A,i,p);
			else return p;
		}
		return i;
	}

	private static void INTERCHANGE(int[] A, int i, int j) {
		// TODO 自动生成的方法存根
		int temp;
		temp = A[i];
		A[i] = A[j];
		A[j] = temp;
	}

	
}

接下来，我给出一份是算法导论的算法：

<pre class="java" name="code">/**
 * 
 * @author YuYunTan(谭淇蔚)
 *
 *这里是我学习的分治法求解快速排序的算法。
 *之前的算法，算是我看书改变了一点。
 *现在这个算法是按照算法导论所教进行实现
 *
 *快速排序：
 *由著名的计算机科学家霍尔给出的排序方法
 *算法是根据分治策略的一种高效率的排序算法。
 *它虽然也是把A[1...n]分成两个子文件，但是与归并排序算法有所不同
 *
 *在被分成的两个子文件以后，不再需要归并。于是，被分成的两个子文件至少必须满足一子文件中的所有元素都小于或等于另一个子文件的任何一个元素
 *
 *
 *快速排序的分治策略：
 *选取A的某个元素，t=A[s],然后将其他元素重新排列。
 *使A[1...n]中所有在t以前出现的元素都小于或者等于t
 *所有在t后面出现的元素都大于或者等于t
 *文件的这种重新整理叫做划分，元素t称为划分元素
 *
 *快速排序就是反复对产生的文件进行划分来实现的
 *
 *快速排序算法(抽象)
 *QuickSort(p,q)
 *global n,A[1...n]
 *if(p<q)then
 *{
 *  j=Partition(p,q+1);
 *  QuickSort(p,j-1);
 *  QuickSort(j+1,q);
 *}
 *PARTITION(A,p,r)
 * x=A[t]
 * i =p-1;
 * for j=p to r-1;
 *    do if A[j] <= x
 *        then i=i+1;
 *        exchange(A[i],A[j])
 *        
 * exchange(A[i+1],A[r])
 * return i+1;
 **/


public class QKsort {

	public static void main(String[] args) {
		int []A = {1,9,10,3,8,1,6,18,23};
		System.out.println("原始数组：");
		print(A);
		QuickSort(A,0,A.length-1);
		System.out.println("最后结果：");
		print(A);
	}

	private static void QuickSort(int[] A, int i, int Length) {
		// TODO 自动生成的方法存根
		int j;
		if(i < Length){
			j = Partition(A,i,Length);
			System.out.println("划分元素的下标为: "+(j)+" 划分元素为"+A[j]);
			print(A);
			QuickSort(A,i,j-1);//递归调用
			QuickSort(A,j+1,Length);//递归调用
		}
		
		
		
	}

	private static int Partition(int[] A, int p, int r) {
		// TODO 自动生成的方法存根
		int x = A[r];
	    int i = p-1;
	    for(int j = p;j <= r-1;j++){
	    	if(A[j]<=x){
	    		i++;
	    		EXCHANGE(A,i,j);
	    	}
	    }
	   EXCHANGE(A,i+1,r);
	   return i+1;
		
	}

	private static void EXCHANGE(int[] A, int i, int j) {
		// TODO 自动生成的方法存根
		int temp;
		temp = A[i];
		A[i] = A[j];
		A[j] = temp;
		
	}

	private static void print(int[] a) {
		// TODO 自动生成的方法存根
		for(int i=0;i<a.length;i++){
			System.out.print(a[i]+" ");
		}
		System.out.println("  ");
	}
}