暑期学习记录08

python

1. 栈
2. 队列
3. 树

4. 链表

   1.栈
   栈相当于一端开口，一端封闭的容器。支持出栈和进栈两种操作。
   后进先出特性。
   stack通常的操作：
   Stack() 建立一个空的栈对象
   push() 把一个元素添加到栈的最顶层
   pop() 删除栈最顶层的元素，并返回这个元素
   peek() 返回最顶层的元素，并不删除它
   isEmpty() 判断栈是否为空
   size() 返回栈中元素的个数

   演示过程如下：
   
   
   

如果希望把数据A出栈，则首先需要将数据B出栈。

利用python列表实现栈的数据结构

# -*- coding: cp936 -*-class Stack:    """模拟栈"""    def __init__(self):         self.items =[]  #定义一个列表items用于实现栈的容器    def isEmpty(self):         return len(self.items)==0      def push(self,item):#执行item进栈操作        self.items.append(item)    def pop(self):        return self.items.pop()    def peek(self):#返回栈顶元素，但不删除            if not self.isEmpty():                return self.items[len(self.items)-1]    def size(self):#返回栈的大小            return len(self.items)s=Stack() print(s.isEmpty()) s.push('DataA') s.push('DataB') print(s.peek()) s.push('DataC') print(s.size()) print(s.isEmpty()) s.push('DataD') print(s.pop()) print(s.pop()) print(s.size()) >>>TrueDataB3FalseDataDDataC2

2.队列
队列相当于两边都开口的容器，但是一边只能进行删除操作，一边只能进行插入操作，进行插入操作的一端叫做队尾，进行删除操作的叫队首。
有入队和出队两种操作。
遵循先进先出原则

利用python实现队列

# -*- coding: cp936 -*-class Queue(object):    def __init__(self):        self.queue=[]    def isempty(self):        return self.queue==[]    def enqueue(self,item):        self.queue.append(item)    def dequeue(self):#程序调用列表的pop函数返回并删除第一个元素        if self.queue!=[]:            return self.queue.pop(0)        else:            return None    def head(self):#返回队首元素        if self.queue!=[]:            return self.queue[0]        else:            return None    def tail(self):        if self.queue!=[]:            return self.queue[-1]        else :            return None    def length(self):        return len(self.queue)q=Queue()print q.isempty()q.enqueue('DataA')q.enqueue('DataB')print q.head()print q.tail()q.enqueue('DataC')print q.length()print q.isempty()q.enqueue('DataD')print q.dequeue()print q.dequeue()print q.length()>>>TrueDataADataB3FalseDataADataB2       

最后三步：

具体过程点击此处粘贴代码查看

3.树（非线性数据结构）
遍历二叉树：
先序遍历 根节点-左子树-右子树
中序遍历 左-根-右
后序遍历 左-右-根
python中实现树的数据结构

# -*- coding: cp936 -*-class Node(object):    def __init__(self,data=-1,lchild=None,rchild=None):#定义树节点类Non        self.data=data#树节点存储的数据        self.lchild=lchild#左子树        self.rchild=rchild#右子树class BinaryTree(object):    def __init__(self):        self.root=Node()#root是Node对象，表示二叉树的根节点    def add(self,data):#data为新节点的数据        node=Node(data)        if self.isEmpty():#如果二叉树为空，则将新节点作为二叉树的根节点            self.root=node        else:            tree_node=self.root            queue=[]#以列表存储二叉树            queue.append(self.root)            while queue:#遍历二叉树                tree_node=queue.pop(0)                if tree_node.lchild==None:                    tree_node.lchild=node                    return                elif tree_node.rchild==None:                    tree_node.rchild=node                    return                else:                    queue.append(tree_node.lchild)                    queue.append(tree_node.rchild)    def pre_order(self,start):#先序遍历        node=start        if node==None:            return        print node.data,        if node.lchild==None and node.rchild==None:            return        self.pre_order(node.lchild)        self.pre_order(node.rchild)    def in_order(self,start):#先序遍历        node=start        if node==None:            return        self.pre_order(node.lchild)        print node.data,        self.pre_order(node.rchild)    def post_order(self,start):#先序遍历        node=start        if node==None:            return        self.pre_order(node.lchild)        self.pre_order(node.rchild)        print node.data,    def isEmpty(self):        return True if self.root.data== -1 else False    def length(self):        return len(self.queue)if __name__ == '__main__':    arr=[]    for i in range(10):        arr.append(i)    print arr    tree=BinaryTree()    for i in arr:        tree.add(i)    print 'pre order:'    tree.pre_order(tree.root)    print '\nin order:'    tree.in_order(tree.root)    print '\npostorder:'    tree.post_order(tree.root)>>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]pre order:0 1 3 7 8 4 9 2 5 6 in order:1 3 7 8 4 9 0 2 5 6 postorder:1 3 7 8 4 9 2 5 6 0

关于遍历其他参考

4.链表
用python实现单向链表

# -*- coding: cp936 -*-class Node():  __slots__=['_item','_next']   #限定Node实例的属性  def __init__(self,item):    self._item=item   #存储数据    self._next=None   #Node的指针部分默认指向None  def getItem(self):    return self._item  def getNext(self):    return self._next  def setItem(self,newitem):    self._item=newitem  def setNext(self,newnext):    self._next=newnextclass SingleLinkedList():   def __init__(self):    self._head=None #初始化为空链表  def isEmpty(self):    return self._head==None  def size(self):    current=self._head    count=0    while current!=None:      count+=1      current=current.getNext()    return count  def travel(self):    current=self._head    while current!=None:      print current.getItem()      current=current.getNext()  def add(self,item):    temp=Node(item)    temp.setNext(self._head)    self._head=temp  def append(self,item):    temp=Node(item)    if self.isEmpty():      self._head=temp  #若为空表，将添加的元素设为第一个元素    else:      current=self._head      while current.getNext()!=None:        current=current.getNext()  #遍历链表      current.setNext(temp)  #此时current为链表最后的元素  def search(self,item):    current=self._head    founditem=False    while current!=None and not founditem:      if current.getItem()==item:        founditem=True      else:        current=current.getNext()    return founditem  def index(self,item):    current=self._head    count=0    found=None    while current!=None and not found:      count+=1      if current.getItem()==item:        found=True      else:        current=current.getNext()    if found:      return count    else:      raise ValueError,'%s is not in linkedlist'%item         def remove(self,item):    current=self._head    pre=None    while current!=None:      if current.getItem()==item:        if not pre:          self._head=current.getNext()        else:          pre.setNext(current.getNext())        break      else:        pre=current        current=current.getNext()             def insert(self,pos,item):    if pos<=1:      self.add(item)    elif pos>self.size():      self.append(item)    else:      temp=Node(item)      count=1      pre=None      current=self._head      while count<pos:        count+=1        pre=current        current=current.getNext()      pre.setNext(temp)      temp.setNext(current)if __name__=='__main__':  a=SingleLinkedList()  for i in range(1,10):    a.append(i)  print a.size()  a.travel()  print a.search(6)  print a.index(5)  a.remove(4)  a.travel()  a.insert(4,100)  a.travel()>>>9123456789True51235678912310056789