排序之快速排序

package com.xsz.demo;
/**   
 * @author cwqi  
 * @date 2015-1-6  
 */

//排序之快速排序,基本思路為分治+挖坑,方法有兩種:一是雙邊掃面;二是單邊掃描。
public class QuickSort {
	public static void main (String[] args){
		int a[] ={2,3,30,1,4,56,2,7,3,8};
		//int a[] ={4,5,6,2,7,3,8};
		//int a[] ={1,5,4,3,8};
		//int a[] ={1,1};
		//int a[] ={1};
		//int a[] ={};
		//int a[] =null;
		int start=0;
		int end= a==null? -1:a.length -1;
		//singleScan(a,start,end);
		doubleScan(a,start,end);
		print(a,end);
	}

	static void doubleScan(int[] a, int start, int end) {
		 if(start < end){  
		        int i = start, j = end, key = a[start];  
		        while(i < j){  
		        	//從後面往前找比key值小的元素
		            while( i < j && a[j] >= key){  
		                j--;  
		            }  
		            if(i < j){  
		                a[i++] = a[j];  
		            }  
		            
		            //從前面往後找比key值大的元素
		            while(i < j && a[i] <= key){  
		                i++;  
		            }  
		            if(i < j){  
		                a[j--] = a[i];  
		            }  
		        }  
		        
		        a[i] = key;  //i為分區中心
		        doubleScan(a, start, i-1);  
		        doubleScan(a, i+1, end);  
		    }   
	}

	static void singleScan(int[] a, int s, int e) {
		int j = s+1;//遍歷下標
		int p = s;//分區位置
		if (s < e) {
			int key =a[s];//key值
			while (j<=e){
				if(a[j] <= key){
					p++ ;
					//System.out.println("key->"+key);
					int temp =a[p];
					a[p] = a[j];
					a[j]=temp;
					//System.out.println("交換----->"+a[j]+" "+a[p]);
					j++ ;
				}else {
					j++ ;
				}
			}

			//將key值放在分區位置
			int temp =a[s];
			a[s] = a[p];
			a[p]=temp;

			singleScan(a, s, p-1);
			singleScan(a, p+1, e);
		}
	}

	static void print(int[]array ,int l){
		for (int i = 0; i <= l; i++) {
			System.out.print(array[i]+" ");
		}
	}
}
时间: 2024-08-02 11:02:09

排序之快速排序的相关文章

8. 冒泡法排序和快速排序(基于openCV)

一.前言 主要讲述冒泡法排序和快速排序的基本流程,并给出代码实现,亲测可用. 二.冒泡法排序 冒泡法排序主要是将相邻两个值比较,把小的向前冒泡,大的向后沉淀,时间复杂度为O(n2).主要思想如下: 分为内外循环,每次外循环确定一个大的数据的具体位置,如下实例: 从图中可以看出,进过两次外循环就可以得到排序结果,随后的8次循环都浪费了,为了避免这种情况,我们可以设置一个状态参数,用来表示内循环是否发生数据的交换,从而作为外循环是否退出的信号. 三.快速排序 快速排序是最有效的排序方法之一,其主要思

插入排序 | 冒泡排序 | 希尔排序 | 堆排序 | 快速排序 | 选择排序 | 归并排序

以下是最近学习各种算法的代码实现: #include <stdlib.h> #include <stdio.h> #include <time.h> #include <limits.h> typedef int EleType; typedef int (*CompFunc)(void *,void *); int IntComp(void * a,void *b) { if(*(int *)a > *(int *)b) return 1; if(*

希尔排序和快速排序

//希尔排序 在直接插入排序算法中,每次插入一个数,使有序序列只增加1个节点,并且对插入下一个数没有提供任何帮助. 如果比较相隔较远距离(称为增量)的数,使得数移动时能跨过多个元素,则进行一次比较就可能消除多个元素交换. D.L.shell于1959年在以他名字命名的排序算法中实现了这一思想.算法先将要排序的一组数按某个增量d分成若干组, 每组中记录的下标相差d.对每组中全部元素进行排序,然后再用一个较小的增量对它进行,在每组中再进行排序. 当增量减到1时,整个要排序的数被分成一组,排序完成 p

插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和LST基数排序——C++实现

首先是算法实现文件Sort.h,代码如下: /* * 实现了八个常用的排序算法:插入排序.冒泡排序.选择排序.希尔排序 * 以及快速排序.归并排序.堆排序和LST基数排序 * @author gkh178 */ #include <iostream> template<class T> void swap_value(T &a, T &b) { T temp = a; a = b; b = temp; } //插入排序:时间复杂度o(n^2) template<

处理海量数据的三大排序之——快速排序(C++)

代码实现                                                                                                                                                                                                        #include "stdafx.h" #include <iostream

Java中的几种排序算法:冒泡排序,插入排序,二分法排序,简单排序,快速排序

冒泡排序: int[] hehe={4,7,2,5,6,9,0}; for(int i=0;i<hehe.length;i++){ for(int j=i+1;j<hehe.length;j++){ if(hehe[i]>hehe[j]){ int temp=hehe[i]; hehe[i]=hehe[j]; hehe[j]=temp; } } } 插入排序 int[] a={13,7,8,9,10,1,2,32}; int i,j,t,h; for (i=1;i<a.length

排序算法----快速排序java

快速排序是对冒泡排序的一种改进,平均时间复杂度是O(nlogn) import java.util.Arrays; import java.util.Scanner; public class test02{ public static void main(String[] args) { int n = 1; while (n != 0){ Scanner scanner = new Scanner(System.in); n = scanner.nextInt(); int s[] = ne

排序(5)---------快速排序(C语言实现)

继shell发明了shell排序过后呢,各位计算机界的大牛们又开始不爽了,为什么他能发明,我就不能发明呢.于是又有个哥们蹦出来了.哎...那么多排序,就木有一个排序是中国人发明的.顺便吐槽一下,一百年的天朝的历史书里还在吹,祖冲之第一个发现圆周率,领先世界一千多年...... 快速排序使用分治法(Divide and conquer)策略来把一个串行(list)分为两个子串行(sub-lists). 步骤为: 1,从数列中挑出一个元素,称为 "基准", 2,重新排序数列,所有元素比基准

冒泡排序,选择排序,快速排序

package com.hello; public class HelloJava { /** * 冒泡排序(通过一次一次的循环,根据相近两个值进行比较,将大的值往下移) * @author MR ZHANG * @param arr * @return */ public static void getBubbleSort(int[] arr){ for(int i = 1;i< arr.length-1;i++){ for(int j=0; j< arr.length-i;j++){ if