排序算法原理:主要采用分治策略,首先先要确定关键字,然后根据关键字划分数组。根据关键字,数组左边存放的是比关键字小的,右边存放的是比关键字大的;这里可以采用数组的最后一位最为关键字。具体代码实现如下:
/**
*
<p>Title:QuickSort </p>
<p>Description: 快速排序</p>
<p>Company: </p>
* @author
* @date 2017-10-18 下午10:42:58
*
*/
public class QuickSort{
/**
*
* @Title:part
* @Description:把数组进行分组
* @param @param arr
* @param @param left:数组第一个元素
* @param @param right: 数组最后一个元素
* @param @param key: 关键字,以此划分数组,比关键字小的都在数组的左边,比他大的都在右边
* @return leftPtr:数组分界数
* @throws
*/
public static int partition(long []arr,int left,int right,long key){
int leftPtr = left - 1;//左指针,开始时指向数组第一个元素的前一位置
int rightPtr = right;//右指针,因为把数组最后一位作为关键字,所以开始时指向数组最后一位的前一位,下面循环时先减了1
while(true){
while(leftPtr < rightPtr && arr[++leftPtr] < key);
while(rigthPtr > leftPtr && arr[--rigthPtr] > key);
//当左指针所指下标大于或等于右指针所指下标时,跳出本次循环
if(leftPtr >= rightPtr){
break;
}
}else{//交换左右指针所指元素
long temp = arr[leftPtr];
arr[letfPtr] = arr[rightPtr];
arr[rightPtr] = temp;
}
}
//交换关键字和leftPtr所指的元素,以关键字位置作为划分
long temp = arr[right];
arr[right] = arr[leftPtr];
arr[leftPtr] = temp;
return leftPtr;
}
pubic static void quickSort(long []arr,int left,int right){
//设置递归结束条件
if(right - left <= 0){
return;
}
long key = arr[right];//取关键字
//获得划分界限数
int partition = partition(arr,left,right,key);
//递归,对以分界数左边的数组进行排序
quickSort(arr,left,partition-1);
//递归,对以分界数右边的数组进行排序
quickSort(arr,parttion+1,right);
}
}
//以下为测试类:
package com.ll.test;
import org.junit.Test;
import com.ll.algrothimn.QuickSort;
/**
*
<p>Title:TestQuickSort </p>
<p>Description: 测试快速排序</p>
<p>Company: </p>
* @author
* @date 2017-10-18下午10:43:26
*
*/
public class TestQuickSort {
@Test
public void show(){
long [] arr = new long[10];
for (int i = 0; i < 10; i++) {
arr[i] = (long)(Math.random()*99);
}
System.out.println("排序前的数组为:");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
System.out.println("排序后的数组为:");
QuickSort.quickSort(arr, 0, arr.length-1);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}