Java实现快速排序
public class QuickSort
{
private long[] arr; //要排序的数组
private int size; //初始化数组大小
private int length; //数组实际大小(即有多少个值)
public QuickSort(int size){
this.arr=new long[size];
this.size = size;
length = 0;
}
//往数组添加值
public void add(long value){
if(length < size)
arr[length++] = value;
}
//打印
public void display(){
for(int i=0; iarr[right]){
swap(left,right);
}
}
}
//交换数组两个位置的数据
public void swap(int left, int right){
long tmp = arr[left];
arr[left] = arr[right];
arr[right] = tmp;
}
/**
* 比较数组的第一个,中间一个,最后一个; 将最小的 放到第一个位置,中间值放到最后位置
* 如[4,6,3,7,9],比较4,3,9 ; 3最小放第一个位置,4为中间值放到最后的位置,结果[3,6,9,7,4]
* 最后一位的值4,作为"中间值"
* @param left
* @param right
* @return
*/
public long setMiddle(int left, int right){
int middle = (left+right)/2;
if(arr[left]>arr[right]){
swap(left,right);
}
if(arr[left]>arr[middle]){
swap(left,middle);
}
if(arr[middle]leftIndex && arr[--rightIndex]>=flag);
//如果查找没有结束, 交换这个两个数, 继续...
if(leftIndexflag){
arr[right]=arr[leftIndex];
arr[leftIndex]=flag;
}
}
//递归的执行操作
if(left ------------------------------------------------------------------
利用上面递归算法进行排序时 当排序数组较大时
会出现堆栈溢出的异常 这是以为内递归调用的次数太多造成的
可以改用"栈+循环的方式 代替 递归调用
import java.text.SimpleDateFormat;
import java.util.Date;
public class QuickSort
{
private long[] arr; //要排序的数组
private int size; //初始化数组大小
private int length; //数组实际大小(即有多少个值)
public QuickSort(int size){
this.arr=new long[size];
this.size = size;
length = 0;
}
//往数组添加值
public void add(long value){
if(length < size)
arr[length++] = value;
}
//打印
public void display(){
for(int i=0; iarr[right]){
swap(left,right);
}
}
}
//交换数组两个位置的数据
public void swap(int left, int right){
long tmp = arr[left];
arr[left] = arr[right];
arr[right] = tmp;
}
/**
* 比较数组的第一个,中间一个,最后一个; 将最小的 放到第一个位置,中间值放到最后位置
* 如[4,6,3,7,9],比较4,3,9 ; 3最小放第一个位置,4为中间值放到最后的位置,结果[3,6,9,7,4]
* 最后一位的值4,作为"中间值"
* @param left
* @param right
* @return
*/
public long setMiddle(int left, int right){
int middle = (left+right)/2;
if(arr[left]>arr[right]){
swap(left,right);
}
if(arr[left]>arr[middle]){
swap(left,middle);
}
if(arr[middle]leftIndex && arr[--rightIndex]>=flag);
//如果查找没有结束, 交换这个两个数, 继续...
if(leftIndexflag){
arr[right]=arr[leftIndex];
arr[leftIndex]=flag;
}
}
//递归的执行操作
/*if(left=2){
//从栈里取出"开始位置"和"结束位置",进行"划分"操作
int right = stack.pop();
int left = stack.pop();
int middle = this.sort(left, right);
//将"划分"之后的左右两个无序数组的起始位置 压入栈,待处理
if(middle>0){
stack.push(left);
stack.push(middle-1);
stack.push(middle+1);
stack.push(right);
}
}
}
public static void main(String[] args){
QuickSort sort = new QuickSort(1000000);
for(int i=0; i<1000000; i++){
sort.add((long)(Math.random()*100));
}
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss ms");
System.out.println(sdf.format(new Date()));
sort.display();
sort.sort();
sort.display();
System.out.println(sdf.format(new Date()));
}
}