数据结构day4

1 链表

1.1 为什么用链表？

     顺序表的构建需要预先知道数据大小来申请连续的存储空间，而在进行插入时又需要进行数据的搬迁，所以使用起来并不是很灵活。链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理

1.2 链表的定义

     链表(Linked List)是一种常见的基础数据结构，是一只种类线性表，但是不像顺序表一样连续存储数据，而是在每一个节点(数据存储单元)里存放下一个节点的位置信息(即地址)。

链表

1.2.1 链表和顺序表的对比

     链表失去了顺序表随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大，但对存储空间的使用要相对灵活。

操作	链表	顺序表
访问元素	O(n)	O(1)
在头部插入/删除	O(1)	O(1)
在尾部插入/删除	O(n)	O(1)
在中间插入/删除	O(n)	O(n)

     注意虽然表面看起来复杂度都是 O(n)，但是链表和顺序表在插入和删除时进行的是完全不同的操作。链表的主要耗时操作是遍历查找，删除和插入操作本身的复杂度是O(1)。顺序表查找很快，主要耗时的操作是拷贝覆盖。因为除了目标元素在尾部的特殊情况，顺序表进行插入和删除时需要对操作点之后的所有元素进行前后移位操作，只能通过拷贝和覆盖的方法进行。

1.3 链表的种类

     链表分为单向链表和双向链表，单向链表只能从头开始索引，而双向链表可以从头开始也可以从尾部开始索引

1.3.1 单链表

     单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。

单链表以及单链表结点

• 表元素域elem用来存放具体的数据
• 链接域next用来存放下一个节点的位置（python中的标识）
• 变量p指向链表的头节点（首节点）的位置，从p出发能找到表中的任意节点。

1.3.1.1 节点实现

     定义一个节点类，它有数据域和指针域，数据域里存放的是这个节点的数据，指针域里存放的是指向下一节点的指针，初始为空

class SingleNode(object):
    """单链表的节点"""
    def __init__(self,item):
        #_item存放数据元素
        self.item = item
        #_next是下一个节点的标识
        self.next = None

1.3.1.2 单链表的实现

     单链表的实现很容易，主要就是定义对链表的各种方法
单链表的操作

• is_empty() 链表是否为空
• length() 链表长度
• travel() 遍历整个链表

• add(item) 链表头部添加元素

  
  
  头部添加元素
• append(item) 链表尾部添加元素

• insert(pos, item) 指定位置添加元素

  
  
  指定位置添加元素

• remove(item) 删除节点

  
  
  删除节点
• search(item) 查找节点是否存在

class SingleNode:
    """单链表的节点"""
    def __init__(self,item):
        #_item存放数据元素
        self.item = item
        #_next是下一个节点的标识
        self.next = None

