s11d27 算法

一、理论

1.1 时间复杂度和空间复杂度的理论:

1）空间复杂度:

是程序运行所以需要的额外消耗存储空间,一般的递归算法就要有o(n)的空间复杂度了,

简单说就是递归集算时通常是反复调用同一个方法，递归n次，就需要n个空间。

2）时间复杂度

一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。

算法的基本操作重复执行的次数是模块n的某一个函数f（n），因此，算法的时间复杂度记做：T（n）=O（f（n））。

随着模块n的增大，算法执行的时间的增长率和f（n）的增长率成正比，所以f（n）越小，算法的时间复杂度越低，算法的效率越高。

1.2 函数调用的时间复杂度分析

按数量级递增排列，常见的时间复杂度有：

常数阶O(1),  对数阶O(log2n),  线性阶O(n),  线性对数阶O(nlog2n),  平方阶O(n^2)， 立方阶O(n^3),...， k次方阶O(n^k), 指数阶O(2^n)

常用的时间复杂度所耗费的时间从小到大依次是：O(1)<O(log2n)<O(n)<O(nlog2n)<O(n^2)<O(n^3)<O(2^n)<O(n!)<O(n^n)

常用的算法的时间复杂度和空间复杂度

排序法

平均时间复杂度

说明

稳定度

空间复杂度

备注

冒泡排序

O(n2)

将待排序的元素看作是竖着排列的“气泡”，较小的元素比较轻，从而要往上浮

稳定

O(1)

快速排序

O(n*log2n)

先选择中间值，然后把比它小的放在左边，大的放在右边（具体的实现是从两边找，找到一对后交换）。然后对两边分别使用这个过程（递归）。

不稳定

O(log2n)~O(n) 因为用到了递归！

选择排序

O(n2)

首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。以此递归。

稳定

O(1)

插入排序

O(n2)

逐一取出元素，在已经排序的元素序列中从后向前扫描，放到适当的位置

稳定

O(1)

起初，已经排序的元素序列为空

堆排序

O(n*log2n)

利用堆（heaps）这种数据结构来构造的一种排序算法。堆是一个近似完全二叉树结构，并同时满足堆属性：即子节点的键值或索引总是小于（或者大于）它的父节点。

不稳定

O(1)

近似完全二叉树

希尔排序

O

选择一个步长(Step) ,然后按间隔为步长的单元进行排序.递归,步长逐渐变小,直至为1.

不稳定

O(1)

箱排序

O(n)

设置若干个箱子，把关键字等于 k 的记录全都装入到第k 个箱子里 ( 分配 ) ，然后按序号依次将各非空的箱子首尾连接起来 ( 收集 ) 。

O(1)

分配排序的一种：通过" 分配 " 和 " 收集 " 过程来实现排序。

当一个算法的空间复杂度为一个常量，即不随被处理数据量n的大小而改变时，可表示为O(1)

访问数组中的元素是常数时间操作，一个算法如果能在每个步骤去掉一半数据元素，如二分检索，通常它就取 O(logn)时间。

二、查找算法

2.1 两分法

aList = [1, 2, 3, 4, 5, 6, 7, 8]

def binarySearch(aList, t):

    low = 0

    heigh = len(aList) - 1

    while low <= heigh:     # 这里为了防止，low=height然后不进入程序，return正确的情况，如：t=3,low=heigh=2

        mid = (low + heigh) / 2

        print 'mid:',mid

        if t > aList[mid]:

            low = mid + 1

        elif t < aList[mid]:

            heigh = mid - 1

        else:

            print "索引,值:",mid,aList[mid]

            return mid  # 返回索引值

        print 'low:',low

        print 'heigh:',heigh

    return -1       # 为了防止元素找不到的情况，就返回-1

print binarySearch(aList,2)

三、排序算法

3.1 冒泡排序

#!/usr/bin/env python

# -*- coding: utf-8 -*-

