java算法之快速排序法

最新推荐文章于 2020-09-23 21:36:59 发布

原创最新推荐文章于 2020-09-23 21:36:59 发布 · 384 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #快速排序 #快速排序法 #java快速排序法

快速排序法分析，

（一）（是否true）{

（1）选定一个值用作比较，一般选取第一个数（如果是整个数组，那就是数组的第一个数），使用一系列的方法，使得比这个数大的排在这个数的后面，比这个数小的排在这个数的前面，这个时候，数组仍然是乱的，但是，之前所选取的那个数已经找到了合适的位置。

（2.1）将选取的那个数的前面【注意，这个时候选取的那个数很有可能不是第一个数了，因为执行了（1）的操作，除非这个数是最小的】的所有数进行（一），这时又有一个数找到了合适的位置。

（2.2）将选取的那个数的后面【注意，这个时候选取的那个数很有可能不是第一个数了，因为执行了（1）的操作，除非这个数是最小的】的所有数进行（一），这时又有一个数找到了合适的位置。

}

具体代码

public class kspx{
	public static void main (String args[]){
		int[] arr = {2,4,5,7,8,9,0,3,6,1} ;
		quickSort(arr) ;
		for (int i = 0;i<arr.length ;i++ ){
			System.out.print(arr[i]+"、") ;
		}
	}

	public static void quickSort(int[] arr){
		qsort(arr, 0, arr.length-1);
	}
	private static void qsort(int[] arr, int low, int high){
		if (low < high){
			int pivot=partition(arr, low, high);        //将数组分为两部分
			qsort(arr, low, pivot-1);                   //递归排序左子数组
			qsort(arr, pivot+1, high);                  //递归排序右子数组
		}
	}
	private static int partition(int[] arr, int low, int high){
		int pivot = arr[low];     //枢轴记录
		while (low<high){
			while (low<high && arr[high]>=pivot) --high;
			arr[low]=arr[high];             //交换比枢轴小的记录到左端
			while (low<high && arr[low]<=pivot) ++low;
			arr[high] = arr[low];           //交换比枢轴小的记录到右端
		}
		//扫描完成，枢轴到位
		arr[low] = pivot;
		//返回的是枢轴的位置
		return low;	
	}
}

分析其中的一个方法：

public class kspx{
	public static void main (String args[]){
		int[] arr = {2,4,5,7,8,9,0,3,6,1} ;
		quickSort(arr) ;
		for (int i = 0;i<arr.length ;i++ ){
			System.out.print(arr[i]+"、") ;
		}
	}

	public static void quickSort(int[] arr){
		qsort(arr, 0, arr.length-1);
	}
	private static void qsort(int[] arr, int low, int high){
		if (low < high){
			int pivot=partition(arr, low, high);        //将数组分为两部分
			qsort(arr, low, pivot-1);                   //递归排序左子数组
			qsort(arr, pivot+1, high);                  //递归排序右子数组
		}
	}


	private static int partition(int[] arr, int low, int high){
		//arr = {2,4,5,7,8,9,0,3,6,1} ;
		//low = 0 ;
		//high = 9 ;
		//pivot一般设为第一个值，pivot = 2 ;

		int pivot = arr[low];     //枢轴记录

		//整个while就是把比2小的放到2的前面，比2大的放到2的后面，这样2就找到了合适的位置。
		//把比2小的依次从前往后放，把比2大的依次从后往前放，这样最后剩的位置就是2的位置了
		while (low<high){

			//上半部分就是从后面往前找，将比pivot（2）小的依次往前放		
			while (low<high && arr[high]>=pivot) --high;
			arr[low]=arr[high];             //交换比枢轴小的记录到左端
			//1、此时low不变的，high减少，目的就是在后面找到一个小于2的值替换arr[low]
			//low=0，当high=9时，满足条件，arr[0]=arr[9]，arr = {1,4,5,7,8,9,0,3,6,1} ;满足条件就是可以跳出while循环
			//3、此时又要及时的替换arr[low]的值
			//low=1，当high=6时，满足条件，arr[1]=arr[6]，arr = {1,0,5,7,8,9,0,3,6,4} ;
			//5、low=2，low=2时，跳出while，arr = {1,0,5,7,8,9,5,3,6,4} ;



			//下半部分就是从前面往后找，将比pivot（2）大的依次往后放	
			while (low<high && arr[low]<=pivot) ++low;
			arr[high] = arr[low];           //交换比枢轴小的记录到右端
			//2、此时要及时的替换arr[high]值,因为arr[high]的值已经用在别的地方了。保持high不变，low增加，在前面找到一个大于2的值替换arr[high]
			//high=9，当low=1时，满足条件，arr[9]=arr[1]，arr = {1,4,5,7,8,9,0,3,6,4} ;
			//4、high=6，当low=2时，满足条件，arr[6]=arr[2]，arr = {1,0,5,7,8,9,5,3,6,4} ;
			//6、无法进入while，high=2，low=2，arr = {1,0,5,7,8,9,5,3,6,4} ;跳出外面的while

		}
		//扫描完成，枢轴到位
		arr[low] = pivot;

		//arr = {1,0,2,7,8,9,5,3,6,4} ;

		//返回的是枢轴的位置
		return low;	
	}
}

