91精品久久久久久久久不口人,日韩欧美国产视频,亚洲国产最新

Tue, 08 Dec 2009 06:21:00 GMT

下面介绍的排序都为：非比较排序法

�q�里个�h认�ؓ在某些特定的地方非比较排序的速度非常明显�Q?br /> 比如 �Q?对待排数据中有顺序分�c�，使用鸽�l(f��)��M��分类�Q�然后对不同�c�d��的待排小数据集合采用插入�Q�快排等排序方式

Counting sort �Q�计数排�?br /> 描述�Q��P代待排序数组出元素x�Q�确定小于此元素[z]个数�Q�然后把x攑ֈ�它在的最�l�输出数�l�[z]上�?br /> �Ҏ(gu��)��：与待排值有养I��E�_��的排序算法；待排序数据要求过于严��|��无实际用处；
��法的步骤如下：
   1. 扑և�待排序的数组中最大和最��的元素
   2. �l�计数组中每个��gؓi的元素出现的�ơ数�Q�存入数�l�C的第i��?br />    3. �Ҏ(gu��)��有的计数累加�Q�从C中的�W�一个元素开始，每一��和前一��相加）
   4. 反向填充目标数组�Q�将每个元素i攑֜�新数�l�的�W�C(i)��，每放一个元素就��C(i)减去1