__author__ = 'WangQiaomei'

import random

import time

'''

aList=[]

for i in range(20):

    aList.append(random.randrange(100))

print aList

'''

aList=[]

for i in range(50000):

    aList.append(random.randrange(100000))

def bubble_sort(aList):# 例如 aList的个数是10个

    for i in range(len(aList)): # 循环索引 0-9

        for j in range(len(aList)-i-1):    # 第一次循环索引j为：8,这里为啥要-1，因为下面会有j+1

            if aList[j]>aList[j+1]:

                temp=aList[j+1]

                aList[j+1]=aList[j]

                aList[j] = temp

    return aList

start_time=time.time()

print bubble_sort(aList)[0:20]

end_time=time.time()

print end_time-start_time

# 给5万个数排序，282秒

3.2 选择排序

#!/usr/bin/env python

# -*- coding: utf-8 -*-

__author__ = 'WangQiaomei'

import random

import time

'''

aList=[]

for i in range(20):

    aList.append(random.randrange(100))

print aList

'''

aList=[]

for i in range(50000):

    aList.append(random.randrange(100000))

#print aList

def select_sort(aList):

    for i in range(len(aList)):

        for j in range(i,len(aList)):

            if aList[i]>aList[j]:

                temp = aList[i]

                aList[i]= aList[j]

                aList[j]= temp

    return aList

start_time=time.time()

print select_sort(aList)[0:20]

end_time=time.time()

print end_time-start_time

'''
第一层循环是循环整个列表
第二层是从i开始循环，到列表结尾。
如果找到比aList[i]小的元素，就和aList[i]交换。
和冒泡算法的时间和空间复杂度基本是一样的。区别是：
1）冒泡算法是两两交换，循环交换的结果把最大的数依次放在最后面。
2）选择排序是把当前的数和aList[i],循环结果就是把最小的数依次放在前面。
# 给5万个数排序，225秒
'''

3.3 直接插入排序

插入排序(Insertion Sort)的基本思想是：将列表分为2部分，左边为排序好的部分，右边为未排序的部分，循环整个列表，每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子序列中的适当位置，直到全部记录插入完成为止。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = 'WangQiaomei'

import random
import time

'''
aList=[]
for i in range(20):
    aList.append(random.randrange(100))
print aList
'''
'''
插入排序，是已经有一个已排序列表，索引是：0到i-1,靠向右移动一个位置，腾出一个空位来插入当前值。
详细：
由于插入排序是：通过从索引“0到i-1”已经排好序的列表中，由iCur（aList[i]）去从跟从i-1，一直旺座不停的比对，一直到<某个元素,
就插入到某个元素的前面。其实就是顺序查找插入，时间复杂度;O(n)。
注意：这里不可能改变列表的个数，当然更不能用insert语句了。
那怎么保持原列表不变，从已经排好序的列表里（0到i-1）,插入一个数呢？
就通过：
如果iCur的左边的紧靠的元素比它大,要把左边的元素一个一个的往右移一位,
直到iCur比aList[position-1]小,iCur插入到左边挪一个位置出来
也就是靠向右移动位置，给icur腾出一个空位，以便插入！
'''

aList=[]
for i in range(50000):
    aList.append(random.randrange(100000))

def insert_sort(aList):
    for i in range(1,len(aList)):   # 默认列表第一个已经排好序了
        iCur= aList[i]
        position=i
        while position>0 and iCur<aList[position-1]:
            aList[position]=aList[position-1]
            position-=1
        aList[position]=iCur
    return aList

start_time=time.time()
print insert_sort(aList)[0:20]
end_time=time.time()
print end_time-start_time

'''
# 给5万个数排序，149秒
'''

四、快速排序

设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动　　

注：在待排序的文件中，若存在多个关键字相同的记录，经过排序后这些具有相同关键字的记录之间的相对次序保持不变，该排序方法是稳定的；若具有相同关键字的记录之间的相对次序发生改变，则称这种排序方法是不稳定的。

