Java快速排序算法

快速排序1.交换法：

话不多说，直接上代码：

public static int quickSortOne(int data[],int left,int right)
	{
		int pre=left;//定义一个标记指向left
		int key=data[left];//把data[left]的值取出来
		for(int i=left+1;i<data.length;i++)//遍历接下来的数组中的数据
		{
			if(data[i]<key)
			{
				data[pre]=data[i];//当data[i]小于key的时候，把data[i]的值赋给data[pre];
				pre++;//pre标记往后移一位
		        for(int k=i;k>pre;j--)
		            data[k]=data[k-1];
		    //这个for循环是为了把pre所对应的位置空出来。
		     }
			    data[pre]=key; 
		}
		return pre;
	}
	public static void quickSort1(int data[],int left,int right)
	//这是用递归方法
	{
		if(data==null) return ;
		int index=quickSortOne(data,left,right);
		if(index+1<right) index=quickSortOne(data,index+1,right);
		if(left<index-1) index=quickSortOne(data,left,index+1);
		
	}
	public static void quickSort11(int data[],int left,int right)
	//这是用数据栈方法
	{
		if(data==null) return ;
		ArrayStack stack=new ArrayStack(1000);
		stack.push(left);
		stack.push(right);
		while(!stack.isEmpty())
		{
			right=stack.pop();
			left=stack.pop();
			int index=quickSortOne(data,left,right);
			if(index+1<right)
			{
				stack.push(index+1);
				stack.push(right);
			}
			if(left<index-1)
			{
				stack.push(left);
				stack.push(index-1);
			}
		}
	}

快速排序2.挖坑填补法

话不多说，见代码：

public static int quickSortW(int data[],int left,int right)
	{
		int num=data[left];
		while(left<right) 
		{
			  while(left<right&&data[right]>num) right--;
//先从右向左比较，当大于num的值时候，right向左移一位。直到data[right]<num时候，把data[right]的值赋给data[left];
			  data[left]=data[right];
			  while(left<right&&data[left]<num) left++;
//然后再从左向右比较，当小于的时候，往左移一位，直到大于的时候，把data[left]的值赋给data[right];
			  data[right]=data[left];	  
		}//最终当left=right 的时候 left所对应的位置就把num的值放进去。输出num，这就找到了第一次快排的分割位置。
		data[left]=num;
		return left;
		
	}
	public static void quickSortW1(int data[],int left,int right)
	{
		int index=quickSortW(data,left,right);
		if(index+1<right) quickSortW1(data,index+1,right);
		if(left<index-1) quickSortW1(data,left,index-1);
	}