数据结构---python---表

一、list的基本实现技术

在数据结构中，如果用python实现线性表，无疑要提到list，list是一种元素个数可变的线性表(而tuple是不变的表，不支持改变其内部状态的任何操作，其他与list性质类似)，采用分离式技术实现的动态顺序表，表中元素保存在一块连续存储区内。实现约束有如下两点：

1、基于下标(位置)的高效元素访问和更新，时间复杂度是O(1)

2、允许任意添加元素，不可以出现由于表满而无法加入新元素的情况；而且在添加新元素之后，表对象标识不变。

在python的官方实现中，list的实现策略如下：

1、在建立空表(或很小的表)时，系统分配一块能容纳8个元素的存储区；
2、在执行insert或append等操作来扩充表时，如果元素区满就换一块4倍大的存储区，把所有元素copy过去；
3、如果当前的表已经“很大”(这里阈值为50000)，系统将改变策略，换存储区时容量加倍，这是为了避免出现过多的空闲存储位置。

注：python没有提供检查一个list对象的当前存储块容量的操作，也没有设置容量的操作，一切与容量有关的处理都由Python解释器自动完成，这和c++、java等有很大的区别。优点是降低了编程的负担，避免人为操作可能引进的错误。但全部交给解释器来完成也限制了表的使用方式。

小练习：list的内置方法reverse，自己实现的方法：

 def my_reverse(lst):
     elems = lst
     i,j = 0, len(elems)-1
     while i <j:
         elems[i], elems[j] = elems[j], elems[i]  #这里交换元素写在一行，不需要设置中间的temp作为交换媒介
         i,j = i+1, j-1
     return elems
 a = [1,2,3,4,5,"a"]
 print a
 print '\nafter my reverse',my_reverse(a)

二、单链表类的实现

单链表的基础知识就不往上贴了，下面贴个python实现的实现类

1、利用循环创建一个简单的单链表

 # -*- coding:utf-8 -*-
 '''
 简单的循环调用一个长度为10的单链表
 '''
 class LNode:  #实现单链表的节点类
     def __init__(self,elem, next_=None):
         self.elem = elem
         self.next = next_  #以next_命名，避免与标准函数next重名，这是python的命名习惯

 llist1 = LNode(1)
 p = llist1

 for i in range(2,11):
     p.next = LNode(i)
     p = p.next

 p = llist1  #把链表的指针重新指向第一个节点
 while p:
     print p.elem
     p = p.next

2、单链表类的实现

 # -*- coding:utf-8 -*-
 __author__ = 'webber'
 '''单链表类的实现'''

 class LNode:  #实现单链表的节点类
     def __init__(self,elem, next_=None):
         self.elem = elem
         self.next = next_  #以next_命名，避免与标准函数next重名，这是python的命名习惯

 class LinkedListUnderflow(ValueError):  #继承标准异常的子类ValueError
     pass

 class LList:
     def __init__(self):
         self._head = None

     def is_empty(self):
         return self._head is None

     def prepend(self,elem):
         self._head = LNode(elem,self._head)

     def pop(self):
         if self._head is None: #无结点，引发异常
             raise LinkedListUnderflow("in pop")
         ele = self._head.elem
         self._head = self._head.next
         return ele

     def pop_last(self):    #这里有两个特殊情况，表为空，或者表中只有一个元素，pop掉最后一个元素的时间复杂度为O(n)
         if self._head is None: #空表，无结点，引发异常
             raise LinkedListUnderflow("in pop_last")
         p = self._head
         if p.next is None:  #表中只有一个元素
             ele = p.elem
             self._head = None
             return ele
         while p.next.next is not None:  #直到p.next是最后的结点
             p = p.next
         ele = p.next.elem
         p.next = None
         return ele

     def append(self, elem):
         if self._head is None:
             self._head = LNode(elem)
             return
         p = self._head
         while p.next:
             p = p.next
         p.next = LNode(elem)

     def printall(self):
         p = self._head
         while p:
             print p.elem,
             if p.next:
                 print ",",
             p = p.next
         print ""

 mlist1 = LList()
 print mlist1.is_empty()
 for i in range(10):
     mlist1.prepend(i)
 for i in range(11,20):
     mlist1.append(i)
 mlist1.printall()
 print mlist1.is_empty()
 for i in range(5):
     mlist1.pop()
 print "pop 5 个数据之后："
 mlist1.printall()

3、表的遍历

python语言为内部汇集类型提供的遍历机制是迭代器，标准使用方式是放在for语句头部，在循环体中逐个处理汇集对象的元素，用yield实现。可在上面的单链表类中添加如下方法：

  def elements(self):
         p = self._head
         while p is not None:
             yield p.elem    #返回结点元素
             p = p.next

  for i in mlist1.elements():
     print i,

筛选生成器：下面是一个筛选生成器的方法，可以将单链表中所有符合条件的结点元素返回，这里需要注意两点：一是关于yield和return的用法区别，yield使这个方法变成一个迭代器，每一次循环迭代器使用next方法返回一个值，而return如果执行的话，整个函数就结束了。二是这里在调用该方法时需要一个“判断谓词参数”，在python中可以使用lambda表达式定制这个操作参数，方法和调用如下：

  def filter(self,pred):      #筛选生成器
         p = self._head
         while p:
             if pred(p.elem):
                 yield p.elem
             p = p.next

 for i in mlist1.filter(lambda i:i>10):    #谓词参数，返回单链表中元素大于10的元素
     print i,