Radix sort�Q�基数排�?br /> 描述�Q�将所有待比较数�?正整�?�l�一为同��L��C��长度,��C��较短的数前面补零. 然后, 从最低位开�? 依次�q�行一�ơ排�?�q�样从最低位排序一直到最高位排序完成以后, 数列��变成一个有序序�?
排序方式�Q�LSD 由右向左排；MSD 由左向右�?br /> �Ҏ(gu��)��：非比较排序；待排数据需要统一格式�Q?br /> 假设需排序数列的取��D��围从1...k,我们于是��Z��个K+1元的数组 a[]�Q��ƈ赋初��gؓ0�Q�然后便开始排序工作：
��法的步骤如下：
   1. 按输入顺序读入数列，如果所�ȝ��元素为i(1<=i<=k),我们��将a[i]的值加一�Q�这��L��到读完所有的元素�?br />    2. ��d��元素�q�排序：我们遍历整个数组�Q�如果a[i]=j(j>=0),我们��p��出j�ơi(表示元素i在原先数列中出现了j��?,�q�样输出的序列就是已排序的�?br />    3. �׃��一般排序算法涉及到元素之间的比较，如果化成比较树可以知道，�q�样的排序算法复杂度的下限是O(N*lnN),而计数排序没有比较元素，所以所需排序旉��少了，我们可以看到计数排序的复杂度为O(n*k)�Q�其中k�Q�k的定义同上）为合�q�排列所需的时��_��是个常数�?br />    4. 此算法适合所需排列的元素取��D��围不大的情况下，否则会造成�I�间的消耗，比如�Q�一�?00个元素，其取��D��围从1-100000�Q�显然这个时候用基数排序是不合适的�?br />

Bucket sort�Q�桶排序
描述�Q�工作的原理是将阵列分到有限数量的桶子里。每个桶子再个别排序�Q�有可能再��用别的排序算法或是以递回方式�l�箋使用桶排序进行排序）�?br /> 桶排序以下列�E�序�q�行�Q?br />    1. 讄��一个定量的阵列当作�I�桶子�?br />    2. 寻访序列�Q��ƈ且把��目一个一个放到对应的桶子厅R�?br />    3. �Ҏ(gu��)��个不是空的桶子进行排序�?br />    4. 从不是空的桶子里把项目再攑֛�原来的序列中�?br />

Pigeonhole sort�Q�鸽巢排�?br /> 描述�Q�是一�U�时间复杂度为O(n)且在不可避免遍历每一个元素�ƈ且排序的情况下效率最好的一�U�排序算�? 但它只有在差�?或者可被映��在差�?很小的范围内的数值排序的情况下实�?
��法的步骤如下：与桶排同

刘凯�?/a> 2009-12-08 14:21 发表评论

Thu, 03 Dec 2009 09:11:00 GMT

# 快排 �?分治很像都是分而治�?/strong> �Q�但他们却是相反�?方式排序 �Q?br /> 分治是想拆分完成后，合�ƈ以有序的��段�q�行排序 �Q�而快排是直接由原始的“拆分”�?strong>排序 �?br />

#encoding=utf-8
#�?nbsp;�?nbsp;�?nbsp;��?/span>
def partition(A,p,r):
    tmp=A[p]
    while True :
        while p+1<r and A[p] > tmp : p+=1
        while r-1>p and A[r] <= tmp : r-=1
    if A[p]<=A[r]: A[p],A[r]=A[r],A[p]
    if r-1<=p : return p

def quickSort(A,p,r):
    if p<r:
        q=partition(A,p,r)
        quickSort(A,p,q)
        quickSort(A,q+1,r)

A=[9,61,7,14,-1,7,667,3,6,8]
print A
quickSort(A,0,len(A)-1)
print A
# �l�果 [667, 61, 14, 9, 8, 7, 7, 6, 3, -1]

图解�Q?br /> 一�ơ�P代过�E�描�q?�Q�从��到大）�Q?br /> 1. �?A[0] 为切分点用��时变�?记录 �q�里�?切分�?/strong> = [5]
2. 分别�?2枚指�?[切分起左,右]
3. 分别向中�?靠拢 �Q?当左指针指向值大�?切分�?停止 �?�Q?��x��针指向�?��于切分�?停止 �?�?br /> 4. 判断是否�?nbsp; 停止�?�?左�?��于叛_�?是：交换两指针�?�Q?

�W�一�ơ�P代后 :
以初始分�?[5] ��已�l�切分好�?��于 5 的左 �Q�大于等�? 的右

刘凯�?/a> 2009-12-03 17:11 发表评论

Tue, 01 Dec 2009 04:05:00 GMT

转自�?/strong>http://www.cnblogs.com/coderzh/archive/2008/09/22/1296195.html�?br /> 作者：CoderZh�Q?a target="_blank" >CoderZh的技术博�?- 博客�?/a>�Q?br /> 出处�Q?a target="_blank" >http://coderzh.cnblogs.com/
# 我这加了�?个�h理解�?说明

#encoding:UTF-8
# [递归] - 单条�?nbsp;自下往上排�?nbsp;
def heap_adjust(data, s, m):
    if 2 * s > m:return

    # 声明预设父节点位�|?/span>
    temp = s - 1

    # [左]子节点�?nbsp;大于父节点�?nbsp; :  预设父节点位�|?nbsp;�?nbsp;左子节点位置
    if data[2*s - 1] > data[temp]: temp = 2*s-1

    # [右]子节点�?nbsp;大于预设父节�?nbsp;: 预设父节点位�|?nbsp;�?nbsp;叛_��节点位置
    if 2 * s <= m - 1 and data[2*s] > data[temp]: temp = 2 * s

    # 交换�?nbsp;满�� 堆特�?nbsp;此�ؓ [ 父节�?nbsp;��于子节�?nbsp; ]
    if temp <> s - 1:
        data[s - 1], data[temp] = data[temp], data[s - 1]
        heap_adjust(data, temp + 1, m)

def heap_sort(data):
    m = len(data) / 2
    # 构徏堆树
    # ��试数据 [3,2,1] 数组��gؓ 所以非底层叶节�?/span>
    for i in range(m , 0, -1):
        heap_adjust(data, i, len(data))


    # 从堆树中 [出栈] 排序输出
    # ��试数据 [5, 4, 3, 2]
    data[0], data[-1] = data[-1], data[0]
    for n in range(len(data) - 1, 1, -1):
        heap_adjust(data, 1, n)
        data[0], data[n - 1] = data[n-1], data[0]

data=[2,3,6,3,868,9,8,-1]
heap_sort(data)
print data
# [-1, 2, 3, 3, 6, 8, 9, 868]

转自 �?http://www.cppblog.com/guogangj/ �?br /> 堆存�?/strong>

�?入栈复杂度�ؓΟ(logn)

�?出栈 Ο(logn)

刘凯�?/a> 2009-12-01 12:05 发表评论

Wed, 25 Nov 2009 15:09:00 GMT

看第二节 - 递归树方�?�Q?br /> �H�发奇想能否使用 txt 构造出递归�q�程
�q�是�?上此提到�?递归�Ҏ(gu��)�� 分治排序

# encoding: utf-8
arr=[]
def printTree():
    ac = []
    ii = 0
    for r in arr :
        c,ss,cc = r
        sc = [' ' for i in xrange(cc*(c-1))]
        for i in xrange(len(sc)) :
            if i % cc == 0 : sc[i]="�?/span>"
        #print "ci %s ii %s = %s "%(ci,ii,ii < ci)
        if ii>=c  :
            sc = "".join(sc)+"├─"+ss+'  '
        else :
            sc = "".join(sc)+"└─"+ss
        ii = c
        ac.append( sc )

    for r in ac[::-1] :
        print r


def MERGE(A,p,q,r):
    #print "%s:%s - %s:%s" % (p,q+1,q+1,r+1)
    if p==q : L = [A[p],10**10]
    else : L = A[p:q+1]+[10**10]

    if q+1==r : R = [A[r],10**10]
    else : R = A[q+1:r+1]+[10*10]

    i = j = 0
    for k in xrange(p,r+1):
        if L[i]<R[j] :
            A[k]=L[i]
            i+=1
        else:
            A[k]=R[j]
            j+=1
    # print "%s:%s = %s \n%s:%s = %s\n\n%s" % ( p,q, L , q+1,r,R, A)

def MERGE_SORT(A,p,r,c=1):
    if p<r:
        q = (p+r)/2
        MERGE_SORT(A,p,q,c+1)
        MERGE_SORT(A,q+1,r,c+1)
        arr.append( (c,"%s - %s" % ( A[p:q+1],A[q+1:r+1]) , 3 ) )
        # Debugging(A,p,q,r, sc )
        MERGE(A,p,q,r)

A=[5,2,7,4,1,3,2,6]
MERGE_SORT(A,0,len(A)-1)
print A
printTree()

输出 �Q�重下往上看输出排序�q�程 �Q�我��׃��多说�?应该很好理解了！�Q�）�Q?br />
[1, 2, 2, 3, 4, 5, 6, 7]
├─[2, 4, 5, 7] - [1, 2, 3, 6]
�?nbsp; ├─[1, 3] - [2, 6]
�?nbsp; �?nbsp; ├─[2] - [6]
�?nbsp; �?nbsp; └─[1] - [3]
�?nbsp; ├─[2, 5] - [4, 7]
�?nbsp; �?nbsp; ├─[7] - [4]
�?nbsp; �?nbsp; └─[5] - [2]

刘凯�?/a> 2009-11-25 23:09 发表评论

Mon, 23 Nov 2009 15:33:00 GMT

3.1 渐近�?/strong>

渐近范围      f(n) = θ(g(n)) ~a=b
渐近上界      f(n) = Ο(g(n)) ~a<=b    0≤f(n)≤cg(n)
渐近下界      f(n) = Ω(g(n)) ~a>=b    0≤cg(n)≤f(n)
非渐�q�上�?nbsp; f(n) = o(g(n))    ~alim[n<=∞](f(n)/g(n))=0
非渐�q�下�?nbsp; f(n) = ω(g(n))   ~a>b     0≤cg(n)lim[n<=∞](f(n)/g(n))=0

渐近号��用（目前我能理解到的�Q�）:
当渐�q�符号出现在某个公式中时�Q�我们将其解释�ؓ一个不在乎其名�U�的�|�名函数�?br /> 例：2n^2+3n+1 = 2n^2+θ(n) �Q�这�U�用法有助于屏蔽无关紧要的细节，如低阉��。�?br />
∑[1≤k≤n]O(i)

3.2 标准记号和常量函�?/strong>
单调�?�Q?单调递增 �Q?单调递减
# 传说中的�q�播体操原来�?上下取整�?�Q?呵呵
下取��_��上取�?�Q?x-1 < └X�?<= x   <= ┌X�?nbsp; < x+1

取模�q�算 a mod n = a-└a/n┘n

多项�?nbsp; p(n) = ∑[0≤i≤d] a.i n^i

指数 (a^m)^n = a^(m*n)   ; a^m*a^n = a^(m+n)

# 指数中的 �Ҏ(gu��)��W�号 e
# e不论对x微分几次�Q�结果都�q�是e�Q�难怪数学系学生会用e比喻坚定不移的爱情！
# 数学中的爱情�W�号 e 哈哈�Q�！
e = lim[n≤∞](1+1/n)^n

�Ҏ(gu��)��
lgn = log_2(n)
lnn=log_e(n)
lg^k(n)=(lgn)^k
lg lg n = lg(lgn)

阶乘 n!

函数�q�代

斐�L那切
F0 = 0
F1 = 1
..
Fi = Fi-1+Fi-2

刘凯�?/a> 2009-11-23 23:33 发表评论

Sun, 22 Nov 2009 15:56:00 GMT

公式�Q?br />

#数据 elt 清洗�?txt)
# 一�?nbsp;user �?nbsp;item 分值化
# 比如用户下蝲�Q�收藏，试听某item �{�等
user    items    score
.

# �l�果输出 (bdb)
# user    item1:score1,item2:score2,item3:score3.

python<<EOF
import bsddb
db = bsddb.hashopen('user-items.db','c')
for row in open('user-item-sc.txt'):
    row=row.split('\n')[0]
    dr = row.split(':')
    if not db.has_key(dr[0]) : db[dr[0]]=dr[1]+':'+dr[2]
    else : db[dr[0]]=db[dr[0]]+';'+dr[1]+':'+dr[2]

db.close()
EOF

# �l�果输出 (txt)
# user    user     score

python<<EOF
import bsddb
from math import *
db = bsddb.hashopen('user-items.db','c')

def ps(u1,u2):
    um1={}
    for v in db[u1].split(';') :
        v=v.split(':')
        um1[v[0]]=float(v[1])
    um2={}
    si=[]
    for v in db[u2].split(';') :
        v=v.split(':')
        um2[v[0]]=float(v[1])
        if um1.has_key( v[0] ) : si.append(v[0])
    n = len(si)

    if n ==0.0 :return None

    sum1=sum( [um1[it] for it in si] )
    sum2=sum( [um2[it] for it in si] )

    sum1Sq=sum([ pow(um1[it],2) for it in si])
    sum2Sq=sum([ pow(um2[it],2) for it in si])

    pSum = sum( [ um1[it]*um2[it] for it in si ] )

    num = pSum - (sum1*sum2/n)
    den = sqrt( (sum1Sq-pow(sum1,2)/n )*( sum2Sq-pow(sum2,2)/n ) )
    if den==0.0 : return None
    return num/den

fc = open('user-user-sc.txt','w')
for i in xrange(1,43381):
    for j in xrange(i+1,43381):
        sc = ps(str(i),str(j))
        if not sc == None: print >>fc, "%s\t%s\t%s" %(i,j,sc)

fc.close()

EOF

# ��试使用
python<<EOF
import bsddb
db = bsddb.hashopen('user-items.db','c')
print db['1']
EOF

25    30604    1.0

print um1['468'],um1['471']
2.0 1.0
(Pdb) print um2['468'],um2['471']
2.0 1.0

如果对大家对推荐有一些了解，数据能到用户与用户关�p?分值化) ,是能�q�很多事情了�?br /> 比如�Q?br /> 1. 首先得到某用��L��q�度最高的几位�z�跃用户�Q�看�q�几位用户在看什么，听什�?然后推荐出去

