python - 穷举所有的数据结构，以及对应的一些实现。还是要多用，熟能生巧 = 技巧多样 + 操作稳定。

问题：

想系统的学习python编程。高手的两个标准：1-技巧性比较多样；2-操作性比较稳定。

首先想到的是编程都包括些什么。程序 = 数据结构 + 算法。

列举出所有的数据结构，学习时能够把握在什么位置。

列举出所有的算法，学习时可以触类旁通。

理论结合python语言，让其稳稳地落地。

解决方案：

多学多练。

觉得理论单一时，补全理论，使其完整多样。

觉得操作不稳时，多记多背，使其稳定自然。

讨论：

1-构建理论体系，需循序渐进，不断迭代。

2-操作就像是一个工种，熟练就好。

# coding:utf-8
'''
程序的三个基本结构：
1-顺序执行
2-循环结构
3-分支和跳转结构
基本的四个数据结构：
1-数组 - 遍历查找，list()
2-链表 - 单向、单向循环、双向，需要自定义class作为结构体。
链表解决hash表冲突(拉链法解决冲突的做法是：
将所有关键字为同义词的结点链接在同一个单链表中。
若选定的散列表长度为m，则可将散列表定义为一个由m个头指针组成的指针数 组T[0..m-1]。
凡是散列地址为i的结点，均插入到以T[i]为头指针的单链表中。
T中各分量的初值均应为空指针。在拉链法中，装填因子α可以大于 1，但一般均取α≤1。)
3-栈 - stack，后进先出
4-队列 - queue，先进先出
复杂的四个数据结构：
1-树（堆） - heap，根结点的值最大或者是最小。用python实现树的遍历，需构造class。
2-集合 - set,像列表、字典、字符串这类可迭代的对像都可以做为集合的参数。set集合是无序的，不能通过索引和切片来做一些操作。
3-哈希表和映射 - 计算hash值查找，类似dict()，需构造class,(例：哈希表长为14，哈希函数是H(key)=key%11，有冲突找链表)
哈希表，又称为散列表，
是一种比搜索树（search trees）或者任何其他的表查找结构（table lookup structure）更有效数据结构，
一般应用于关联数组、数据库索引、高速缓存和集合等方面.
4-图 - 需构造一个函数来实现
常用的四种算法：
1-贪婪法：0-1背包问题
2-分治法：大整数乘法
3-动态规划法：字符串的编辑距离
4-穷举法：wwwdot - google = dotcom
算法具体应用：
1-9X9数独问题

结构体：
Python中没有专门定义结构体的方法，但可以使用class标记定义类来代替结构体，
其成员可以在构造函数__init__中定义。
class Node(object):
    def __init__(self,val,n=0,p=0):
        self.data = val
        self.next = n
        self.pre = p
Node(1)

随机数：
在python 中的random库中，经常会用到如randint之类的方法来生成一定范围内的随机数.
这之中主要用到的方法步骤为->指定一个特定的seed种子，
根据seed再通过特定的随机数产生方法，就可以做到在[0，1]这个范围中取到随机分布的随机数，
然后一定的变换，我们就可以得到一定范围内的随机数了.
1-自然界的为真随机数，计算机的为伪随机数。
2-伪随机数需要seed。输入：长度为N的seed。输出：长度为N的伪随机数任意多个。
3-伪随机数分为平均分布和正态分布两种；
4-平方取中法：randnum = int(seed**2/pow(10,(N/2))) % int(pow(10.0,N))
5-系数A增数C模数M：randnum = (A * seed + C) % M（A = 1103515245 / C = 12345 / M = 2**32）

概率论：
随机变量的所有取值组成一个样本空间。
事件为样本空间的子集。
概率 = 事件 / 样本空间。


洗牌：
import random
items = [1, 2, 3, 4, 5, 6]
random.shuffle(items)
print items
[3, 2, 5, 6, 4, 1]

张天飞 / 陈莉君 - 西安邮电大学

给出两个链表 3->1->5->null 和 5->9->2->null，返回 8->0->8->null

'''
import os
import random
from fractions import Fraction # 分数
from collections import deque  # 队列
import heapq # 堆

def probality(event, space):
    print Fraction(len(event & space), len(space))

class Node(object): # 结构体
    def __init__(self,val,p=0):
        self.data = val
        self.next = p


def josphus(n, k):
    '''约瑟夫环问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，
    数到k的那个人被杀掉；他的下一个人又从1开始报数，数到k的那个人又被杀掉；
    依此规律重复下去，直到圆桌周围的人只剩最后一个。
    可以采用循环链表的方式
    '''
    if k == 1:
        print 'survive: %d' % n
        return n
    people = list(range(1,n+1))
    p = 0
    while(1<len(people)):
        p = (p + k - 1) % len(people)
        print 'kill: %d' % people[p]
        del people[p]
    print 'survive: ', people[0]

def stackorqueue():
    # list0 = [0]*10
    list0 = list(range(1,10))
    print list0
    while list0:
        # list0.pop(0) # 先进先出queue
        # print list0
        list0.pop() # 先进后出stack
        print list0

    queue = deque([1,2,3,4,5,6])
    queue.append(7)
    queue.popleft()
    print queue


if __name__ == '__main__':
    # print eval('123') + eval('45') # 168
    # # event = {1,3,5}
    # event = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21}
    # space = {1,2,3,4,5,6}
    # probality(event, space) # 集合set
    # 1 - 数组
    # 2 - 链表
    # 3 - 栈
    # 4 - 队列
    # 结构体
    # 二位数组
    # print Node(1).data, Node(2).next
    # josphus(10,4)
    # stackorqueue()
    #heapq
    # list0 = [4,5,6,7,1,8,2,9,3]
    # # for i in range(1,10):
    # #     list0.append(random.randrange(1,10))
    # print list0
    # heapq.heapify(list0)
    # print list0
    # heapq.heappush(list0, 'a')
    # print list0
    # print heapq.heappop(list0)
    a = set('abc')
    list0 = [4, 5, 6, 7, 1, 8, 2, 9, 3]
    dict0 = {'a':'1', 'b':'2'}
    print dict0.get('a')
    print dict0.has_key('c')
    dict0.pop('a')
    print dict0