class SingleLinkList:
    """单链表"""
    def __init__(self):
        self.__head = None

    
    def is_empty(self):
        """判断链表是否为空"""
        return self.__head == None

    
    def length(self):
        """链表长度"""
        #cur 初始时指向头节点
        cur = self.__head
        count = 0
        #尾节点指向None,当未到达尾部时候
        while cur != None:
            count += 1
            #将cur后移动一个节点
            cur = cur.next
        return count

    
    def travel(self):
        """遍历链表"""
        cur  = self.__head
        while cur != None:
            print (cur.item)
            cur = cur.next
    def add(self,item):
        """头部添加元素"""
        #先创建一个保存item值的节点
        node  = SingleNode(item)
        #将新节点的链接域next指向头节点，即__head指向的位置
        node.next = self.__head
        #将链表的头__head指向新节点
        self.__head = node

    def append(self, item):
        """尾部添加元素"""
        node = SingleNode(item)
        # 先判断链表是否为空，若是空链表，则将__head指向新节点
        if self.is_empty():
            self.__head = node
        # 若不为空，则找到尾部，将尾节点的next指向新节点
        else:
            cur = self.__head
            while cur.next != None:
                cur = cur.next
            cur.next = node
     
        
    def insert(self, pos, item):
        """指定位置添加元素"""
        # 若指定位置pos为第一个元素之前，则执行头部插入
        if pos <= 0:
            self.add(item)
        # 若指定位置超过链表尾部，则执行尾部插入
        elif pos > (self.length()-1):
            self.append(item)
        # 找到指定位置
        else:
            node = SingleNode(item)
            count = 0
            # pre用来指向指定位置pos的前一个位置pos-1，初始从头节点开始移动到指定位置
            pre = self.__head
            while count < (pos-1):
                count += 1
                pre = pre.next
            # 先将新节点node的next指向插入位置的节点
            node.next = pre.next
            # 将插入位置的前一个节点的next指向新节点
            pre.next = node
    def remove(self,item):
        """删除节点"""
        cur = self.__head
        pre = None
        while cur != None:
            # 找到了指定元素
            if cur.item == item:
                # 如果第一个就是删除的节点
                if not pre:
                    # 将头指针指向头节点的后一个节点
                    self.__head = cur.next
                else:
                    # 将删除位置前一个节点的next指向删除位置的后一个节点
                    pre.next = cur.next
                break
            else:
                # 继续按链表后移节点
                pre = cur
                cur = cur.next
        
    def search(self,item):
        """链表查找节点是否存在，并返回True或者False"""
        cur = self.__head
        while cur != None:
            if cur.item == item:
                return True
            cur = cur.next
        return False
    

linklist = SingleLinkList()
linklist.append('lalala')
linklist.add('lailailai')
linklist.travel()
linklist.remove('lailailai')
print(linklist.search('lailailai'))
linklist.travel()

lailailai
lalala
False
lalala

1.3.2 单向循环列表

     单链表的一个变形是单向循环链表，链表中最后一个节点的next域不再为None，而是指向链表的头节点。这是在链表里面形成了一个环，环的长度就是链表的长度

单向循环链表

1.3.2.1 单向循环链表的操作

     单向循环链表节点的实现和单链表节点的一样，单向循环链表也有很多操作

• is_empty() 判断链表是否为空
• length() 返回链表的长度
• travel() 遍历
• add(item) 在头部添加一个节点
• append(item) 在尾部添加一个节点
• insert(pos, item) 在指定位置pos添加节点
• remove(item) 删除一个节点
• search(item) 查找节点是否存在

1.3.2.2 单向循环链表的实现

class Node(object):
    """节点"""
    def __init__(self, item):
        self.item = item
        self.next = None