扩展�Q?br /> 把初始�?反过�?nbsp; item user score �Q�然后统计出 item �?item 之间的关�p?�?br /> �?消费某一产品 �Q�马上推荐出其他的相�q�的产品 �Q�時时推荐）

刘凯�?/a> 2009-11-22 23:56 发表评论

跟我一起学 - ��法��D�� - 分治��法

Sun, 22 Nov 2009 15:26:00 GMT
��法��D��,一章二��节 ,分治��法

def MERGE(A,p,q,r):
    print "%s:%s - %s:%s" % (p,q+1,q+1,r+1)
    if p==q : L = [A[p],10**10]
    else : L = A[p:q+1]+[10**10]

    if q+1==r : R = [A[r],10**10]
    else : R = A[q+1:r+1]+[10*10]

    i = j = 0
    for k in xrange(p,r+1):
        if L[i]<R[j] :
            A[k]=L[i]
            i+=1
        else:
            A[k]=R[j]
            j+=1
    # print "%s:%s = %s \n%s:%s = %s\n\n%s" % ( p,q, L , q+1,r,R, A)

def Debugging(A,p,q,r,c):
    print "%s\t%s:%s - %s:%s" % (c,p,q,q+1,r)

def MERGE_SORT(A,p,r,c=1):
    if p<r:
        q = (p+r)/2
        MERGE_SORT(A,p,q,c+1)
        MERGE_SORT(A,q+1,r,c+1)
        #Debugging(A,p,q,r,c)
        MERGE(A,p,q,r)

