排序算法(快速排序)

快速排序算法有几种种优化方式:基准点的选择,减去不必要的交换位置,优化小数组时的优化,递归的优化(在数组长度很短,用直接插入算法就行了)

时间复杂度(nlog2n)

public class QuickSort {
    
    public static void main(String[] args) {
        int a[]={1,3,5,2,7,7,4,9};
        sort(a, 0, 7);
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]);
        }
    }
    
    public static void sort(int a[],int low,int high){
        
        int point=a[low];//开始时,基准点在数组的最开始的位置
        if(low<high){
            point=patertion(a,low,high);
            sort(a,low,point-1);//递归左边
            sort(a,point+1,high);//递归右边
            
        }
        
    }

private static int patertion(int[] a, int low, int high) {
        int point=a[low];
        while(low<high){
            while(low<high&&a[high]>=point){
                    high--;
                }
                a[low]=a[high];
                //swap(a,low,high);//我们交换可以变成赋值
                
            
            while(low<high&&a[low]<=point){
                low++;
                }
                a[high]=a[low];
                //swap(a,low,high);//我们交换可以变成赋值,最后low的位置存的point,结束后赋值回去a[low]=point;
                
        }    
        a[low]=point;
        return low;
    }

//    private static void swap(int[] a, int low, int high) {
//        int temp;
//        temp=a[high];
//        a[high]=a[low];
//        a[low]=temp;
//    }
//

}

时间: 2024-10-10 13:58:30

排序算法(快速排序)的相关文章

排序算法----快速排序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

经典排序算法 - 快速排序Quick sort

经典排序算法 - 快速排序Quick sort 原理,通过一趟扫描将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列 举个例子 如无序数组[6 2 4 1 5 9] a),先把第一项[6]取出来, 用[6]依次与其余项进行比较, 如果比[6]小就放[6]前边,2 4 1 5都比[6]小,所以全部放到[6]前边 如果比[6]大就放[6]后边,9比[6]大,放到[6

排序算法----快速排序(链表形式)

单链表形式实现排序算法. 这个快速排序主要利用递归调用.包含4个文件,头文件QuickSort.h,fatal.h,库函数QuickSort.c,测试文件TestQuickSort. QuickSort.h 1 typedef long ElementType; 2 #ifndef _List_H//如果没有编译过 3 #include<stdbool.h> 4 struct Node; 5 typedef struct Node *PtrToNode; 6 typedef PtrToNode

排序算法--快速排序

快速排序之所以特别快,主要是由于非常精炼和高度优化的内部循环. 像归并排序一样,快速排序也是一种分治的递归算法.数组S排序的基本算法由下列简单的四部组成: 1.如果S中元素个数是0或1,则返回 2.取S中任一元素v,称之为pivot(枢纽元,主元,基准) 3.将S-{v}分成两个不想交的集合:S1={x∈S-{v} | x <= v} 和 S2={x∈S-{v} | x > v} 4.返回{QuickSort(S1)后,继随v,继而QuickSort(S2) 为了完成上述的步骤3,有两种常用方

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

快速排序基本思想:挖坑填数+递归分治 快速排序使用分治法的策略,把一个串行分成2个子串行,快速排序又是一种分而治之的思想在排序算法是上的典型应用,本质上看,快速排序应该算冒泡排序基础上的递归分治法,快速排序名字简单粗暴,顾名思义就是快而且效率高,它是处理大数据最快的算法之一了. 算法描述:1.从数列中任意挑出一个数作为基准(pivot) 2.重新排序,所有比基准大的数放在基准左边,所有比基准大的数放在基准右边,这样排序一遍后该基准就位于数列的中间,这个就被称为分区操作(partition) 3.

白话排序算法--快速排序

前言: 写到快速排序时,之前已经进行了冒泡.选择.插入排序,发现算法问题很多东西都是和实际问题相逆的,实际你可能会由外及里,由上及下,可是算法里面它有时就需要你由里往外去扩散,好比最里面的是小成果,然后一次次往外变化,成果也慢慢变大,最后直至达到最终成果为止.本篇快速排序方法因为调用了递归,你就可以逆着由里及外来思考问题. 写这篇文章光画图就花费了我2小时时间,越抽象就越不好形容和比喻,画的不好,希望各位不要吐槽. 快速排序:先快速排序将队列一分为二,然后对每个队列进行递归调用快速排序方法,直至

排序算法--快速排序算法解析

一.快速排序算法思路 ①.取待排序列表的第一个元素p,通过归位算法,挪移他到列表中正确的位置. ②.列表被元素p分成两部分,左边都比元素p小,右边都比元素p大. ③.通过递归,在两部分,重复1.2步骤,直至列表有序. 归位算法动画演示: 二.快速排序算法代码示例 1 def partition(l,left,right):#归位算法 2 temp = l[left] #保存归位元素 3 while left <right: 4 while l[right]>=temp and left<

经典排序算法--快速排序

一.快速排序的基本思想: 快速排序使用了分治的思想,通过一趟排序将待排序列分割成两部分,其中一部分记录的关键字均比另一部分记录的关键字小.之后分别对这两部分记录继续进行排序,以达到整个序列有序的目的. 二.快速排序的三个步骤 1) 选择基准:在待排序列中,按照某种方式挑出一个元素,作为 "基准"(pivot): 2) 分割操作:以该基准在序列中的实际位置,把序列分成两个子序列.如果为升序,则此时,在基准左边的元素都比该基准小,在基准右边的元素都比基准大:而基准则在排序后正确的位置上.

经典排序算法——快速排序

对于一个int数组,请编写一个快速排序算法,对数组元素排序. 给定一个int数组A及数组的大小n,请返回排序后的数组. 测试样例: [1,2,3,5,2,3],6 [1,2,2,3,3,5] class QuickSort { public: int* quickSort(int* A, int n) { // write code here if(A==NULL || n<2) return A; process(A,0,n-1); return A; } int* process(int*

排序算法 - 快速排序(Quick Sort)

算法思想 快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序.它采用了一种分治的策略,通常称其为分治法(Divide-and-ConquerMethod). (1) 分治法的基本思想    分治法的基本思想是:将原问题分解为若干个规模更小但结构与原问题相似的子问题.递归地解这些子问题,然后将这些子问题的解组合为原问题的解. (2)快速排序的基本思想    设当前待排序的无序区为R[low..high],利用分治法可将快速排序的基本思想描述为:分解:      在R[low..hi