class SinCycLinkedlist(object):
    """单向循环链表"""
    def __init__(self,node = None):
        self.__head = node
        if node:
            node.next = node

    def is_empty(self):
        """判断链表是否为空"""
        return self.__head == None

    def length(self):
        """返回链表的长度"""
        # 如果链表为空，返回长度0
        if self.is_empty():
            return 0
        count = 1
        cur = self.__head
        while cur.next != self.__head:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        """遍历链表"""
        if self.is_empty():
            return
        cur = self.__head
        while cur.next != self.__head:
            print (cur.item)
            cur = cur.next
        print (cur.item)


    def add(self, item):
        """头部添加节点"""
        node = Node(item)
        if self.is_empty():
            self.__head = node
            node.next = self.__head
        else:
            #添加的节点指向__head
            node.next = self.__head
            # 移到链表尾部，将尾部节点的next指向node
            cur = self.__head
            while cur.next != self.__head:
                cur = cur.next
            cur.next = node
            #__head指向添加node的
            self.__head = node

    def append(self, item):
        """尾部添加节点"""
        node = Node(item)
        if self.is_empty():
            self.__head = node
            node.next = self.__head
        else:
            # 移到链表尾部
            cur = self.__head
            while cur.next != self.__head:
                cur = cur.next
            # 将尾节点指向node
            cur.next = node
            # 将node指向头节点__head
            node.next = self.__head

    def insert(self, pos, item):
        """在指定位置添加节点"""
        if pos <= 0:
            self.add(item)
        elif pos > (self.length()-1):
            self.append(item)
        else:
            node = Node(item)
            cur = self.__head
            count = 0
            # 移动到指定位置的前一个位置
            while count < (pos-1):
                count += 1
                cur = cur.next
            node.next = cur.next
            cur.next = node

    def remove(self, item):
        """删除一个节点"""
        # 若链表为空，则直接返回
        if self.is_empty():
            return
        # 将cur指向头节点
        cur = self.__head
        pre = None
        # 若头节点的元素就是要查找的元素item
        if cur.item == item:
            # 如果链表不止一个节点
            if cur.next != self.__head:
                # 先找到尾节点，将尾节点的next指向第二个节点
                while cur.next != self.__head:
                    cur = cur.next
                # cur指向了尾节点
                cur.next = self.__head.next
                self.__head = self.__head.next
            else:
                # 链表只有一个节点
                self.__head = None
        else:
            pre = self.__head
            # 第一个节点不是要删除的
            while cur.next != self.__head:
                # 找到了要删除的元素
                if cur.item == item:
                    # 删除
                    pre.next = cur.next
                    return
                else:
                    pre = cur
                    cur = cur.next
            # cur 指向尾节点
            if cur.item == item:
                # 尾部删除
                pre.next = cur.next

    def search(self, item):
        """查找节点是否存在"""
        if self.is_empty():
            return False
        cur = self.__head
        if cur.item == item:
            return True
        while cur.next != self.__head:
            cur = cur.next
            if cur.item == item:
                return True
        return False

if __name__ == "__main__":
    ll = SinCycLinkedlist()
    ll.add(1)
    ll.add(2)
    ll.append(3)
    ll.insert(2, 4)
    ll.insert(4, 5)
    ll.insert(0, 6)
    print ("length:",ll.length())
    ll.travel()
    print(ll.search(3))
    print(ll.search(7))
    ll.remove(1)
    print("length:",ll.length())
    ll.travel()

length: 6
6
2
1
4
3
5
True
False
length: 5
6
2
4
3
5

1.3.3 双向链表

     一种更复杂的链表是“双向链表”或“双面链表”。每个节点有两个链接：一个指向前一个节点，当此节点为第一个节点时，指向空值；而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。

双向链表

1.3.3.1 双向循环链表的操作

• is_empty() 链表是否为空
• length() 链表长度
• travel() 遍历链表
• add(item) 链表头部添加
• append(item) 链表尾部添加
• insert(pos, item) 指定位置添加
• remove(item) 删除节点
• search(item) 查找节点是否存在

1.3.3.2 双向循环链表的实现

     双向链表的节点和单链表的有点不同，每个节点有两个指针域，其中一个为前驱指针，指向前一个节点，另一个为后继指针，指向后一个节点，所以每次进行插入或者删除时要对两个指针都要操作

class Node(object):
    """双向链表节点"""
    def __init__(self, item):
        self.item = item
        self.next = None
        self.prev = None