A=[5,2,7,4,1,3,2,6]
print A
MERGE_SORT(A,0,len(A)-1)
print A

�l�果输出》�?br /> python 2f.py
[5, 2, 7, 4, 1, 3, 2, 6]
[1, 2, 2, 3, 4, 5, 6, 7]

分��n些细节：��法�q�不难，但确实写了很久，调试让我很郁闗��?br /> 直到写了 def Debugging 目测�Q?br />
python 2f.py
3       0:0 - 1:1
3       2:2 - 3:3
2       0:1 - 2:3
3       4:4 - 5:5
3       6:6 - 7:7
2       4:5 - 6:7
1       0:3 - 4:7

�?每层 �Ҏ(gu��)��l�的数组下标取�?�Q?
�?python 中当
arr = [1,2,3,4] 我希望能取出 [2,3] �?arr[1:3] 是最后一位不计算在内�?br /> 最典型�?nbsp; arr[0,1] == [1]

刘凯�?/a> 2009-11-22 23:26 发表评论

理解高斯函数�Q�以及在推荐��法中的应用

Thu, 19 Nov 2009 03:14:00 GMT

�q�是一个很有用�?公式比如�Q�用��h��费分值权�?�Q?产品兌��分值权�?�{�等

公式

�?http://www.wolframalpha.com 中表�C?:
e = (1+1/n) ^n
a*e^(-(x-b)^2/c^2)
a 峰值最大�?
b 峰值x轴偏�U�量
c 弧度跨度

= 1*e^(-(x-1)^2/1^2)

修改峰�?a = 2

�q�里 ��?不一一展现 b 峰值x轴偏�U�量 �Q?c 弧度跨度 �?大家可以 �?wolframalpha 自己��d��?br />

实例1 与时间有关的递减 �Q?br />

import math
def gaussian(x,peak=1.0,axis=1.0,span=1.0):
    return peak*math.e**(-(x-axis)**2/(span)**2 )

跨度 c 参�?
c = 1 : �?.5 附�g急剧衰减
c = 2 : 4
c = 18 :30 # �q�个�?nbsp;衰减�l�计一个月不错
c = 55 :90 # 衰减�l�计一个季�?nbsp;不错

#��单应�?nbsp;
消费1�ơ得峰�?�?nbsp;��览1�ơ峰�?�?nbsp;
�l�计某用户季度得�?br /> 数据�Q�在�?0天浏�?0�ơ，消费1��?nbsp;�Q�前11天浏�?��?nbsp;
d10 = gaussian(10,span=55.0)
d11 = gaussian(11,span=55.0)
print d10*10*2+d10*4*1+d11*5*2
#�l�果 33.0407089687

倒的高斯　�Q�　实例2 �Q?br /> 公式 =

目的　与次数有关的产品分值化
#用户 �?nbsp;某��?nbsp;分值化
# 比如某用�?nbsp;用过某��?nbsp;n�ơ，我希�?nbsp;n 无限大是一�?nbsp;渐进某个�?nbsp;而不是和 n 无限递增�?/span>
#下面�?nbsp;fun �l�果�?nbsp; 1.6 �?nbsp;10 分值直接的区域, 也就�?nbsp;传说中的产品感兴��?nbsp;“10分制” ��易版
def gs(x,peak=9.0,axis=-2.0,span=11.0):
    return "%.4f" % (-1*peak*math.e**(-(x-axis)**2/(span)**2 )+peak+1)

>>> gs(1)
'1.6451'
>>> gs(2)
'2.1148'
>>> gs(3)
'2.6800'
>>> gs(4)
'3.3161'
>>> gs(5)
'3.9970'
>>> gs(6)
'4.6969'
>>> gs(60)
'10.0000'

刘凯�?/a> 2009-11-19 11:14 发表评论

跟我一起学 - ��法��D�� - 插入排序

Wed, 18 Nov 2009 15:29:00 GMT
��法��D�� - ��法入门 ,一��节�Q�插入排�?复杂度）
#  插入排序                -         复杂�?/span>
def insertion_sort(arr):             # 1
    for j in xrange( 1,len(arr) ):   # n-1
        key = arr[j]                 # n-1
        i=j-1                        # n-1
        while i>=0 and arr[i]> key : # n(n-1)/2
            arr[i+1] = arr[i]        # n(n-1)/2
            i=i-1                    # n(n-1)/2
        arr[i+1] = key               # n-1
        print arr                    # n-1

验证�l�果 :
>>> arr=[5,2,4,6,1,3]
>>> insertion_sort(arr)
[2, 5, 4, 6, 1, 3]
[2, 4, 5, 6, 1, 3]
[2, 4, 5, 6, 1, 3]
[1, 2, 4, 5, 6, 3]
[1, 2, 3, 4, 5, 6]

验证复杂度：
z = 5(n-1)+1+3n(n-1)/2
我们��试数据 �?nbsp; n=6
当数据极端情况就是需要全部重新排�?
��是 [6,5,4,3,2,1] 要排�?[1,2,3,4,5,6] �q�样
>> z = 71

一�U�比较笨�?验证�Ҏ(gu��)�� 供大家拍�?:

def insertion_sort(arr):
    ii=0
    ii+=1
    for j in xrange( 1,len(arr) ):
        ii+=1

        key = arr[j]
        ii+=1

        i=j-1
        ii+=1

        while i>=0 and arr[i]> key :
            ii+=1

            arr[i+1] = arr[i]
            ii+=1

            i=i-1
            ii+=1

        arr[i+1] = key
        ii+=1

        print arr
        ii+=1

    print "----",str(ii)

>>> arr=[6,5,4,3,2,1]
>>> insertion_sort(arr)
[5, 6, 4, 3, 2, 1]
[4, 5, 6, 3, 2, 1]
[3, 4, 5, 6, 2, 1]
[2, 3, 4, 5, 6, 1]
[1, 2, 3, 4, 5, 6]
---- 71 #复杂度验证�ؓ 71

�|�嗦�?n(n-1)/2
极端情况�?nbsp;
i=1 ; j 需要挪�?1��?br /> i=2 ; j 挪动 1+2��?br /> i=3 ; j 挪动 1+2+3��?br /> ....
i=n ; j 挪动 1+2....+n

我们又找�?(1+n)+(2+n-1)+(3+n-2).... = (1+n)n/2
我们�q?�?i 是从 2 �ơ开始的也就是说 (n-1)n/2 �?

def tn(ii):
    ti=0
    for i in xrange(ii) :
        for j in xrange(i) :
            ti+=1
    print ti

print tn(2)  #1 = 1
print tn(3)  #3 = 1+2
print tn(4)  #6 = 1+2+3
..

刘凯�?/a> 2009-11-18 23:29 发表评论

��法复杂度分析图

Tue, 17 Nov 2009 15:12:00 GMT
发现自己写个��程�?- 文本存储二叉�l�构的hashMap�?那个费劲�Q?痛下军_�� 仔细学习 ��法 �?br /> �Q�如果大家有兴趣��p��我一�?- 《算法导论�?/strong>�Q�也望大家监督我能每天拿��Z��时和大家分享算�?��法代码我会��量使用 py �?解决一些分析日志的应用上靠 �Q�其实，上面费劲�?二叉hash 是�ؓ了分析日志中 - 希望能实�?多个大文件不需要合�q�就能根据某列排序输�? 目前的解军_��?find .. -exec cat {} \; | perl |sort 的笨�Ҏ(gu��)�� Q?

1. ��法在计��中的作�?�Q�笔讎ͼ� :
   ��法(algorithm):��是定义良好的计��过�E�，它取一个或一�l�作��出，�q��生一个或一�l�自作�ؓ输出�?br />
一些函数运行��?nbsp; # http://www.wolframalpha.com/ 函数都可在网站里�q�行
�q�里 n=一亿条数据 :
log_2(n)     30
n^0.5        31622
n            10^9
n*log_2(n)   2.9^10
n^2          10^18
n^3          10^27
2^n          无穷
n!           10^362880

需要知道的复杂�?- 在某一个��界点�?合�ƈ会别插入要快�?br /> 插入排序复杂�?n^2    http://www.wolframalpha.com/input/?i=n^2
合�ƈ排序复杂�?n*log_2(n) http://www.wolframalpha.com/input/?i=n*log_2%28n%29+

�|�上的查扑ֈ�的一些名�U�ͼ�参�?http://www.51testing.com/?uid-130868-action-viewspace-itemid-66729
1.1�E�_��排序非稳定排�?-
�E�_��排序是所有相�{�的数经�q�某�U�排序方法后�Q�仍能保持它们在排序之前的相�Ҏ(gu��)��序，。反之，��是非稳定的排序�?br /> 1.2内排�?nbsp; 外排�?/strong>
在排序过�E�中�Q�所有需要排序的数都在内存，�q�在内存中调整它们的存储��序�Q�称为内排序�Q?在排序过�E�中�Q�只有部分数被调入内存，�q�借助内存调整数在外存中的存放��序排序�Ҏ(gu��)��U�Cؓ外排序�?br /> 1.3��法的时间复杂度 �I�间复杂�?/strong>
所谓算法的旉��复杂度，是指执行��法所需要的计算工作量�?一个算法的�I�间复杂度，一般是指执行这个算法所需要的内存�I�间�?br />

几种常见的算法复杂度�Q?br /> 2.1冒��排序 �Q�Bubble Sort�Q?nbsp;   O(n^2)
2.2选择排序 �Q�Selection Sort�Q?O(n^2 )
2.3插入排序 �Q�Insertion Sort�Q?O(n^2)
2.4堆排�?nbsp;   O( nlog(n) )
2.5归�ƈ排序 O( nlog_2(n) )
2.6快速排�?nbsp; 最�?O( nlog_2(n) ) 最�?O(n^2)

wiki 参�?�Q�http://zh.wikipedia.org/wiki/%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95
�I�定�?/strong>

冒��排序�Q�bubble sort�Q?�?O(n²)

插入排序 �Q�insertion sort�Q��?O(n²)

�a�數排序 (counting sort) �?O(n+k); 需�?O(n+k) ��外�I�間

合併排序 �Q�merge sort�Q��?O(n log n); 需�?O(n) ��外�I�間

原地合併排序 �?O(n²)

二叉排序�?/a>排序 �Q�Binary tree sort�Q?�?O(n log n)期望時間; O(n²)最壞時�? 需�?O(n) ��外�I�間

 �¿�l(f��)排序 (Pigeonhole sort) �?O(n+k); 需�?O(k) ��外�I�間

基數排序 �Q�radix sort�Q��?O(n·k); 需�?O(n) ��外�I�間

[不穩�?/span>

選擇排序 �Q�selection sort�Q��?O(n²)

希爾排序 �Q�shell sort�Q��?O(n log n) 如果使用最佳的珑֜�版本

堆排�?/a> �Q�heapsort�Q��?O(n log n)

快速排�?/a> �Q�quicksort�Q��?O(n log n) 期望時間, O(n²) 最壞情�? ��於大的、亂�怸�列一般相信是最快的已知排序

 [不實用的排序演算�?/span>

Bogo排序 �?O(n × n!) 期望時間�Q�無�H�的最壞情況�?/li>
刘凯�?/a> 2009-11-17 23:12 发表评论

��法公式 - 囑�Ş�?

Thu, 05 Nov 2009 05:09:00 GMT

在定�?数学公式的时�?可能希望有个直观�?展现

http://www.wolframalpha.com/

我们前一�D�|��间用到的 { 推荐分�?90 �?递减公式�Q�如果这东西早发�?公式��׃��会错了！}

目前我们递减的公�?/div>
y=-x/90+1

在比如我们优化下 90天改�?

(y*10)^2=-x+90

2009-11-05

刘凯�?/a> 2009-11-05 13:09 发表评论

apriori-实现

Tue, 01 Sep 2009 09:43:00 GMT
谢谢同事孙超讲解
�q�就把他�?思想 ��M��?

刘凯�?/a> 2009-09-01 17:43 发表评论

Mon, 31 Aug 2009 06:25:00 GMT

代码:

# -*- coding: UTF8 -*-

import sys
# 最��?nbsp;支持�?/span>
sup_min = int(sys.argv[1])

ss = ","

# 交易数据 �?/span>
D=[
'A,B,C,D',
'B,C,E',
'A,B,C,E',
'B,D,E',
'A,B,C,D'
]

print "交易数据库展�?/span>"
for arr in D : print arr
print

'''
rows=int(sys.argv[1])
D=[]
for tid in open('BuyMusic.20090722.mob.prodIds').readlines()[:rows] :
    D.append(tid.split("\n")[0].split("\t")[1])

print "��d�� 文�g�l�束 BuyMusic.20090722.mob.prodIds !"
'''
#全局频繁��?nbsp;攉��
sup_data_map = {}
#全局  最大频�J�项攉��
is_zsup={}

# 遍历�q�程临时局�?nbsp; 频繁��?nbsp;攉��
mapL = {}

# �W�一��?nbsp;频繁��?nbsp;攉��
def find_frequent_1_itemset(I):
    if I=='null' or I=='' : return
    if mapL.has_key(I): mapL[I]+=1
    else: mapL[I]=1

map(find_frequent_1_itemset,[ I  for TID in D for I  in TID.split(ss) ])

# 刷选掉 ��于最��支持度 �?nbsp;频繁��?/span>
def remove_not_sup_min(map,supmin=sup_min):
    for k  in [k for k,v in map.items() if v<supmin] :
        del map[k]
remove_not_sup_min(mapL)

print "�W�一��?nbsp;�{��?nbsp;频繁��?nbsp;�l�束!"
print mapL

# 装蝲全局频繁��?nbsp;最大频�J�项
for k,v in mapL.items() :
    sup_data_map[k]=v
    is_zsup[k]=v

# 判定是否 'BD' 属于  'BCD' �?nbsp;
isInTid = lambda I,TID : len(I.split(ss)) == len([i for i in I if i in TID.split(ss)])

# �l�合  [A,B] + [A,C] = [A,B.C]
def comb(arr1,arr2):
    tmap={}
    for v in arr1+arr2 : tmap[v]=""
    return tmap.keys()

# apriori �q�代核心
def runL(mapL,dep):
    mapL2 = {}
    C={}
    keys = mapL.keys()
    iik=""
    jjk=""
    # �Ҏ(gu��)�� 上次  频繁��?nbsp;�Q�生成本��?nbsp;'可能频繁��? 集合
    for ii in range(len(keys)) :
        for jj in range(ii+1,len(keys)) :
            keystr=comb([ch for ch in keys[ii].split(ss)],[ch for ch in keys[jj].split(ss)])
            if not len(keystr) == dep : continue
            keystr.sort()
            tk=ss.join(keystr)
            if not tk in C : C[tk]=(keys[ii],keys[jj])

    #  '可能频繁��? �Ҏ(gu��)�� 交易数据�?nbsp; 计数
    for tk,z in C.items():
        for TID in D:
            if isInTid(tk,TID) :
                if mapL2.has_key(tk): mapL2[tk]+=1
                else: mapL2[tk]=1

    # 刷选掉 ��于最��支持度 �?nbsp;频繁��?/span>
    remove_not_sup_min(mapL2)
    for k,v in  is_zsup.items() :
        for k1,v1 in mapL2.items() :
            if isInTid(k,k1) :
                del is_zsup[k]
                break
    # 全局频繁��?nbsp;,最大频�J�项  攉��
    for k,v in mapL2.items() :
        sup_data_map[k]=v
        is_zsup[k]=v
    print "�W?/span>"+str(dep)+"��?nbsp;�{��?nbsp;频繁��?nbsp;�l�束!"
    return mapL2

# 真正 �q�行
ii=1
while mapL :
    ii=ii+1
    mapL = runL(mapL,ii)
    print mapL

# 全局  频繁��?nbsp;�?nbsp;去除最大频�J�项
for k,v in is_zsup.items() :
    if sup_data_map.has_key(k) : del sup_data_map[k]

print "频繁��?/span>"
print sup_data_map
print
print "最大频�J�项"
print is_zsup
print

print "可信�?nbsp;展现"
for k,v in  sup_data_map.items() :
    for k1,v1 in is_zsup.items() :
        if isInTid(k,k1) :
            print k,"->",k1,"\t%.1f" %((float(is_zsup[k1])/float(sup_data_map[k]))*100)+"%"

�l�果:
-bash-3.00$ python ap.py 2
交易数据库展�?br /> A,B,C,D
B,C,E
A,B,C,E
B,D,E
A,B,C,D

�W�一��?�{��?频繁��?�l�束!
{'A': 3, 'C': 4, 'B': 5, 'E': 3, 'D': 3}
�W?��?�{��?频繁��?�l�束!
{'C,D': 2, 'C,E': 2, 'A,D': 2, 'A,B': 3, 'A,C': 3, 'B,E': 3, 'B,D': 3, 'B,C': 4}
�W?��?�{��?频繁��?�l�束!
{'A,B,D': 2, 'A,B,C': 3, 'B,C,D': 2, 'B,C,E': 2, 'A,C,D': 2}
�W?��?�{��?频繁��?�l�束!
{'A,B,C,D': 2}
�W?��?�{��?频繁��?�l�束!
{}
频繁��?br /> {'A': 3, 'C': 4, 'B': 5, 'E': 3, 'D': 3, 'C,D': 2, 'C,E': 2, 'A,D': 2, 'A,B': 3, 'A,C': 3, 'A,B,D': 2, 'B,C,D': 2, 'A,C,D': 2, 'B,E': 3, 'B,D': 3, 'B,C': 4, 'A,B,C': 3}

最大频�J�项
{'B,C,E': 2, 'A,B,C,D': 2}

可信�?展现
A -> A,B,C,D    66.7%
C -> B,C,E    50.0%
C -> A,B,C,D    50.0%
B -> B,C,E    40.0%
B -> A,B,C,D    40.0%
E -> B,C,E    66.7%
D -> A,B,C,D    66.7%
C,D -> A,B,C,D    100.0%
C,E -> B,C,E    100.0%
A,D -> A,B,C,D    100.0%
A,B -> A,B,C,D    66.7%
A,C -> A,B,C,D    66.7%
A,B,D -> A,B,C,D    100.0%
B,C,D -> A,B,C,D    100.0%
A,C,D -> A,B,C,D    100.0%
B,E -> B,C,E    66.7%
B,D -> A,B,C,D    66.7%
B,C -> B,C,E    50.0%
B,C -> A,B,C,D    50.0%
A,B,C -> A,B,C,D    66.7%

刘凯�?/a> 2009-08-31 14:25 发表评论

k-means �Q�python�Q�算�?

Fri, 07 Aug 2009 08:20:00 GMT

�?http://www.daniweb.com/forums/thread31449.html
什么都不说了，直接看代码吧�?br /> 注解应该写的比较详细

# liukaiyi
# �?nbsp;k-means �Q�维度类�?nbsp;- 数值�Ş�?nbsp;( 199 �?nbsp;23.13 )
import sys, math, random

# -- �c�d�� '数据'
# �?nbsp;n-�l�度�I�间
class Point:
    def __init__(self, coords, reference=None):
        self.coords = coords
        self.n = len(coords)
        self.reference = reference
    def __repr__(self):
        return str(self.coords)

# -- �c�d�� '聚集�?nbsp;/ 聚类�q�_��距离 �?nbsp;'
# -- �?nbsp;n-�l�度�I�间
# -- k-means 核心�c?/span>
# -- 每次聚集各点围绕�?nbsp;�q�行聚集
# -- �q�提供方�?nbsp;�?聚集后的计算中心点，同时记入此次中心�?聚集各点�q�_��距离)�Q��ؓ下一�ơ聚集提供中心点.
class Cluster:
    def __init__(self, points):
        if len(points) == 0: raise Exception("ILLEGAL: EMPTY CLUSTER")
        self.points = points
        self.n = points[0].n
    for p in points:
            if p.n != self.n: raise Exception("ILLEGAL: MULTISPACE CLUSTER")
        # �?nbsp;聚集各点�?nbsp;�q�_��?/span>
    self.centroid = self.calculateCentroid()
    def __repr__(self):
        return str(self.points)

    # 更新中心点，�q�返�?nbsp;原中心点 �?nbsp;��C��心点(聚集各点�q�_��距离)距离
    def update(self, points):
        old_centroid = self.centroid
        self.points = points
        self.centroid = self.calculateCentroid()
        return getDistance(old_centroid, self.centroid)

    # 计算�q�_��?nbsp;�Q�聚�?攉��各点�Q�离本类的中心点�Q�最�q�数�?后生成新�?nbsp;中心�?nbsp;�Q?/span>
    def calculateCentroid(self):
        centroid_coords = []
        #  �l�度 �q�代
    for i in range(self.n):
            centroid_coords.append(0.0)
            # 攉��各点 �q�代
        for p in self.points:
                centroid_coords[i] = centroid_coords[i]+p.coords[i]
            centroid_coords[i] = centroid_coords[i]/len(self.points)
        return Point(centroid_coords)

# -- �q�回�Ҏ(gu��)�� k-means 聚集形成�?nbsp;数据�?nbsp;
def kmeans(points, k, cutoff):
    # Randomly sample k Points from the points list, build Clusters around them
    initial = random.sample(points, k)
    clusters = []
    for p in initial: clusters.append(Cluster([p]))
    # �q�代 k-means 直到每次�q�代各收集点别的最�?nbsp;不超�q?nbsp;0.5
    while True:
        #  k 个收�?nbsp;数组
        lists = []
        for c in clusters: lists.append([])
    # �q�代每个数据�?nbsp;�Q��ƈ计算与每个中心点距离
    # �q�把数据�Ҏ(gu��)��加入相应最短的中心�Ҏ(gu��)��集数�l�中
    # 在�P代中 smallest_distance 为每个点与各中心�Ҏ(gu��)��短距��?nbsp;参数�Q�请注意�?/span>
        for p in points:
            smallest_distance = getDistance(p, clusters[0].centroid)
            index = 0
            for i in range(len(clusters[1:])):
                distance = getDistance(p, clusters[i+1].centroid)
                if distance < smallest_distance:
                    smallest_distance = distance
                    index = i+1
            # ��d��?nbsp;��L��短中心距��ȝ�� 数组�?/span>
        lists[index].append(p)

        # 聚集完，计算�?nbsp;中心�?/span>
    # �q?nbsp;cluster.centroid 属性记入下 ��C��心点�Q�下一��?nbsp;聚集的中心点 �Q?/span>
    # �q?nbsp;计算与上一��?nbsp;中心�?nbsp;距离 �Q�如�?nbsp;差值在 cutoff 0.5 以下 ,跛_��q�代 �Q�结束，�q�回最后一��?nbsp;聚集集合�Q?/span>
    biggest_shift = 0.0
        for i in range(len(clusters)):
            shift = clusters[i].update(lists[i])
            biggest_shift = max(biggest_shift, shift)
        if biggest_shift < cutoff: break
    return clusters

# -- 得到�Ƨ几里�d距离两点之间
def getDistance(a, b):
    # Forbid measurements between Points in different spaces
    if a.n != b.n: raise Exception("ILLEGAL: NON-COMPARABLE POINTS")
    # Euclidean distance between a and b is sqrt(sum((a[i]-b[i])^2) for all i)
    ret = 0.0
    for i in range(a.n):
        ret = ret+pow((a.coords[i]-b.coords[i]), 2)
    return math.sqrt(ret)

# -- �?nbsp;n-�l�度 �I�间中创�?nbsp;随机�?/span>
# -- 随机生成 ��试数据
def makeRandomPoint(n, lower, upper):
    coords = []
    for i in range(n): coords.append(random.uniform(lower, upper))
    return Point(coords)

# main
def main(args):
    # 参数说明
    # num_points,    n,    k,      cutoff,         lower,        upper
    # 随机数据数量 , �l�度, 聚集�? 跛_��q�代最��距��?nbsp;,   �l�度数最大�?�l�度数最��?/span>
    num_points, n, k, cutoff, lower, upper = 10, 2, 3, 0.5, -200, 200

    # �?nbsp;n-�l�度�I�间�?nbsp;, 创徏 num_points 随机�?/span>
    # ��试数据生成
    points = []
    for i in range(num_points): points.append(makeRandomPoint(n, lower, upper))

    # 使用 k-means ��法�Q�来聚集数据�?nbsp;(��法入口�?
    clusters = kmeans(points, k, cutoff)

    print "\nPOINTS:"
    for p in points: print "P:", p
    print "\nCLUSTERS:"
    for c in clusters: print "C:", c
if __name__ == "__main__": main(sys.argv)

刘凯�?/a> 2009-08-07 16:20 发表评论

91精品久久久久久久久不口人,日韩欧美国产视频,亚洲国产最新

跟我一起学 - ���法��D�� - 分治���法

理解高斯函数�Q�以及在推荐���法中的应用

跟我一起学 - ���法��D�� - 插入排序

���法 复杂度分析图

���法公式 - 囑�Ş�?

apriori-实现

k-means �Q�python�Q�算�?

跟我一起学 - ��法��D�� - 分治��法

理解高斯函数�Q�以及在推荐��法中的应用

跟我一起学 - ��法��D�� - 插入排序

��法复杂度分析图

��法公式 - 囑�Ş�?