python 快排,堆排,归并

#归并排序
def mergeSort(a,L,R) :
    if(L>=R) :
        return
    mid=((L+R)>>1)
    mergeSort(a,L,mid)
    mergeSort(a,mid+1,R)
    p=L
    q=mid+1
    t=[]
    while(p<=mid and q<=R) :
        if a[p]<=a[q] :
            t.append(a[p])
            p+=1
        if a[p]>a[q] :
            t.append(a[q])
            q+=1
    while (p<=mid) :
        t.append(a[p])
        p+=1
    while(q<=R) :
        t.append(a[q])
        q+=1
    cur=0
    for i in range(L,R+1) :
        a[i]=t[cur]
        cur+=1

a=[2,3,5,1,5]
mergeSort(a,0,4)
print a

#快速排序
import random

def Qsort(a) :
    if a==[] :
        return []
    val=random.choice(a)
    return Qsort([x for x in a if x<val]) + [x for x in a if x==val] +Qsort([x for x in a if x>val])

a=[1,3,4,6,2,4]
a=Qsort(a)

#堆排
def heapAjust(a,pos,sz) :
    if(pos>sz/2) :
        return
    Lchild=pos*2
    Rchild=pos*2+1
    Max=pos
    if(Lchild<=sz and a[Lchild]>a[Max]) :
        Max=Lchild
    if(Rchild<=sz and a[Rchild]>a[Max]) :
        Max=Rchild
    if(Max!=pos) :
        a[Max],a[pos]=a[pos],a[Max]
        heapAjust(a,Max,sz)
    
def buildHeap(a,sz) :
    for i in range(sz/2,0,-1) :
        heapAjust(a,i,sz)
def heapSort(a,sz) :
    buildHeap(a,sz)
    for i in range(sz,0,-1) :
        a[i],a[1]=a[1],a[i]
        heapAjust(a,1,i-1)

a=[0,1,2,5,3,4,6]
heapSort(a,6)
print a

时间: 2024-11-03 12:03:40

python 快排,堆排,归并的相关文章

堆排 归并排序 快排

堆排序的思想 利用大顶堆(小顶堆)堆顶记录的是最大关键字(最小关键字)这一特性,使得每次从无序中选择最大记录(最小记录)变得简单. 其基本思想为(大顶堆): 1)将初始待排序关键字序列(R1,R2....Rn)构建成大顶堆,此堆为初始的无序区: 2)将堆顶元素R[1]与最后一个元素R[n]交换,此时得到新的无序区(R1,R2,......Rn-1)和新的有序区(Rn),且满足R[1,2...n-1]<=R[n]; 3)由于交换后新的堆顶R[1]可能违反堆的性质,因此需要对当前无序区(R1,R2,

快排,堆排与归并排序

快排: Parition函数用于进行一次快排,本次快排将某个元素放在它应该呆在的位置pos.pos左侧全比它小,pos右侧全比它大. Parition中,设置low指针与high指针,以待排元素为标杆,判断high指向元素是否大于待排元素,若小于则与low指向的元素交换,并切换到low指针.low指针此时指向刚交换过来的元素,其一定小于待排元素,然后low自加直到low指向的元素大于待排元素,此时再与high指向的元素交换,high指向的元素为之前一次low - high交换前low指向的元素:

普林斯顿公开课 算法4-3:堆排

堆排的灵感源自于堆的数据结构.它是一种原地排序算法,不需要额外的临时数组. 基本思想 堆排的基本思想是: 先建立一个最大堆 将最大的元素移动到数组末尾,减小堆的大小,调整最大堆使其符合最大堆的性质 重复第二步,直到最大堆耗尽为止 第一个步骤建立最大堆的代码非常简单,只要对每个节点执行sink操作即可. 1 2 for(int k = N/2; k >= 1; k--)     sink(a, k, N); 第二个步骤也很简单,代码如下: 1 2 3 4 while(N > 1) {     e

STL_算法_Heap算法(堆排)(精)

C++ Primer 学习中... 简单记录下我的学习过程 (代码为主) /***************************************** STL-算法--Heap算法 堆排序算法 (heapsort) make_heap()         //把容器内的数据做堆排序 push_heap()         //向堆内放入元素 pop_heap()          //删除堆顶元素 sort_heap()         //把堆排还原成普通排序 ************

【Algorithm】堆排,C++实现

对一个数组中的元素按照顺序构建二叉树,就形成了一个(二叉)堆.(二叉树是虚拟的,并不是真的建立二叉树) 表示堆的数组A有两个重要属性:A.heapSize,表示堆里面有多少元素,数组里有多少元素在堆里  A.length,表示数组长度 例如数组A= {1,2,3,4,5,6,7,8,9,10},此时A.heapSize = A.length.除了最后一层之外,这个二叉树是完满的 最大堆:父节点的值总是不小于子节点的值,反应在数组中就是A[i]>=A[2i+1] && A[i]>

堆排Java代码实现

堆排复习: 结论:堆排算法时间复杂度为O(nlgn),额外空间复杂度为O(1); 在开始堆排序过程之前先要熟悉两个结构 1,完全二叉树:若设二叉树的深度为h,除第 h 层外,其它各层 (1-h-1) 的结点数都达到最大个数,第 h 层所有的结点都连续集中在最左边,这就是完全二叉树.(摘自百度百科) 大白话:说白了就是建立二叉树的过程中,二叉树每一层都是满节点的,最后一层的节点不许中间有空缺: 2,大根堆:大根堆要求根节点的关键字既大于或等于左子树的关键字值,又大于或等于右子树的关键字值.(摘自百

java代码实现:12个高矮不同的人,排成两排,每排必须是从矮到高排列,而且第二排比对应的第一排的人高,问排列方式有多少种?

此题参考与其他人思路, 2个解题方式. 1. 1 /** 2 * 用java代码实现:12个高矮不同的人,排成两排,每排必须是从矮到高排列,而且第二排比对应的第一排的人高,问排列方式有多少种? 3 * 状态树方式解 4 * 用状态生成树的方式来做的,先把12个人按从低到高一次编号, 5 * 从(1 ; 2)出发,加入3和4的时候生成(1,3 ; 2,4)和(1,2 ; 3,4), 6 * 然后加入5和6,分别从前面的两个状态出发,可以生成5种状态,就是说6个人时有5种排列 7 * @author

[硕.Love Python] BinomialHeap(B堆 & 二项堆)

class Node(object):     def __init__(self, data):         self.data = data         self.child = None         self.left = None         self.right = None         self.degree = 0     def __str__(self):         return str(self.data)     __repr__ = __str_

[硕.Love Python] FibonacciHeap(F堆 & 斐波那契堆)

class Node(object):     __slots__ = [         'data', 'child', 'left', 'right',         'degree', 'parent', 'childCut',     ]     def __init__(self, data):         self.data = data         self.child = None         self.left = None         self.right