class DLinkList(object):
    """双向链表"""
    def __init__(self):
        self._head = None

    def is_empty(self):
        """判断链表是否为空"""
        return self._head == None

    def length(self):
        """返回链表的长度"""
        cur = self._head
        count = 0
        while cur != None:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        """遍历链表"""
        cur = self._head
        while cur != None:
            print(cur.item,end = ' ')
            cur = cur.next
        print('')

    def add(self, item):
        """头部插入元素"""
        node = Node(item)
        if self.is_empty():
            # 如果是空链表，将_head指向node
            self._head = node
        else:
            # 将node的next指向_head的头节点
            node.next = self._head
            # 将_head的头节点的prev指向node
            self._head.prev = node
            # 将_head 指向node
            self._head = node

    def append(self, item):
        """尾部插入元素"""
        node = Node(item)
        if self.is_empty():
            # 如果是空链表，将_head指向node
            self._head = node
        else:
            # 移动到链表尾部
            cur = self._head
            while cur.next != None:
                cur = cur.next
            # 将尾节点cur的next指向node
            cur.next = node
            # 将node的prev指向cur
            node.prev = cur



    def search(self, item):
        """查找元素是否存在"""
        cur = self._head
        while cur != None:
            if cur.item == item:
                return True
            cur = cur.next
        return False
    def insert(self, pos, item):
        """在指定位置添加节点"""
        if pos <= 0:
            self.add(item)
        elif pos > (self.length()-1):
            self.append(item)
        else:
            node = Node(item)
            cur = self._head
            count = 0
            # 移动到指定位置的前一个位置
            while count < (pos-1):
                count += 1
                cur = cur.next
            # 将node的prev指向cur
            node.prev = cur
            # 将node的next指向cur的下一个节点
            node.next = cur.next
            # 将cur的下一个节点的prev指向node
            cur.next.prev = node
            # 将cur的next指向node
            cur.next = node

    def remove(self, item):
        """删除元素"""
        if self.is_empty():
            return
        else:
            cur = self._head
            if cur.item == item:
                # 如果首节点的元素即是要删除的元素
                if cur.next == None:
                    # 如果链表只有这一个节点
                    self._head = None
                else:
                    # 将第二个节点的prev设置为None
                    cur.next.prev = None
                    # 将_head指向第二个节点
                    self._head = cur.next
                return
            while cur != None:
                if cur.item == item:
                    # 将cur的前一个节点的next指向cur的后一个节点
                    cur.prev.next = cur.next
                    # 将cur的后一个节点的prev指向cur的前一个节点
                    cur.next.prev = cur.prev
                    break
                cur = cur.next

if __name__ == "__main__":
    ll = DLinkList()
    ll.add(1)
    ll.add(2)
    ll.append(3)
    ll.insert(2, 4)
    ll.insert(4, 5)
    ll.insert(0, 6)
    print("length:",ll.length())
    ll.travel()
    print(ll.search(3))
    print(ll.search(4))
    ll.remove(1)
    ll.travel()

length: 6
6 2 1 4 3 5
True
True
6 2 4 3 5

2 栈

     栈（stack），有些地方称为堆栈，是一种容器，可存入数据元素、访问元素、删除元素，它的特点在于只能允许在容器的一端（称为栈顶端指标，英语：top）进行加入数据（英语：push）和输出数据（英语：pop）的运算。没有了位置概念，保证任何时候可以访问、删除的元素都是此前最后存入的那个元素，确定了一种默认的访问顺序。
     由于栈数据结构只允许在一端进行操作，因而按照后进先出（LIFO, Last In First Out）的原理运作。

栈

2.1 栈的操作

• Stack() 创建一个新的空栈
• push(item) 添加一个新的元素item到栈顶
• pop() 弹出栈顶元素
• peek() 返回栈顶元素
• is_empty() 判断栈是否为空
• size() 返回栈的元素个数

2.2栈的实现

栈可以用顺序表实现，也可以用链表实现。我这用的是数组来实现的

class Stack(object):
    """栈:依靠数组实现"""
    def __init__(self):
        self.__items = []

    def is_empty(self):
        """判断是否为空"""
        return self.__items == []

    def push(self,item):
        """加入元素"""
        self.__items.append(item)

    def pop(self):
        """弹出元素"""
        return self.__items.pop()

    def peek(self):
        """返回栈顶元素"""
        return self.__items[len(self.__items)-1]

    def size(self):
        """返回栈的大小"""
        return len(self.__items)


if __name__ == "__main__":
    stack = Stack()
    stack.push("hello")
    stack.push("world")
    stack.push("xxx")
    print(stack.size())
    print(stack.peek())
    print(stack.pop())
    print(stack.pop())
    print(stack.pop())

3
xxx
xxx
world
hello