要注意的是，排序算法的稳定性是针对所有输入实例而言的。即在所有可能的输入实例中，只要有一个实例使得算法不满足稳定性要求，则该排序算法就是不稳定的。

4.1 快速排序--清爽代码

#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = 'WangQiaomei'

def quick_sort(aList, left, right):
    if left >= right:
        return
    low = left
    high = right
    k = aList[left]
    while low < high:
        while high > 0 and low != high and aList[low] <= aList[high]:
            high -= 1
        temp = aList[low]
        aList[low] = aList[high]
        aList[high] = temp

while low != high and aList[high] > aList[low]:
            low += 1
        temp = aList[high]
        aList[high] = aList[low]
        aList[low] = temp
    quick_sort(aList, left, low - 1)
    quick_sort(aList, low + 1, right)

aList = [83, 83, 94, 51, 9, 79, 40, 68, 12, 17]

print aList
quick_sort(aList, 0, len(aList) - 1)
print aList

'''
打印结果：
[83, 83, 94, 51, 9, 79, 40, 68, 12, 17]
[9, 12, 17, 40, 51, 68, 79, 83, 83, 94]
'''

4.2 快速排序-错误示范讲解

#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = 'WangQiaomei'
import random
'''
aList=[6,2,5,11,3,8,9]
6,2,5,11,3,8,9  current_val=6 索引：low=0,high=6 初始值
此时算hight的：从后往前，跟6比大小，high的索引递减，这里递减了2次，注意：直到遇见比6小的，才交换位置。
3,2,5,11,6,8,9  current_val=6 索引：low=0,high=4
此时算low的：从前往后，跟6比大小，low的索引递增，这里递增了3次，注意：直到遇见比6大的，才交换位置。
3,2,5,6,11,8,9  current_val=6 索引：low=3,high=4
此时算hight的：从后往前，因为11比6大，high的索引-1=3,不交换位置。此时：low=high=6，
这是第一次排序，把比6小的发在6的左边，把比6大的放在6的右边。
3,2,5,6,11,8,9  current_val=6 索引：low=3,high=3

开始第二次排序，先排序6的左边：此时6的位置已经固定，不需要排它了！
注意：此时low和high的索引还是针对完整列表（第一次排序好的列表：
[3,2,5,6,11,8,9]）来说的。因为是给aList排序，不是给[3,2,5]排序！
3,2,5           current_val=3 索引：low=0,high=2  初始值
2,3,5           current_val=3 索引：low=0,high=1  从后向前，交换
2,3,5           current_val=3 索引：low=1,high=1  不交换

开始第三次排序，排6的右边：此时6的位置已经固定，不需要排它了！
注意：此时low和high的索引还是针对第二次排序好的列表：
[2,3,5,6,11,8,9]）来说的。
11,8,9          current_val=11 索引：low=4,high=6 初始值
9,8,11          current_val=11 索引：low=4,high=5 从后向前，交换
8,9,11          current_val=11 索引：low=5,high=5 从前向后，交换

第三次排序好的列表，就是最终结果，因为左边列表 和右边的列表，都分别得到了一个值。
最终结果：
[2,3,5,6,8,9,11]
'''

def quick_sort(aList, left,right):  # left 和right是为了递归用的。
    # if low==high and low>0:
    if left>=right:
        return
    low=left            # 这两句是为了递归用的
    high= right
    k = aList[left]     # 定的固定值，以它为标杆排序
    while low<high:
        # print 'aList[low]:',aList[low]
        # print 'aList[high]:',aList[high]
        # print 'low:',low
        # print 'high:',high
        print aList

