快速排序

递归： 1、函数自己调用自己 2、要有结束递归的条件 def print_num(n): if n < 0: return print(n) print_num(n-1) print("******") print_num(3) 执行结果： 3 2 1 0 **** **** **** **** 解释： """ n=3: if n <=0: 不会触发 return print(n)---》打印了3 print_num(n-1)--》print_num(3-1)-print_num(2)--None print("*******")#被暂停了，需要等待print_num(2)执行结束 才会执行。 结束递归调用后，打印了一行星号 return None，函数执行完毕了 print_num(2) n=2: if n <=0: 不会触发 return print(n)---》打印了2 print_num(n-1)--》print_num(2-1)-print_num(1)--None print("*******")#被暂停了，需要等待print_num(1)执行结束 才会执行。 结束递归调用后，打印了一行星号 print_num(1) n=1: if n <=0: 不会触发 return print(n)---》打印了1 print_num(n-1)--》print_num(1-1)

1、快速排序思想：快速排序主要利用分治和递归的思想，例如，将一个数组{2,5,10,1,0,7}排序。首先选取其第一个元素2作为基准，将<2的元素移动到其左边，将>=2的元素移动到其右边（其中等于2放左放右都可以），此过程称为一次分区，可以得到{0,1,2，10,5,7}。经过一次分区后，数组就分成了两个部分，左边小于2，右边大于等于2。因此可以继续分别对其左右分区{0,1,2}和{10,5,7}再分别进行快排，不断的迭代，直至完全有序。 过程解析图 2、代码实现 import java.util.Arrays; public class TestQuickSort { private static int partition(int[] arr, int low, int high) { //指定左指针i和右指针j int i = low; int j= high; //将第一个数作为基准值。挖坑 int x = arr[low]; //使用循环实现分区操作 while(i<j){//5 8 //1.从右向左移动j，找到第一个小于基准值的值 arr[j] while(arr[j]>=x && i<j){ j--; } //2.将右侧找到小于基准数的值加入到左边的（坑）位置， 左指针想中间移动一个位置i++ if(i<j){ arr[i] = arr[j]; i++; } //3

1 void swap(int &i, int &j) 2 { 3 int temp = i; 4 i = j; 5 j = temp; 6 } 7 8 int partition(int a[], int p, int r) 9 { 10 int x = a[r]; 11 int i = p - 1; 12 for (int j = p; j < r; j++) { 13 if (a[j] <= x) { 14 i ++; 15 swap(a[i], a[j]); 16 } 17 } 18 i ++; 19 swap(a[i], a[r]); 20 return i; 21 } 22 23 void quick_sort(int a[], int p, int r) 24 { 25 if (p < r) { 26 int q = partition(a, p, r); 27 quick_sort(a, p, q - 1); 28 quick_sort(a, q + 1, r); 29 } 30 } 来源： https://www.cnblogs.com/ren-yu/p/11869616.html

快速排序是冒泡的一种增强,冒泡的时间复杂度是O(n^2),我们首先看一下冒泡的代码:public class Demo1 { /** * 进行冒泡排序 * 1.其实就是通过相邻两个数进行一个比较,比较出最大或者最小的数值 * 2.8 ---> 7 ---> 6 * */ public void sortingMp(int[] arr){ int value = 0; //循环完毕最大的数值在最后arr.length-1的位置 for(int a=0;a<arr.length;a++){ if(arr[a] > arr[a+1]){ value = arr[a]; arr[a] = arr[a+1]; arr[a+1] = value; } } //第二次循环只要是找到倒数第二大的数 放置arr.length-1-1的位置 for(int a=0;a<arr.length-1;a++){ if(arr[a] > arr[a+1]){ value = arr[a]; arr[a] = arr[a+1]; arr[a+1] = value; } } //以此类推我们会发现最后a < arr.length-1-1-? == arr.length-(arr.length-1) //arr.length-1就是我们需要循环上述代码的次数 } /** * 这个方法是将上述方法进行改良整合 * *

快速排序 2019-11-10 11:43:52 by冲冲 1、概念 快速排序(Quick Sort)使用分治法策略。 ① 基本思想是，选择一个基准数，通过一趟排序将要排序的数据分割成独立的两部分；其中一部分的所有数据都比另外一部分的所有数据都要小。然后，再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 ② 快速排序流程 A. 从数列中挑出一个基准值。 B. 将所有比基准值小的摆放在基准前面，所有比基准值大的摆在基准的后面(相同的数可以到任一边)；在这个分区退出之后，该基准就处于数列的中间位置。 C. 递归地把"基准值前面的子数列"和"基准值后面的子数列"进行排序。 2、基本思想 以数列a={30,40,60,10,20,50}为例，演示它的快速排序过程： 在第1趟中，设置x=a[i]，即x=30。 ① 从"右 --> 左"查找小于x的数：找到满足条件的数a[j]=20，此时j=4；然后将a[j]赋值a[i]，此时i=0；接着从左往右遍历。 ② 从"左 --> 右"查找大于x的数：找到满足条件的数a[i]=40，此时i=1；然后将a[i]赋值a[j]，此时j=4；接着从右往左遍历。 ③ 从"右 --> 左"查找小于x的数：找到满足条件的数a[j]=10，此时j=3；然后将a[j]赋值a[i]，此时i=1；接着从左往右遍历。 ④ 从

1.（ 来源 ） （1）O(1)：常量阶，运行时间为常量 （2）O(logn)：对数阶，如 二分搜索算法，快速幂 （3）O(n)：线性阶，如 n个数内找最大值 （4）O(nlogn)：对数阶，如 快速排序算法，线段树 （5）O(n^2)：平方阶，如 选择排序，冒泡排序 （6）O(n^3)：立方阶，如 两个n阶矩阵的乘法运算 （7）O(2^n)：指数阶，如 n个元素集合的所有子集的算法 （8）O(n!)：阶乘阶，如 n个元素全部排列的算法 2.（ 来源） 来源： https://www.cnblogs.com/phemiku/p/11826243.html

题目描述 利用快速排序算法将读入的 N个数从小到大排序后输出。 快速排序是信息学竞赛的必备算法之一。对于快速排序不是很了解的同学可以自行上网查询相关资料，掌握后独立完成。（ C + +选手请不要试图使用 STL ，虽然你可以使用 sort 一遍过，但是你并没有掌握快速排序算法的精髓。） 输入格式 第 1行为一个正整数 N ，第 2 行包含 N 个空格隔开的正整数 a i ​ ，为你需要进行排序的数，数据保证了 A i ​ 不超过 1000000000 。 输出格式 将给定的 N个数从小到大输出，数之间空格隔开，行末换行且无空格。 输入输出样例 输入 #1 复制 5 4 2 4 5 1 输出 #1 复制 1 2 4 4 5 说明/提示 对于 20\% 2 0 %的数据，有 N≤1000 ； 对于 100\% 1 0 0 %的数据，有 N≤100000 。 #include <cmath> #include <cstdio> #include <cstring> #include <cstdlib> #include <iostream> #include <algorithm> using namespace std; int main(){ int n; scanf("%d",&n); int a[n]; for(int i=1;i<=n;i++){ scanf("%d",&a[i

简单原理： 　　快速排序是对冒泡排序的改进，用分而治之的思想，先找到一个基准数，利用基准数进行一轮排序，将所有比它小的数都放在左边，再将所有比它大的数都放在它右边， 然后返回基准数的位置，进行下一轮排序，下一轮将分别对基准数左右两边进行排序，依次循环，直到最后排序完成。 代码实现： import org.codewy.util.PrintUtil; /** * 快速排序 */ public class QuickSort { public static void qiuckSort(int[] source, int i, int j) { int point; if (i < j) { point = partition(source, i, j); qiuckSort(source, i, point - 1); qiuckSort(source, point + 1, j); } } private static int partition(int[] source, int i, int j) { //将第一个值设为基准数 int pointVal = source[i]; while (i < j ) { //从右边开始找到第一个比基准值小的数val1 while (i < j && source[j] >= pointVal) { j--; } /

import java.util.ArrayList; import java.util.Random; /* *返回一个数组，下标0是该元素的下标，下标1是该元素的值 */ public class minNumber { //每次返回接受数组中最小的数字，以数组的形式返回，0是最小数，1是它的下标 public static ArrayList<Integer> findMinNumber(ArrayList<Integer> list){ ArrayList<Integer> min_number=new ArrayList<Integer>(); min_number.add(list.get(0)); min_number.add(0); for(int i=1;i<list.size();i++){ if(list.get(i)<min_number.get(0)){ min_number.add(0,list.get(i)); min_number.add(1,i); } } return min_number; } public static void main(String[] args){ //第一个是等待排序的列表，第二个相当于第一个的拷贝，第三个就是整理好的数组 ArrayList<Integer> list=new ArrayList<Integer>

快速排序：可以对一个数组或者是对数组中的一段进行排序 思想： 选择一个base， 然后通过一顿瞎操作， 使得 当前数组变成 左小，base， 右大 （小，大，都是相对于base 来说的） 然后使用同样的方法将 上一步的左小 排成 左小，base， 右大的格式， 将 上一步的右大 也排成 左小，base， 右大的格式 这样不断的进行，最终变成了一个有序的数组（从思想中可以发现这个是将大问题不断转换为一个个的小问题，所以可以 使用递归实现） 实现： 因为上面说了这个可以通过递归实现， 所以我只需要弄清楚一层的 左小，base， 右大 的实现即可 选择数组最左边的数为base，然后生成两个指针left， right，分别指向数组的左边和右边，根据左边指针的作用 是 将左边的数都变成比base 小的数 ， 所以左边指针left 在移动的时候，发现比base 大的数字的时候，异常出现了 同理右边指针right的作用是 将右边的数字都变成比base 大的数 ， 所以右边指针right 移动的时候，发现比base 小的 数字的时候， 异常出现了 ，那么怎么处理呢？ 将left 指向的数字，和right 指向的数字进行相互的交换， 就使得左右两边 暂时满足 开始的愿望， 左小右大 ，直到两个指针相遇的时候。两个指针相遇了， 那么这个不是之前的异常了，问题出现了， 两者相遇的时候，这个值为多大