3 队列

     队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。
     队列是一种先进先出的（First In First Out）的线性表，简称FIFO。允许插入的一端为队尾，允许删除的一端为队头。队列不允许在中间部位进行操作！假设队列是q=（a1，a2，……，an），那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，总是在队列最后。这也比较符合我们通常生活中的习惯，排在第一个的优先出列，最后来的当然排在队伍最后。

队列

3.1 队列的操作

• Queue() 创建一个空的队列
• enqueue(item) 往队列中添加一个item元素
• dequeue() 从队列头部删除一个元素
• is_empty() 判断一个队列是否为空
• size() 返回队列的大小

3.2 队列的实现

同栈一样，队列也可以用顺序表或者链表实现。

class Queue(object):
    """队列"""
    def __init__(self):
        self.__items = []

    def is_empty(self):
        return self.__items == []

    def enqueue(self, item):
        """进队列"""
        self.__items.insert(0,item)

    def dequeue(self):
        """出队列"""
        return self.__items.pop()

    def size(self):
        """返回大小"""
        return len(self.__items)

if __name__ == "__main__":
    q = Queue()
    q.enqueue("hello")
    q.enqueue("world")
    q.enqueue("itcast")
    print (q.size())
    print (q.dequeue())
    print (q.dequeue())
    print (q.dequeue())

3
hello
world
itcast

4 双端队列

     双端队列（deque，全名double-ended queue），是一种具有队列和栈的性质的数据结构。双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。双端队列可以在队列任意一端入队和出队。

4.1 双端队列的操作

• Deque() 创建一个空的双端队列
• add_front(item) 从队头加入一个item元素
• add_rear(item) 从队尾加入一个item元素
• remove_front() 从队头删除一个item元素
• remove_rear() 从队尾删除一个item元素
• is_empty() 判断双端队列是否为空
• size() 返回队列的大小

双端队列的实现

class Deque(object):
    """双端队列"""
    def __init__(self):
        self.items = []

    def is_empty(self):
        """判断队列是否为空"""
        return self.items == []

    def add_front(self, item):
        """在队头添加元素"""
        self.items.insert(0,item)

    def add_rear(self, item):
        """在队尾添加元素"""
        self.items.append(item)

    def remove_front(self):
        """从队头删除元素"""
        return self.items.pop(0)

    def remove_rear(self):
        """从队尾删除元素"""
        return self.items.pop()

    def size(self):
        """返回队列大小"""
        return len(self.items)


if __name__ == "__main__":
    deque = Deque()
    deque.add_front(1)
    deque.add_front(2)
    deque.add_rear(3)
    deque.add_rear(4)
    print (deque.size())
    print(deque.items)
    print (deque.remove_front())
    print (deque.remove_front())
    print (deque.remove_rear())
    print (deque.remove_rear())

4
[2, 1, 3, 4]
2
1
4
3

5 树

     树(英文：tree)是一种抽象数据类型(ADT)或者实作这种抽象数据类型的数据结构，用来模拟具有树状结构性质的数据集合。它是由n(n>=1)个有限节点组成一个具有层次关系的集合。把它叫做"树"是因为它看起来像一颗倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：
-每个节点有零个或多个子节点；

• 没有父节点的节点称为根节点；
• 每一个非根节点有且只有一个父节点；

• 除了根节点外，每个子节点可以分为多个不相交的子数；

  
  
  树

5.1 树的术语

• 节点的度：一个节点含有的子树的个数称为该节点的度；
• 树的度：一棵树中，最大的节点的度称为树的度；
• 叶节点或终端节点：度为零的节点；
• 父亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；
• 孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；
• 兄弟节点：具有相同父节点的节点互称为兄弟节点；
• 节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
• 树的高度或深度：树中节点的最大层次；
• 堂兄弟节点：父节点在同一层的节点互为堂兄弟；
• 节点的祖先：从根到该节点所经分支上的所有节点；
• 子孙：以某节点为根的子树中任一节点都称为该节点的子孙。
• 森林：由m（m>=0）棵互不相交的树的集合称为森林