# while high>0 and low!=high and aList[low]<=aList[high]: # 此时 aList[low]是关键字，递归low的值。这是对的
        '''
        注意:这里high是递减的，可能high会减成负数，会报错，所以high>0
        high是递减的，如果high减的跟low相等了，不应该再执行，结果再执行high-=1,则high<low，结果错误的交换了！

如下所示：
        [9, 12, 51, 17, 40, 68, 79, 83, 94, 83]
        low1: 5
        high1: 5
        low2: 5
        high2: 4
        [9, 12, 51, 17, 68, 40, 79, 83, 94, 83]

所以，这里应该写成：
        while high>0 and low!=high and aList[low]<=aList[high]:
        或者直接写成：
        while low<high and aList[low]<=aList[high]:
        '''
        # 有时候有多个相同的元素，所以要写成<=
        while high>0 and aList[low]<=aList[high]: # 此时 aList[low]是关键字，递归low的值。应该加上条件：and low!=high

# while high>0 and k<=aList[high]:    # 这样写也是对的,关键字就是k。这时候k就是aList[low]
            if low==high:
                print 'low1:',low
                print 'high1:',high
            high-=1
        print 'low2:',low
        print 'high2:',high
        temp=aList[low]         # 其实是low和high之间互换位置。
        aList[low]= aList[high]
        aList[high]=temp
        print aList
        #print 'sec_aList[low]:',aList[low]
        #print 'sec_aList[high]:',aList[high]
        # 因为low和high是互相变动的，有的时候low是关键字，有的时候high是关键字，有的时候low=high=关键字
        # 而每次while循环，都只针对一个固定值，小的放左边，大的放右边

'''
        这里也一样，如果low+=1的话，low和high相等的时候（本来不应该执行了），low再加1，则又做了错误的交换了。
        '''
        # while low!=high and aList[high]>aList[low]:   # 此时 aList[high]是关键字，递归low的值 是对的
        while aList[high]>aList[low]:   # 此时 aList[high]是关键字，递归low的值 ，应该加上条件：andand low!=high
        # while k>aList[low]: # 这样写也是对的，关键字就是k。这时候k就是aList[high]
            if low==high:
                print 'low3:',low
                print 'high3:',high
            low+=1
        temp=aList[high]
        aList[high]= aList[low]
        aList[low]=temp

#print 'result:',aList
    # if low==high and low>0:
    # quick_sort(aList, 0,low-1)
    #print 'left:',left
    #print 'low-1:',low-1
    # quick_sort(aList, 0,low-1)
    quick_sort(aList, left,low-1)
    # quick_sort(aList, low+1,len(aList)-1)
    quick_sort(aList, low+1,right)

#print aList

'''
aList=[]
for i in range(20):
    aList.append(random.randrange(100))
print aList

aList=[6,2,5,11,3,8,9]

aList=[]
for i in range(10):
    aList.append(random.randrange(100))
'''

aList=[83, 83, 94, 51, 9, 79, 40, 68, 12, 17]
# aList=[83, 83, 94, 51, 9, 79, 40]
print aList
quick_sort(aList, 0,len(aList)-1)
print aList

4.3 快速排序--正确

