数据结构 python 语言描述

（一）数据结构综述

• 经常使用的数据结构：数组（顺序表）、链表、字典（哈希表）、搜索树
• 图这种数据结构，通常用不到
• 概念很无聊，直接上代码
• 书：数据结构高分笔记，王道

 

（二）链表

 

 

 1 class Node(object):
 2     def __init__(self,element=None):
 3         self.element = element
 4         self.next = None
 5 
 6 # 这种建立链表的方法是很是野鸡的，这里主要是为了演示
 7 head = Node()
 8 n1 = Node(111)
 9 n2 = Node(222)
10 n3 = Node(333)
11 head.next = n1
12 n1.next = n2
13 n2.next = n3
14 
15 def log_link_list(head):
16     """
17     打印链表中全部的元素
18     """
19     n = head.next
20     while n.next is not None:
21         print(n.element)
22         n = n.next
23     print(n.element)
24     
25     
26 def append(head,element):
27     """
28     在链表的末尾添加元素
29     """
30     n = head
31     while n.next is not None:
32         n = n.next
33     node = Node()
34     n.next = node
35     node.element = element
36     
37     
38 def preappend(head,element):
39     """
40     链表的头插法
41     """
42     node = Node(element)
43     node.next = head.next
44     head.next = node
45     
46     
47 def pop(head):
48     tail = head
49     while tail.next is not None:
50         tail = tail.next
51     # 拿到最后一个元素的 pointer 了
52     n = head
53     while n.next is not tail:
54         n = n.next
55     n.next = None
56     return tail.element
57     
58 preappend(head,999)   
59 append(head,666)
60 log_link_list(head)
61 
62 pop(head)
63 log_link_list(head)

 

 

(三) 二叉树

 

 

class Tree(object):
    def __init__(self,element=None):
        self.element = element
        self.left = None
        self.right = None
        
    def traversal(self):
        """
        二叉树的前序,中序，后续遍历
        改变 print 的位置就能够
        """
       
        if self.left is not None:
            self.left.traversal()
        if self.right is not None:
            self.right.traversal()
        print(self.element)
            
    def reverse(self):
        """
        交换左右子树
        """
        self.left, self.right = self.right, self.left
        if self.left is not None:
            self.left.reverse()
        if self.right is not None:
            self.right.reverse()

def test():
    # 手动构建二叉树，这种方法很是野鸡。就只有在学习的时候用
    # 在实际的应用中，通常都是自动生成的
    
    t = Tree(0)
    left = Tree(1)
    right = Tree(2)
    t.left = left
    t.right = right
    
    t.traversal()
    
if __name__ == '__main__':
    test()

 

 

 

(四)字典，又叫哈希表，Map等

1. 这个方法很直接，咱们先把一个字符串映射成一个整数

　　　　如： ‘dog’ ------>   'd'*1 + 'o'*10 + 'g'*100

　　2. data = [key, value] 咱们插入的数据是一个个列表，采用连接地址法

 

 

class HashTable(object):
    def __init__(self):
        self.table_size = 10007
        self.table = [0] * self.table_size

    # 这个魔法方法是用来实现 in  not in 语法的
    def __contains__(self, item):
        return self.has_key(item)
        
    def has_key(self, key):
        """
        检查一个 key 是否存在, 时间很短, 是 O(1)
        若是用 list 来存储, 须要遍历, 时间是 O(n)
        """
        index = self._index(key)
        # 取元素
        v = self.table[index]
        if isinstance(v, list):
            # 检查是否包含咱们要找的 key
            for kv in v:
                if kv[0] == key:
                    return True
        return False

    def _insert_at_index(self, index, key, value):
        # 检查下标处是不是第一次插入数据
        v = self.table[index]
        data = [key, value]
        if isinstance(v, int):
            self.table[index] = [data]
        else:
            # 若是不是, 获得的会是 list, 直接 append
            self.table[index].append([data])

    def add(self, key, value):
        """
        add 函数往 hashtable 中加入一对元素
        咱们先只支持字符串当 key
        """
        # 先计算出下标
        index = self._index(key)
        # 在下标处插入元素
        self._insert_at_index(index, key, value)

    def get(self, key, default_value=None):
        """
        这个和 dict 的 get 函数同样
        """
        index = self._index(key)
        # 取元素
        v = self.table[index]
        if isinstance(v, list):
            # 检查是否包含咱们要找的 key
            for kv in v:
                if kv[0] == key:
                    return kv[1]
        return default_value

    def _index(self, key):
        # 先计算出下标
        return self._hash(key) % self.table_size

    def _hash(self, s):
        n = 1
        f = 1
        for i in s:
            n += ord(i) * f
            f *= 10
        return n


def test():
    import uuid
    names = [
        'web',
        'python',
    ]
    ht = HashTable()
    for key in names:
        value = uuid.uuid4()
        ht.add(key, value)
        print('add 元素', key, value)
    for key in names:
        v = ht.get(key)
        print('get 元素', key, v)


if __name__ == '__main__':
    test()