python数据结构

数据结构

列表 又称 顺序表
32 位 机器上 , 一个整形占4 个 字节 一个地址 占 4 个 字节
数组与列表的两点不同:
1. 数组元素类型相同
2. 数组的长度固定

python 中的列表

python 中的列表其实存储的是元素的内存地址，因此列表中可以存储不同的数据元素 
python 列表中删除和插入的时间复杂度 都是 O(n) ;

python 链表

链表是一系列节点组成的元素集合。每个节点包含两部分。数据域item和指向下一个节点的指针next。 通过节点之间的相互连接，最终串成链表

class Node:
	def __init__(self, item):
		self.item = item
		self.next = None
a = Node(1)
b = Node(2)
c = Node(3)
# 通过next 把各个节点连接起来 
a.next = b
b.next = c
print(a.next.next.item) 

创建链表

头插法

class Node:
	def __init__(self, item):
		self.item = item
		self.next = None
##  通过列表进行插入 
def create_linklist_head(li):
	head = Node(li[0])
	for element in li[1:]:
		node = Node(element)
		node.next = head
		head = node 
	return head
def print_linklist(lk):
	while lk:
		print(lk.item, end=',')
		lk = lk.next
		
lk = create_linklist([1,2,3])
print(lk.item)

尾插法

class Node:
	def __init__(self, item):
		self.item = item
		self.next = None
class create_linklist_tail(li):
	  head = Node(li[0])
	  tail = head 
	  for element in li[1:]:
	  		node = Node(element)
	  		tail.next = node 
	  		tail = node 
	  return head 

链表的插入

链表的删除

python 双向链表

双链表的每个节点有两个指针: 一个指向后一个节点, 另一个指向前一个节点

class Node:
	def __init__(self,item =Node):
		self.item = item
		self.next = None 
		self.prior = None 

总结

哈希表

	哈希表一个通过哈希函数来计算数据存储位置的数据结构，通常支持如下操作:
	保证 Insert  get  del  是高效的。
	直接寻址表 
	当关键字的全域U 比 较小时，直接寻址是一种简单而有效的方法 。
	哈希表 是由一个直接寻址表和一个哈希函数组成。 哈希函数h(k)  将元素关键字k 作为自变量，返回元素的存储下标。

解决哈希冲突-- 开放寻址法

开放寻址法： 如果哈希函数返回的位置已经有值，则可以向后探查新的位置来存储这个值。
线性探查：如果位置i 被 占用 ，则探查i + 1 ， i + 2
二次探查: 如果位置i 被占用 ，则探查i + 2 , i - 1
二度哈希: 有n 个 哈希函数，当使用第一个哈希函数h1 发生冲突，则尝试使用h2, h3

解决哈希冲突-- 拉链法

拉链法: 哈希表每个位置都连接一个链表 ，当冲突发生时，冲突的元素将被加到该位置链表的最后。

class LinkList:
    class Node:
        def __init__(self, item=None):
            self.item = item
            self.next = None

    class LinkListIterator:
        def __init__(self, node):
            self.node = node

        def __next__(self):
            if self.node:
                cur_node = self.node
                self.node = cur_node.next
                return cur_node.item
            else:
                raise StopIteration

        def __iter__(self):
            return self

    def __init__(self, iterable=None):
        self.head = None
        self.tail = None
        if iterable:
            self.extend(iterable)

    def append(self, obj):
        s = LinkList.Node(obj)
        if not self.head:
            self.head = s
            self.tail = s
        else:
            self.tail.next = s
            self.tail = s

    def extend(self, iterable):
        for obj in iterable:
            self.append(obj)

    def find(self, obj):
        for n in self:
            if n == obj:
                return True
        else:
            return False

    def __iter__(self):
        return self.LinkListIterator(self.head)

    def __repr__(self):
        return "<<" + ",".join(map(str, self)) + ">>"

#  类似于集合的结构 哈希表 
class HashTable:
    def __init__(self, size=101):
        self.size = size
        self.T = [LinkList() for i in range(self.size)]

    def h(self, k):
        return k % self.size

    def insert(self, k):
        i = self.h(k)
        if self.find(k):
            print("Duplicated Insert")
        else:
            self.T[i].append(k)

    def find(self, k):
        i = self.h(k)
        return self.T[i].find(k)