#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = 'WangQiaomei'
import random
'''
aList=[6,2,5,11,3,8,9]
6,2,5,11,3,8,9  current_val=6 索引：low=0,high=6 初始值
此时算hight的：从后往前，跟6比大小，high的索引递减，这里递减了2次，注意：直到遇见比6小的，才交换位置。
3,2,5,11,6,8,9  current_val=6 索引：low=0,high=4
此时算low的：从前往后，跟6比大小，low的索引递增，这里递增了3次，注意：直到遇见比6大的，才交换位置。
3,2,5,6,11,8,9  current_val=6 索引：low=3,high=4
此时算hight的：从后往前，因为11比6大，high的索引-1=3,不交换位置。此时：low=high=6，
这是第一次排序，把比6小的发在6的左边，把比6大的放在6的右边。
3,2,5,6,11,8,9  current_val=6 索引：low=3,high=3

开始第二次排序，先排序6的左边：此时6的位置已经固定，不需要排它了！
注意：此时low和high的索引还是针对完整列表（第一次排序好的列表：
[3,2,5,6,11,8,9]）来说的。因为是给aList排序，不是给[3,2,5]排序！
3,2,5           current_val=3 索引：low=0,high=2  初始值
2,3,5           current_val=3 索引：low=0,high=1  从后向前，交换
2,3,5           current_val=3 索引：low=1,high=1  不交换

开始第三次排序，排6的右边：此时6的位置已经固定，不需要排它了！
注意：此时low和high的索引还是针对第二次排序好的列表：
[2,3,5,6,11,8,9]）来说的。
11,8,9          current_val=11 索引：low=4,high=6 初始值
9,8,11          current_val=11 索引：low=4,high=5 从后向前，交换
8,9,11          current_val=11 索引：low=5,high=5 从前向后，交换

第三次排序好的列表，就是最终结果，因为左边列表 和右边的列表，都分别得到了一个值。
最终结果：
[2,3,5,6,8,9,11]
'''

def quick_sort(aList, left,right):  # left 和right是为了递归用的。
    # if low==high and low>0:
    if left>=right:
        return
    low=left            # 这两句是为了递归用的
    high= right
    k = aList[left]     # 定的固定值，以它为标杆排序
    while low<high:
        # print 'aList[low]:',aList[low]
        # print 'aList[high]:',aList[high]
        # print 'low:',low
        # print 'high:',high
        print aList

# while high>0 low!=high and aList[low]<=aList[high]: # 此时 aList[low]是关键字，递归low的值。这是对的
        '''
        注意:这里high是递减的，可能high会减成负数，会报错，所以high>0
        high是递减的，如果high减的跟low相等了，不应该再执行，结果再执行high-=1,则high<low，结果错误的交换了！

如下所示：
        [9, 12, 51, 17, 40, 68, 79, 83, 94, 83]
        low1: 5
        high1: 5
        low2: 5
        high2: 4
        [9, 12, 51, 17, 68, 40, 79, 83, 94, 83]

所以，这里应该写成：
        while high>0 and low!=high and aList[low]<=aList[high]:
        或者直接写成：
        while low<high and aList[low]<=aList[high]:
        '''
        # 有时候有多个相同的元素，所以要写成<=
        while high>0 and low!=high and aList[low]<=aList[high]:
        # while high>0 and aList[low]<=aList[high]: # 此时 aList[low]是关键字，递归low的值。应该加上条件：and low!=high

# while high>0 and k<=aList[high]:    # 这样写也是对的,关键字就是k。这时候k就是aList[low]
            '''
            if low==high:
                print 'low1:',low
                print 'high1:',high
            '''
            high-=1
        print 'low2:',low
        print 'high2:',high
        temp=aList[low]         # 其实是low和high之间互换位置。
        aList[low]= aList[high]
        aList[high]=temp
        print aList
        #print 'sec_aList[low]:',aList[low]
        #print 'sec_aList[high]:',aList[high]
        # 因为low和high是互相变动的，有的时候low是关键字，有的时候high是关键字，有的时候low=high=关键字
        # 而每次while循环，都只针对一个固定值，小的放左边，大的放右边

'''
        这里也一样，如果low+=1的话，low和high相等的时候（本来不应该执行了），low再加1，则又做了错误的交换了。
        '''
        while low!=high and aList[high]>aList[low]:   # 此时 aList[high]是关键字，递归low的值 是对的

#while aList[high]>aList[low]:   # 此时 aList[high]是关键字，递归low的值 ，应该加上条件：andand low!=high
        # while k>aList[low]: # 这样写也是对的，关键字就是k。这时候k就是aList[high]
            '''
            if low==high:
                print 'low3:',low
                print 'high3:',high
            '''
            low+=1
        temp=aList[high]
        aList[high]= aList[low]
        aList[low]=temp