将程序输出

public class kspx{
	public static void main (String args[]){
		int[] arr = {2,4,5,7,8,9,0,3,6,1} ;
		quickSort(arr) ;
		for (int i = 0;i<arr.length ;i++ ){
			System.out.print(arr[i]+"、") ;
		}
	}

	public static void quickSort(int[] arr){
		qsort(arr, 0, arr.length-1);
	}
	private static void qsort(int[] arr, int low, int high){
		if (low < high){
			int pivot=partition(arr, low, high);        //将数组分为两部分
			qsort(arr, low, pivot-1);                   //递归排序左子数组
			qsort(arr, pivot+1, high);                  //递归排序右子数组
		}
	}
	private static int partition(int[] arr, int low, int high){
		int pivot = arr[low];     //枢轴记录
		
		System.out.println("arr["+pivot+"]="+pivot) ;

		int j = 1 ;

		while (low<high){
			while (low<high && arr[high]>=pivot) --high;
			arr[low]=arr[high];             //交换比枢轴小的记录到左端

			System.out.print((j++)+"-->") ;
			for (int i = 0;i<arr.length ;i++ ){
			System.out.print(arr[i]+"、") ;
			}
			System.out.println() ;

			while (low<high && arr[low]<=pivot) ++low;
			arr[high] = arr[low];           //交换比枢轴小的记录到右端

			System.out.print((j++)+"-->") ;
			for (int i = 0;i<arr.length ;i++ ){
			System.out.print(arr[i]+"、") ;
			}
			System.out.println() ;

		}
		//扫描完成，枢轴到位
		arr[low] = pivot;
		//返回的是枢轴的位置

		System.out.print((j++)+"-->") ;
		for (int i = 0;i<arr.length ;i++ ){
			System.out.print(arr[i]+"、") ;
			}
			System.out.println() ;
			System.out.println("======================") ;

		return low;
		
	}




}

输出结果

arr[2]=2
1-->1、4、5、7、8、9、0、3、6、1、
2-->1、4、5、7、8、9、0、3、6、4、
3-->1、0、5、7、8、9、0、3、6、4、
4-->1、0、5、7、8、9、5、3、6、4、
5-->1、0、5、7、8、9、5、3、6、4、
6-->1、0、5、7、8、9、5、3、6、4、
7-->1、0、2、7、8、9、5、3、6、4、
======================
arr[1]=1
1-->0、0、2、7、8、9、5、3、6、4、
2-->0、0、2、7、8、9、5、3、6、4、
3-->0、1、2、7、8、9、5、3、6、4、
======================
arr[7]=7
1-->0、1、2、4、8、9、5、3、6、4、
2-->0、1、2、4、8、9、5、3、6、8、
3-->0、1、2、4、6、9、5、3、6、8、
4-->0、1、2、4、6、9、5、3、9、8、
5-->0、1、2、4、6、3、5、3、9、8、
6-->0、1、2、4、6、3、5、3、9、8、
7-->0、1、2、4、6、3、5、7、9、8、
======================
arr[4]=4
1-->0、1、2、3、6、3、5、7、9、8、
2-->0、1、2、3、6、6、5、7、9、8、
3-->0、1、2、3、6、6、5、7、9、8、
4-->0、1、2、3、6、6、5、7、9、8、
5-->0、1、2、3、4、6、5、7、9、8、
======================
arr[6]=6
1-->0、1、2、3、4、5、5、7、9、8、
2-->0、1、2、3、4、5、5、7、9、8、
3-->0、1、2、3、4、5、6、7、9、8、
======================
arr[9]=9
1-->0、1、2、3、4、5、6、7、8、8、
2-->0、1、2、3、4、5、6、7、8、8、
3-->0、1、2、3、4、5、6、7、8、9、
======================
0、1、2、3、4、5、6、7、8、9、