随机化快排和决策树

1、随机化快速排序算法

(1)、快速排序的坏处:完全顺序/完全逆序时时间复杂度为:O(n^2),其余的情况时间复杂度为:O(nlogn),算法的效率与输入顺序有关;

  (2)、随机选择主元,好处:其运行时间不依赖于输入序列的顺序,算法的效率与输入的顺序无关;

(3)、最差的情况由随机数产生器决定,随机化快速排序的时间复杂度为:O(nlogn);


2、比较排序的算法模型

该模型中,只能做的操作:< <= > .......,来决定元素的相对顺序;

局限性:该模型只能用于可以比较大小的数据类型;

总结:比较排序的算法时间复杂度不会小于:O(nlogn);

3、决策树下的排序算法

有3个数<a1, a2, a3>,用决策树进行排序。

(1)、决策树:一般情况下,有n个元素需要排序,左边的子树说明ai <= aj;右边的子树对应ai > aj;每一个叶子结点表示一种排序结果,最终的结果a1 < a2 < a3......< an;

(2)、因此比较型排序算法都可以被转换成决策树模型的方式;

(3)、n值的决策树,就是把算法中这些比较的所有可能结果分别列出来;决策树指出了所有可能的路线,用决策树分析比较型的算法是很有用的;

  对于n个元素的排序, 用决策树可以证明比较型的排序算法的时间复杂度:取决于树的高度,此时叶子节点的个数是n!,树高>=nlog(n);

  树的高度决定比较的次数,进而决定时间复杂度;

时间: 2024-12-20 01:20:15

随机化快排和决策树的相关文章

关于快排与随机化快排

快排是我们比较熟悉的排序算法,时间复杂度最佳为O(nlogn),最坏为O(n2)随机化快排只是通过换轴将产生最坏情况可能性降低 1 #include<stdio.h> 2 #include<math.h> 3 #include<stdlib.h> 4 #include<iostream> 5 #include<time.h> 6 using namespace std; 7 8 int a[1000000]; 9 int Partition(in

随机化快排

procedure qs(l,r:integer);var i,j,x,t:integer;begin    i:=l; j:=r;        x:=a[l+random(r-l)+1];    repeat        while (a[i]<x) do inc(i);        while (a[j]>x) do dec(j);        if i<=j then        begin            t:=a[i];a[i]:=a[j];a[j]:=t;  

快排变种

随机化快排 快速排序的最坏情况基于每次划分对主元的选择.基本的快速排序选取第一个元素作为主元.这样在数组已经有序的情况下,每次划分将得到最坏的结果.一种比较常见的优化方法是随机化算法,即随机选取一个元素作为主元.这种情况下虽然最坏情况仍然是O(n^2),但最坏情况不再依赖于输入数据,而是由于随机函数取值不佳.实际上,随机化快速排序得到理论最坏情况的可能性仅为1/(2^n).所以随机化快速排序可以对于绝大多数输入数据达到O(nlogn)的期望时间复杂度.一位前辈做出了一个精辟的总结:“随机化快速排

初探快排

学了数据结构,实现下快排, public void QuickSort1(float[] seq,int low,int hight){int i = low;//记录最左值索引int j = hight;//记录最右值索引float temp = seq[low];//记录比较值(此处是最左值)while (low < hight)//每轮比较{while (low < hight && temp >= seq[hight]){hight--;}seq[low] = s

快排,随机快排,双路快排,三路快排的理解

再讲快排之前,首先对于任何一个数组,无论之前是多么杂乱,排完之后是不是一定存在一个数作为分界点(也就是所谓的支点),在支点左边全是小于等于这个支点的,然后在这个支点右边的全是大于等于这个支点的,快排过程就是寻找这个支点过程 先看普通的快排(普通单路快排) 代码如下 let findIndex = (arr, l, len) => { let par = arr[l], j = l for (let i = l + 1; i <= len; i++) { if (arr[i] < par)

算法学习——单链表快排

/**  * 以p为轴对start-end间的节点进行快排(包括start && 不包括end):  * 思路:  * 1.将头节点作为轴节点start,从start.next开始遍历,如果节点小于轴start的值,将该节点插入到轴节点后面:  * 2.将轴节点插入合适位置,即找到最后一个小于轴的节点,将该节点与轴节点值互换,此时就链表分为两部分,小于轴节点和大于轴节点:  * 3.递归的遍历2中两部分节点.  *   * @param p  * @param start  * @para

快排的递归和非递归

常用的快排都是用递归写的,因为比较简单,但是可以用栈来实现非递归的快排. 第一种是递归的快排 #include<stdio.h> #include <stdlib.h> #include <time.h> int quick(int a[],int i ,int j) {     int tmp=0,key,b=0;     int im,jm;     im=i;     jm=j;     key=a[i];     if(i>j)         retur

Quick Sort(快排)

这是挖坑填补法的演示 快排之挖坑填补法: 1 void Quick(int top/*起始位置*/,int end/*末尾位置*/,int arr[])//挖坑填补法 2 { 3 int i=top,j=end,mark;//i是记住前面的坑 j记住后面的坑 mark记住标准值 4 5 mark=arr[top];//以起始位置作为标准值,同时起始点成为第一个坑 6 if(top>=end)return; 7 while(i<j) 8 { 9 while(i<j)//从后向前找比标准值小

冒泡,快排代码+注释

冒泡: package Sort; public class BubbleSort { public static void main(String[] args) { int[] list = new int[]{12,14,3,24,1,33}; int[] nums = bubbleSort(list); for(int i = 0;i< list.length;i++){ System.out.println(nums[i]); } } public static int[] bubbl