#print 'result:',aList
    # if low==high and low>0:
    # quick_sort(aList, 0,low-1)
    #print 'left:',left
    #print 'low-1:',low-1
    # quick_sort(aList, 0,low-1)
    quick_sort(aList, left,low-1)
    # quick_sort(aList, low+1,len(aList)-1)
    quick_sort(aList, low+1,right)

#print aList

'''
aList=[]
for i in range(20):
    aList.append(random.randrange(100))
print aList

aList=[6,2,5,11,3,8,9]

aList=[]
for i in range(10):
    aList.append(random.randrange(100))
'''

aList=[83, 83, 94, 51, 9, 79, 40, 68, 12, 17]
# aList=[83, 83, 94, 51, 9, 79, 40]
print aList
quick_sort(aList, 0,len(aList)-1)
print aList

01背包问题

def fastMaxVal(w, v, i, aW, m):

    global numCalls

    numCalls += 1

    # print 'maxVal called with:',i,aW

    try:

        return m[(i, aW)]

    except KeyError:

        if i == 0:

            if w[i] <= aW:

                m[(i, aW)] = v[i]

                return v[i]

            else:

                m[(i, aW)] = 0

                return 0

        without_i = fastMaxVal(w, v, i - 1, aW, m)

        if w[i] > aW:

            m[(i, aW)] = without_i

            return without_i

        else:

            with_i = v[i] + fastMaxVal(w, v, i - 1, aW - w[i], m)

        res = max(with_i, without_i)

        m[(i, aW)] = res

        return res

def maxVal0(w, v, i, aW):

    m = {}

    return fastMaxVal(w, v, i, aW, m)

weights = [5, 3, 2]

vals = [9, 7, 8]

numCalls = 0

res = maxVal0(weights, vals, len(vals) - 1, 5)

print 'max Val=', res, 'number of calls = ', numCalls

装饰器：

def auth(func):

    def inner(*args,**kwargs):

        # key = kwargs['token']

        # del kwargs['token']

        key = kwargs.pop('token')

        is_login = login(key)

        if not is_login:

            return '非法用户'

        temp = func(*args,**kwargs)

        print 'after'

        return temp

    return inner

三层装饰器：