5.2 树的种类

• 无序树：树中任意节点的子节点之间没有顺序关系，这种树称为无序树，也称为自由树；
• 有序树：树中任意节点的子节点之间有顺序关系，这种树称为有序树；
  • 二叉树：每个节点最多含有两个子树的树称为二叉树；

    • 完全二叉树：对于一颗二叉树，假设其深度为d(d>1)。除了第d层外，其它各层的节点数目均已达最大值，且第d层所有节点从左向右连续地紧密排列，这样的二叉树被称为完全二叉树，其中满二叉树的定义是所有叶节点都在最底层的完全二叉树;

      
      
      完全二叉树

满二叉树

- 平衡二叉树（AVL树）：当且仅当任何节点的两棵子树的高度差不大于1的二叉树；
- 排序二叉树（二叉查找树（英语：Binary Search Tree），也称二叉搜索树、有序二叉树）；

• 霍夫曼树（用于信息编码）：带权路径最短的二叉树称为哈夫曼树或最优二叉树；
• B树：一种对读写操作进行优化的自平衡的二叉查找树，能够保持数据有序，拥有多余两个子树。

5.3 数的存储与表示

• 顺序存储：将数据结构存储在固定的数组中，然在遍历速度上有一定的优势，但因所占空间比较大，是非主流二叉树。二叉树通常以链式存储。

  
  
  顺序存储

• 链式存储：由于对节点的个数无法掌握，常见树的存储表示都转换成二叉树进行处理，子节点个数最多为2

  
  
  链式存储

5.4 常见的一些树的应用场景

1. xml，html等，那么编写这些东西的解析器的时候，不可避免用到树
2. 路由协议就是使用了树的算法
3. mysql数据库索引
4. 文件系统的目录结构

5. 所以很多经典的AI算法其实都是树搜索，此外机器学习中的decision tree也是树结构

   
   
   网页结构

5.5 二叉树

5.5.1 二叉树的基本概念

     二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）

5.5.2 二叉树的性质

1. 在二叉树的第i层上至多有2^(i-1)个结点（i>0）
2. 深度为k的二叉树至多有2^k - 1个结点（k>0）
3. 对于任意一棵二叉树，如果其叶结点数为N0，而度数为2的结点总数为N2，则N0=N2+1;
   性质4:具有n个结点的完全二叉树的深度必为 log2(n+1)
4. 对完全二叉树，若从上至下、从左至右编号，则编号为i 的结点，其左孩子编号必为2i，其右孩子编号必为2i＋1；其双亲的编号必为i/2（i＝1 时为根,除外）

5.5.3 二叉树的节点表示以及树的创建

     首先创建一个树的节点，由于是二叉树，所以有三个属性组成——值，左孩子，右孩子。

class Node(object):
    """节点类"""
    def __init__(self, elem=-1, lchild=None, rchild=None):
        self.elem = elem
        self.lchild = lchild
        self.rchild = rchild

     然后开始树的创建,创建一个树的类，并给一个root根节点，一开始为空，随后添加节点

class Tree(object):
    """树类"""
    def __init__(self, root=None):
        self.root = root

    def add(self, elem):
        """为树添加节点"""
        node = Node(elem)
        #如果树是空的，则对根节点赋值
        if self.root == None:
            self.root = node
        else:
            queue = []
            queue.append(self.root)
            #对已有的节点进行层次遍历
            while queue:
                #弹出队列的第一个元素
                cur = queue.pop(0)
                if cur.lchild == None:
                    cur.lchild = node
                    return
                elif cur.rchild == None:
                    cur.rchild = node
                    return
                else:
                    #如果左右子树都不为空，加入队列继续判断
                    queue.append(cur.lchild)
                    queue.append(cur.rchild)

tree1 = Tree()
tree1.add(21)
tree1.add(99)
tree1.add(89)
tree1.add(92)
tree1.add(9)
tree1.add(31)