s11d27 算法的更多相关文章

  1. B树——算法导论(25)

    B树 1. 简介 在之前我们学习了红黑树,今天再学习一种树--B树.它与红黑树有许多类似的地方,比如都是平衡搜索树,但它们在功能和结构上却有较大的差别. 从功能上看,B树是为磁盘或其他存储设备设计的, ...

  2. 分布式系列文章——Paxos算法原理与推导

    Paxos算法在分布式领域具有非常重要的地位.但是Paxos算法有两个比较明显的缺点:1.难以理解 2.工程实现更难. 网上有很多讲解Paxos算法的文章,但是质量参差不齐.看了很多关于Paxos的资 ...

  3. 【Machine Learning】KNN算法虹膜图片识别

    K-近邻算法虹膜图片识别实战 作者:白宁超 2017年1月3日18:26:33 摘要:随着机器学习和深度学习的热潮,各种图书层出不穷.然而多数是基础理论知识介绍,缺乏实现的深入理解.本系列文章是作者结 ...

  4. 红黑树——算法导论(15)

    1. 什么是红黑树 (1) 简介     上一篇我们介绍了基本动态集合操作时间复杂度均为O(h)的二叉搜索树.但遗憾的是,只有当二叉搜索树高度较低时,这些集合操作才会较快:即当树的高度较高(甚至一种极 ...

  5. 散列表(hash table)——算法导论(13)

    1. 引言 许多应用都需要动态集合结构,它至少需要支持Insert,search和delete字典操作.散列表(hash table)是实现字典操作的一种有效的数据结构. 2. 直接寻址表 在介绍散列 ...

  6. 虚拟dom与diff算法 分析

    好文集合: 深入浅出React(四):虚拟DOM Diff算法解析 全面理解虚拟DOM,实现虚拟DOM

  7. 简单有效的kmp算法

    以前看过kmp算法,当时接触后总感觉好深奥啊,抱着数据结构的数啃了一中午,最终才大致看懂,后来提起kmp也只剩下“奥,它是做模式匹配的”这点干货.最近有空,翻出来算法导论看看,原来就是这么简单(先不说 ...

  8. 神经网络、logistic回归等分类算法简单实现

    最近在github上看到一个很有趣的项目,通过文本训练可以让计算机写出特定风格的文章,有人就专门写了一个小项目生成汪峰风格的歌词.看完后有一些自己的小想法,也想做一个玩儿一玩儿.用到的原理是深度学习里 ...

  9. 46张PPT讲述JVM体系结构、GC算法和调优

    本PPT从JVM体系结构概述.GC算法.Hotspot内存管理.Hotspot垃圾回收器.调优和监控工具六大方面进行讲述.(内嵌iframe,建议使用电脑浏览) 好东西当然要分享,PPT已上传可供下载 ...

随机推荐

  1. ! [rejected] master -> master (non-fast-forward)

    当向GitHub远程仓库提交请求时,常会出现  ! [rejected]  master -> master (non-fast-forward) 错误. 出现这种错误通常是由于远程仓库的文件版 ...

  2. S11 day 93 RestFramework 之 序列化

    1. 表建模 from django.db import models # Create your models here. #文章表 class Article(models.Model): tit ...

  3. python web开发——c3 数据库交互和flask-SQLALchemy

    ORM(对象关系映射) 定义:将数据库中表与表之间的关系和代码中类(class)与类之间的关系联系起来,这就是ORM

  4. JQuery Mobile - 为什么绑定事件后会被多次执行？

    JQuery Mobile 在绑定事件时候,发现会被多次执行,为什么啊? 原来,jquery click  不是替换原有的function ,而是接着添加,所以才会执行次数越来越多,怎么办才能按需实现 ...

  5. [bug] JS sort 函数在 ios 中无效

    首先,请原谅我做一次标题党: 但我觉得从发现问题到最后解决问题的过程还是蛮有意思的,特此记录一下: 背景 近两天开发的航班延误宝是内嵌在客户端(android.ios)webview 中的 H5 页面 ...

  6. 《JAVA与模式》之合成模式

    在阎宏博士的<JAVA与模式>一书中开头是这样描述合成(Composite)模式的: 合成模式属于对象的结构模式,有时又叫做“部分——整体”模式.合成模式将对象组织到树结构中,可以用来描述 ...

  7. 可方便扩展的JIRA Rest Web API的封装调用

    JIRA是一个缺陷跟踪管理系统,被广泛应用于缺陷跟踪.客户服务.需求收集.流程审批.任务跟踪.项目跟踪和敏捷管理等工作领域,当我们需要把第三方业务系统集成进来时,可以调用他的API. JIRA本身的A ...

  8. 【GDKOI2017】小队任务 莫比乌斯反演+杜教筛

    题目大意:给你n,求$\sum_{i=1}^{n}\sum_{j=i}^{n}[gcd(i,j)=1](i+1)(j+1)$ 子任务一:暴力 子任务二:$T=50000,n≤10^7$ 子任务三:$T ...

  9. Swift的Guard语句

    与if语句相同的是,guard也是基于一个表达式的布尔值去判断一段代码是否该被执行.与if语句不同的是,guard只有在条件不满足的时候才会执行这段代码.你可以把guard近似的看做是Assert,但 ...

  10. Vue-Router路由Vue-CLI脚手架和模块化开发 之 使用props替代路由对象的方式获取参数

    在上一章博文中使用路由对象$route获取参数时,组件和路由对象耦合,在这篇博文中就可以使用props来进行解耦: 1.在组件中使用props选项定义数据,接收参数: 2.在路由中,使用props选项 ...