这样就将元素的值放入树中了，但是还没有讲到树的遍历所以看不了，下面讲树的遍历

5.5.4 二叉树的遍历

     树的遍历是树的一种重要的运算。所谓遍历是指对树中所有结点的信息的访问，即依次对树中每个结点访问一次且仅访问一次，我们把这种对所有节点的访问称为遍历（traversal）。那么树的两种重要的遍历模式是深度优先遍历和广度优先遍历,深度优先一般用递归，广度优先一般用队列。一般情况下能用递归实现的算法大部分也能用堆栈来实现。

5.5.4.1 深度优先遍历

     对于一颗二叉树，深度优先搜索(Depth First Search)是沿着树的深度遍历树的节点，尽可能深的搜索树的分支。
     那么深度遍历有重要的三种方法。这三种方式常被用于访问树的节点，它们之间的不同在于访问每个节点的次序不同。这三种遍历分别叫做先序遍历（preorder），中序遍历（inorder）和后序遍历（postorder）。我们来给出它们的详细定义，然后举例看看它们的应用。

5.5.4.1.1 先序遍历

     在先序遍历中，我们先访问根节点，然后递归使用先序遍历访问左子树，再递归使用先序遍历访问右子树
根节点->左子树->右子树

def preorder(self, root):
      """递归实现先序遍历"""
      if root == None:
          return
      print (root.elem)
      self.preorder(root.lchild)
      self.preorder(root.rchild)

5.5.4.1.2 中序遍历

     在中序遍历中，我们递归使用中序遍历访问左子树，然后访问根节点，最后再递归使用中序遍历访问右子树
左子树->根节点->右子树

def inorder(self, root):
      """递归实现中序遍历"""
      if root == None:
          return
      self.inorder(root.lchild)
      print (root.elem)
      self.inorder(root.rchild)

5.5.4.1.3 后序遍历

     在后序遍历中，我们先递归使用后序遍历访问左子树和右子树，最后访问根节点
左子树->右子树->根节点

def postorder(self, root):
      """递归实现后续遍历"""
      if root == None:
          return
      self.postorder(root.lchild)
      self.postorder(root.rchild)
      print (root.elem)

5.5.4.2 广度优先遍历

     从树的root开始，从上到下从从左到右遍历整个树的节点

class Node(object):
    """节点类"""
    def __init__(self, elem=-1, lchild=None, rchild=None):
        self.elem = elem
        self.lchild = lchild
        self.rchild = rchild


class Tree(object):
    """树类"""
    def __init__(self, root=None):
        self.root = root

    def add(self, elem):
        """为树添加节点"""
        node = Node(elem)
        #如果树是空的，则对根节点赋值
        if self.root == None:
            self.root = node
        else:
            queue = []
            queue.append(self.root)
            #对已有的节点进行层次遍历
            while queue:
                #弹出队列的第一个元素
                cur = queue.pop(0)
                if cur.lchild == None:
                    cur.lchild = node
                    return
                elif cur.rchild == None:
                    cur.rchild = node
                    return
                else:
                    #如果左右子树都不为空，加入队列继续判断
                    queue.append(cur.lchild)
                    queue.append(cur.rchild)
                    
    def breadth_travel(self, root):
        """利用队列实现树的层次遍历"""
        if root == None:
            return
        queue = []
        queue.append(root)
        while queue:
            node = queue.pop(0)
            print(node.elem)
            if node.lchild != None:
                queue.append(node.lchild)
            if node.rchild != None:
                queue.append(node.rchild)


tree1 = Tree()
tree1.add(21)
tree1.add(99)
tree1.add(89)
tree1.add(92)
tree1.add(9)
tree1.add(31)
tree1.breadth_travel(tree1.root)

21
99
89
92
9
31

总结

     今天讲了很多数据类型，链表和树比较重要，而树又比较难，所以需要认真复习，多刷笔试题。