四种常见链表的实现及时间复杂度分析（Python3版）

四种常见的链表包括：单向链表，单向循环链表，双向链表，双向循环链表。
要实现的链表操作包括

• is_empty() 判断链表是否为空
• length() 求链表长度
• traversing() 遍历所有节点元素
• add() 头部添加节点
• append() 尾部添加节点
• insert(pos, item) 某个位置插入节点
• remove(item) 删除一个节点
• search(item) 查找某个节点是否存在

先初始化节点

class Node(object):
    """单节点"""

    def __init__(self, elem):
        self.elem = elem
        self.next = None


class DoubleNode(Node):
    """双节点"""

    def __init__(self, elem):
        super(DoubleNode, self).__init__(elem)
        self.prev = None

四种链表的实现中，每一个类都继承自object, self.__head是私有变量，不能被子类或外部调用。

class SingleLinkList(object):
    """单向链表"""

    def __init__(self, node=None):
        self.head = node

    def is_empty(self) -> bool:
        """链表是否为空 O(1)"""
        return self.head is None

    def length(self) -> int:
        """链表长度 O(n)"""
        count, cur = 0, self.head
        while cur is not None:
            cur = cur.next  # 不要写错cur = self.head.next, self.__next不是活动指针
            count += 1
        return count

    def traversing(self) -> '':
        """遍历所有节点 O(n)"""
        cur = self.head  # 不是 self._head
        while cur is not None:
            print(cur.elem, end=' ')
            cur = cur.next
        return ''

    def add(self, item) -> None:
        """头部添加节点 O(1)"""
        node = Node(item)
        node.next = self.head
        self.head = node

    def append(self, item) -> None:
        """尾部添加节点 O(n)"""
        node = Node(item)
        cur = self.head
        if self.is_empty():
            self.head = node
        else:
            while cur.next is not None:
                cur = cur.next
            cur.next = node

    def insert(self, position: int, item) -> None:
        """
        节点插入到某个位置 O(n)
        :param position: 0表示第1个位置
        :param item:
        :return: None
        """
        if position <= 0:
            self.add(item)
        elif position >= self.length():
            self.append(item)
        else:
            node = Node(item)
            count, cur = 1, self.head
            while count < position:
                cur = cur.next
                count += 1
            node.next = cur.next
            cur.next = node

    def remove(self, item) -> None:
        """删除链表中的一个节点 O(n)"""
        pre, cur = None, self.head
        while cur is not None:
            if cur.elem == item:
                if cur == self.head:
                    self.head = cur.next
                    break  # 只remove第一个元素
                pre.next = cur.next
                break
            pre = cur
            cur = cur.next

    def search(self, item) -> bool:
        """查找节点是否存在 O(n)"""
        cur = self.head
        while cur is not None:
            if cur.elem == item:
                return True
            cur = cur.next
        return False

class SingleCycleLinkList(object):
    """单向循环链表"""

    def __init__(self, node=None):
        self.__head = node
        if node:
            node.next = node

    def is_empty(self) -> bool:
        """链表是否为空 O(1)"""
        return self.__head is None

    def length(self) -> int:
        """链表长度 O(n)"""
        if self.is_empty():
            return 0
        count, cur = 1, self.__head
        while cur.next != self.__head:
            cur = cur.next  # 不要写错cur = self.__head.next, self.__next不是活动指针
            count += 1
        return count

    def transverse(self) -> '':
        """遍历所有节点 O(n)"""
        if not self.is_empty():
            cur = self.__head  # 不是 self._head
            while cur.next != self.__head:
                print(cur.elem, end=' ')
                cur = cur.next
            print(cur.elem, end=' ')
        return ''

    def add(self, item) -> None:
        """头部添加节点 O(n)"""
        node = Node(item)
        if self.is_empty():
            self.__head = node
            node.next = node
        else:
            cur = self.__head
            while cur.next != self.__head:
                cur = cur.next
            # 退出while循环之后cur指向尾结点
            node.next = self.__head
            self.__head = node
            cur.next = self.__head

    def append(self, item) -> None:
        """尾部添加节点 O(n)"""
        node = Node(item)
        if self.is_empty():
            self.__head = node
            node.next = node
        else:
            cur = self.__head
            while cur.next != self.__head:
                cur = cur.next
            cur.next = node
            node.next = self.__head

    def insert(self, position: int, item) -> None:
        """
        节点插入到某个位置 O(n)
        :param position: 0表示第1个位置
        :param item:
        :return: None
        """
        if position <= 0:
            self.add(item)
        elif position >= self.length():
            self.append(item)
        else:
            node = Node(item)
            count, cur = 1, self.__head
            while count < position:
                cur = cur.next
                count += 1
            node.next = cur.next
            cur.next = node

    def remove(self, item) -> None:
        """删除链表中的一个节点 O(n)"""
        if self.is_empty():
            return
        pre, cur = None, self.__head
        while cur.next != self.__head:
            if cur.elem == item:
                # 移除头结点
                if cur == self.__head:
                    rear = self.__head
                    while rear.next != self.__head:
                        rear = rear.next
                    self.__head = cur.next
                    rear.next = self.__head
                # 移除中间节点
                else:
                    pre.next = cur.next
                return  # 结束。只remove第一个元素
            pre = cur
            cur = cur.next
        # 移除尾结点
        if cur.elem == item:
            if cur == self.__head:
                self.__head = None
            else:
                pre.next = self.__head  # 或者 pre.next = cur.next

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

class DoubleLinkList(object):
    """双向链表"""

    def __init__(self, node=None):
        self.__head = node

    def is_empty(self) -> bool:
        """链表是否为空 O(1)"""
        return self.__head is None

    def length(self) -> int:
        """链表长度 O(n)"""
        count, cur = 0, self.__head
        while cur is not None:
            cur = cur.next  # 不要写错cur = self.__head.next, self.__next不是活动指针
            count += 1
        return count

    def transverse(self) -> '':
        """遍历所有节点 O(n)"""
        cur = self.__head  # 不是 self._head
        while cur is not None:
            print(cur.elem, end=' ')
            cur = cur.next
        return ''

    def add(self, item) -> None:
        """头部添加节点 O(1)"""
        node = DoubleNode(item)
        node.next = self.__head
        self.__head = node
        if node.next:  # 当原链表为空时
            node.next.prev = node

    def append(self, item) -> None:
        """尾部添加节点 O(n)"""
        node = DoubleNode(item)
        cur = self.__head
        if self.is_empty():
            self.__head = node
        else:
            while cur.next is not None:
                cur = cur.next
            cur.next = node
            node.prev = cur

    def insert(self, position: int, item) -> None:
        """
        节点插入到某个位置 O(n)
        :param position: 0表示第1个位置
        :param item:
        :return: None
        """
        if position <= 0:
            self.add(item)
        elif position >= self.length():
            self.append(item)
        else:
            node = DoubleNode(item)
            count, cur = 1, self.__head
            while count < position:
                cur = cur.next
                count += 1
            node.next = cur.next
            node.prev = cur
            cur.next.prev = node
            cur.next = node

    def remove(self, item) -> None:
        """删除链表中的一个节点 O(n)"""
        cur = self.__head
        while cur is not None:
            if cur.elem == item:
                if cur == self.__head:
                    self.__head = cur.next
                    if self.__head:  # 只有一个节点的特殊情况
                        cur.next.prev = None
                else:
                    cur.prev.next = cur.next
                    if cur.next:
                        cur.next.prev = cur.prev
                break  # 只remove第一个元素
            cur = cur.next

    def search(self, item) -> bool:
        """查找节点是否存在 O(n)"""
        cur = self.__head
        while cur is not None:
            if cur.elem == item:
                return True
            cur = cur.next
        return False

class DoubleCycleLinkList(object):
    """双向循环链表"""

    def __init__(self, node=None):
        self.__head = node
        if node:
            node.next = node
            node.prev = node

    def is_empty(self) -> bool:
        """链表是否为空 O(1)"""
        return self.__head is None

    def length(self) -> int:
        """链表长度 O(n)"""
        if self.is_empty():
            return 0
        count, cur = 1, self.__head
        while cur.next != self.__head:
            cur = cur.next  # 不要写错cur = self.__head.next, self.__next不是活动指针
            count += 1
        return count

    def transverse(self) -> '':
        """遍历所有节点 O(n)"""
        if not self.is_empty():
            cur = self.__head  # 不是 self._head
            while cur.next != self.__head:
                print(cur.elem, end=' ')
                cur = cur.next
            print(cur.elem, end=' ')
        return ''

    def add(self, item) -> None:
        """头部添加节点 O(n)"""
        node = DoubleNode(item)
        if self.is_empty():
            self.__head = node
            node.next = node
            node.prev = node
        else:
            cur = self.__head
            while cur.next != self.__head:
                cur = cur.next
            # 退出while循环之后cur指向尾结点，双向循环链表需要改动5个指针
            node.next = self.__head  # 1.node.next指向原来的头结点
            node.prev = cur  # 2.node.prev指向尾结点，当前cur指向的节点
            cur.next.prev = node  # 3.原来头结点的prev指向要插入的node
            self.__head = node  # 4.self.__head指向要插入的node
            cur.next = node  # 5.尾结点的next指向要插入的node

    def append(self, item) -> None:
        """尾部添加节点 O(n)"""
        node = DoubleNode(item)
        if self.is_empty():
            self.__head = node
            node.next = node
            node.prev = node
        else:
            cur = self.__head
            # 退出while循环之后cur指向尾结点，双向循环链表需要改动4个指针
            while cur.next != self.__head:
                cur = cur.next
            cur.next.prev = node  # 1.原来头结点的.prev指向要插入的node
            cur.next = node  # 2.原来尾结点.next指向要插入的node
            node.prev = cur  # 3.node.prev指向原来的尾节点
            node.next = self.__head  # 4.node.next指向头结点

    def insert(self, position: int, item) -> None:
        """
        节点插入到某个位置 O(n)
        :param position: 0表示第1个位置
        :param item:
        :return: None
        """
        if position <= 0:
            self.add(item)
        elif position >= self.length():
            self.append(item)
        else:
            node = DoubleNode(item)
            count, cur = 1, self.__head
            while count < position:
                cur = cur.next
                count += 1
            node.next = cur.next
            node.prev = cur
            cur.next.pre = node
            cur.next = node

    def remove(self, item) -> None:
        """删除链表中的一个节点 O(n)"""
        if self.is_empty():
            return
        cur = self.__head
        while cur.next != self.__head:
            if cur.elem == item:
                # 移除头结点
                if cur == self.__head:
                    cur.prev.next = cur.next
                    cur.next.prev = cur.prev
                    self.__head = cur.next
                # 移除中间节点
                else:
                    cur.prev.next = cur.next
                    cur.next.prev = cur.prev
                return  # 结束。只remove第一个元素
            cur = cur.next
        # 移除尾结点
        if cur.elem == item:
            if cur == self.__head:  # 当链表只有一个节点时
                self.__head = None
            else:
                cur.next.prev = cur.prev
                cur.prev.next = cur.next

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

在以上四种链表的实现中，可以发现有的类方法代码是重复的，具体重复的方法如下：

• 所有的is_empty()方法都一样
• 双向链表的length(), traversing(), search(item)实现与单向链表
• 双向循环链表的length(), traversing(), search(item)实现与单向循环链表一样
  因此，我们可以使用Python中类的特性：继承和多态 来简化代码，使用了继承之后把self.__head改成self.head。

class Node(object):
    """单节点"""

    def __init__(self, elem):
        self.elem = elem
        self.next = None


class DoubleNode(Node):
    """双节点"""

    def __init__(self, elem):
        super(DoubleNode, self).__init__(elem)
        self.prev = None


class SingleLinkList(object):
    """单链表"""

    def __init__(self, node=None):
        self.head = node

    def is_empty(self) -> bool:
        """链表是否为空 O(1)"""
        return self.head is None

    def length(self) -> int:
        """链表长度 O(n)"""
        count, cur = 0, self.head
        while cur is not None:
            cur = cur.next  # 不要写错cur = self.head.next, self.__next不是活动指针
            count += 1
        return count

    def traversing(self) -> '':
        """遍历所有节点 O(n)"""
        cur = self.head  # 不是 self._head
        while cur is not None:
            print(cur.elem, end=' ')
            cur = cur.next
        return ''

    def add(self, item) -> None:
        """头部添加节点 O(1)"""
        node = Node(item)
        node.next = self.head
        self.head = node

    def append(self, item) -> None:
        """尾部添加节点 O(n)"""
        node = Node(item)
        cur = self.head
        if self.is_empty():
            self.head = node
        else:
            while cur.next is not None:
                cur = cur.next
            cur.next = node

    def insert(self, position: int, item) -> None:
        """
        节点插入到某个位置 O(n)
        :param position: 0表示第1个位置
        :param item:
        :return: None
        """
        if position <= 0:
            self.add(item)
        elif position >= self.length():
            self.append(item)
        else:
            node = Node(item)
            count, cur = 1, self.head
            while count < position:
                cur = cur.next
                count += 1
            node.next = cur.next
            cur.next = node

    def remove(self, item) -> None:
        """删除链表中的一个节点 O(n)"""
        pre, cur = None, self.head
        while cur is not None:
            if cur.elem == item:
                if cur == self.head:
                    self.head = cur.next
                    break  # 只remove第一个元素
                pre.next = cur.next
                break
            pre = cur
            cur = cur.next

    def search(self, item) -> bool:
        """查找节点是否存在 O(n)"""
        cur = self.head
        while cur is not None:
            if cur.elem == item:
                return True
            cur = cur.next
        return False


class SingleCycleLinkList(SingleLinkList):
    """单向循环链表"""

    def __init__(self, node=None):
        if node:
            node.next = node
        super(SingleCycleLinkList, self).__init__(node=node)

    def length(self) -> int:
        """链表长度 O(n)"""
        if self.is_empty():
            return 0
        count, cur = 1, self.head
        while cur.next != self.head:
            cur = cur.next  # 不要写错cur = self.head.next, self.__next不是活动指针
            count += 1
        return count

    def traversing(self) -> '':
        """遍历所有节点 O(n)"""
        if not self.is_empty():
            cur = self.head  # 不是 self._head
            while cur.next != self.head:
                print(cur.elem, end=' ')
                cur = cur.next
            print(cur.elem, end=' ')
        return ''

    def add(self, item) -> None:
        """头部添加节点 O(n)"""
        node = Node(item)
        if self.is_empty():
            self.head = node
            node.next = node
        else:
            cur = self.head
            while cur.next != self.head:
                cur = cur.next
            # 退出while循环之后cur指向尾结点
            node.next = self.head
            self.head = node
            cur.next = self.head

    def append(self, item) -> None:
        """尾部添加节点 O(n)"""
        node = Node(item)
        if self.is_empty():
            self.head = node
            node.next = node
        else:
            cur = self.head
            while cur.next != self.head:
                cur = cur.next
            cur.next = node
            node.next = self.head

    def insert(self, position: int, item) -> None:
        """
        节点插入到某个位置 O(n)
        :param position: 0表示第1个位置
        :param item:
        :return: None
        """
        if position <= 0:
            self.add(item)
        elif position >= self.length():
            self.append(item)
        else:
            node = Node(item)
            count, cur = 1, self.head
            while count < position:
                cur = cur.next
                count += 1
            node.next = cur.next
            cur.next = node

    def remove(self, item) -> None:
        """删除链表中的一个节点 O(n)"""
        if self.is_empty():
            return
        pre, cur = None, self.head
        while cur.next != self.head:
            if cur.elem == item:
                # 移除头结点
                if cur == self.head:
                    rear = self.head
                    while rear.next != self.head:
                        rear = rear.next
                    self.head = cur.next
                    rear.next = self.head
                # 移除中间节点
                else:
                    pre.next = cur.next
                return  # 结束。只remove第一个元素
            pre = cur
            cur = cur.next
        # 移除尾结点
        if cur.elem == item:
            if cur == self.head:
                self.head = None
            else:
                pre.next = self.head  # 或者 pre.next = cur.next

    def search(self, item) -> bool:
        """查找节点是否存在 O(n)"""
        if self.is_empty():
            return False
        else:
            cur = self.head
            while cur.next != self.head:
                if cur.elem == item:
                    return True
                cur = cur.next
            return cur.elem == item


class DoubleLinkList(SingleLinkList):
    """双链表"""

    def add(self, item) -> None:
        """头部添加节点 O(1)"""
        node = DoubleNode(item)
        node.next = self.head
        self.head = node
        if node.next:  # 当原链表为空时
            node.next.prev = node

    def append(self, item) -> None:
        """尾部添加节点 O(n)"""
        node = DoubleNode(item)
        cur = self.head
        if self.is_empty():
            self.head = node
        else:
            while cur.next is not None:
                cur = cur.next
            cur.next = node
            node.prev = cur

    def insert(self, position: int, item) -> None:
        """
        节点插入到某个位置 O(n)
        :param position: 0表示第1个位置
        :param item:
        :return: None
        """
        if position <= 0:
            self.add(item)
        elif position >= self.length():
            self.append(item)
        else:
            node = DoubleNode(item)
            count, cur = 1, self.head
            while count < position:
                cur = cur.next
                count += 1
            node.next = cur.next
            node.prev = cur
            cur.next.prev = node
            cur.next = node

    def remove(self, item) -> None:
        """删除链表中的一个节点 O(n)"""
        cur = self.head
        while cur is not None:
            if cur.elem == item:
                if cur == self.head:
                    self.head = cur.next
                    if self.head:  # 只有一个节点的特殊情况
                        cur.next.prev = None
                else:
                    cur.prev.next = cur.next
                    if cur.next:
                        cur.next.prev = cur.prev
                break  # 只remove第一个元素
            cur = cur.next


class DoubleCycleLinkList(SingleCycleLinkList):
    """双向循环链表"""

    def __init__(self, node=None):
        if node:
            node.next = node
            node.prev = node
        super(DoubleCycleLinkList, self).__init__(node=node)

    def add(self, item) -> None:
        """头部添加节点 O(n)"""
        node = DoubleNode(item)
        if self.is_empty():
            self.head = node
            node.next = node
            node.prev = node
        else:
            cur = self.head
            while cur.next != self.head:
                cur = cur.next
            # 退出while循环之后cur指向尾结点，双向循环链表需要改动5个指针
            node.next = self.head  # 1.node.next指向原来的头结点
            node.prev = cur  # 2.node.prev指向尾结点，当前cur指向的节点
            cur.next.prev = node  # 3.原来头结点的prev指向要插入的node
            self.head = node  # 4.self.head指向要插入的node
            cur.next = node  # 5.尾结点的next指向要插入的node

    def append(self, item) -> None:
        """尾部添加节点 O(n)"""
        node = DoubleNode(item)
        if self.is_empty():
            self.head = node
            node.next = node
            node.prev = node
        else:
            cur = self.head
            # 退出while循环之后cur指向尾结点，双向循环链表需要改动4个指针
            while cur.next != self.head:
                cur = cur.next
            cur.next.prev = node  # 1.原来头结点的.prev指向要插入的node
            cur.next = node  # 2.原来尾结点.next指向要插入的node
            node.prev = cur  # 3.node.prev指向原来的尾节点
            node.next = self.head  # 4.node.next指向头结点

    def insert(self, position: int, item) -> None:
        """
        节点插入到某个位置 O(n)
        :param position: 0表示第1个位置
        :param item:
        :return: None
        """
        if position <= 0:
            self.add(item)
        elif position >= self.length():
            self.append(item)
        else:
            node = DoubleNode(item)
            count, cur = 1, self.head
            while count < position:
                cur = cur.next
                count += 1
            node.next = cur.next
            node.prev = cur
            cur.next.pre = node
            cur.next = node

    def remove(self, item) -> None:
        """删除链表中的一个节点 O(n)"""
        if self.is_empty():
            return
        cur = self.head
        while cur.next != self.head:
            if cur.elem == item:
                # 移除头结点
                if cur == self.head:
                    cur.prev.next = cur.next
                    cur.next.prev = cur.prev
                    self.head = cur.next
                # 移除中间节点
                else:
                    cur.prev.next = cur.next
                    cur.next.prev = cur.prev
                return  # 结束。只remove第一个元素
            cur = cur.next
        # 移除尾结点
        if cur.elem == item:
            if cur == self.head:  # 当链表只有一个节点时
                self.head = None
            else:
                cur.next.prev = cur.prev
                cur.prev.next = cur.next


if __name__ == '__main__':
    print("----single_link_list-----")
    single_link_list = SingleLinkList()
    single_link_list.remove('test')
    print(single_link_list.is_empty(), single_link_list.length())
    single_link_list.insert(-1, 'zhao')
    print(single_link_list.is_empty(), single_link_list.length())
    single_link_list.insert(3, 'zi')
    print(single_link_list.length())
    single_link_list.append('yang')
    single_link_list.add("head")
    single_link_list.insert(4, "tail")
    print(single_link_list.traversing())
    single_link_list.remove(1)
    print(single_link_list.traversing())
    single_link_list.remove("head")
    print(single_link_list.traversing())
    single_link_list.remove("tail")
    print(single_link_list.traversing())
    single_link_list.remove('zi')
    print(single_link_list.traversing())

    print("\n----single_cycle_link_list-----")
    single_cycle_link_list = SingleCycleLinkList()
    single_cycle_link_list.remove('test')
    print(single_cycle_link_list.is_empty(), single_cycle_link_list.length())
    single_cycle_link_list.insert(-1, 'zhao')
    print(single_cycle_link_list.is_empty(), single_cycle_link_list.length())
    single_cycle_link_list.insert(3, 'zi')
    print(single_cycle_link_list.length())
    single_cycle_link_list.append('yang')
    single_cycle_link_list.add("head")
    single_cycle_link_list.insert(4, "tail")
    print(single_cycle_link_list.traversing())
    single_cycle_link_list.remove(1)
    print(single_cycle_link_list.traversing())
    single_cycle_link_list.remove("head")
    print(single_cycle_link_list.traversing())
    single_cycle_link_list.remove("tail")
    print(single_cycle_link_list.traversing())
    single_cycle_link_list.remove('zi')
    print(single_cycle_link_list.traversing())

    print("\n----double_link_list-----")
    double_link_list = DoubleLinkList()
    double_link_list.remove('test')
    print(double_link_list.is_empty(), double_link_list.length())
    double_link_list.insert(-1, 'zhao')
    print(double_link_list.is_empty(), double_link_list.length())
    double_link_list.insert(3, 'zi')
    print(double_link_list.length())
    double_link_list.append('yang')
    double_link_list.add("head")
    double_link_list.insert(4, "tail")
    print(double_link_list.traversing())
    double_link_list.remove(1)
    print(double_link_list.traversing())
    double_link_list.remove("head")
    print(double_link_list.traversing())
    double_link_list.remove("tail")
    print(double_link_list.traversing())
    double_link_list.remove('zi')
    print(double_link_list.traversing())

    print("\n----double_cycle_link_list-----")
    double_cycle_link_list = DoubleCycleLinkList()
    double_cycle_link_list.remove('test')
    print(double_cycle_link_list.is_empty(), double_cycle_link_list.length())
    double_cycle_link_list.insert(-1, 'zhao')
    print(double_cycle_link_list.is_empty(), double_cycle_link_list.length())
    double_cycle_link_list.insert(3, 'zi')
    print(double_cycle_link_list.length())
    double_cycle_link_list.append('yang')
    double_cycle_link_list.add("head")
    double_cycle_link_list.insert(4, "tail")
    print(double_cycle_link_list.traversing())
    double_cycle_link_list.remove(1)
    print(double_cycle_link_list.traversing())
    double_cycle_link_list.remove("head")
    print(double_cycle_link_list.traversing())
    double_cycle_link_list.remove("tail")
    print(double_cycle_link_list.traversing())
    double_cycle_link_list.remove('zi')
    print(double_cycle_link_list.traversing())

结果运行如下：

----single_link_list-----
True 0
False 1
2
head zhao zi yang tail 
head zhao zi yang tail 
zhao zi yang tail 
zhao zi yang 
zhao yang 

----single_cycle_link_list-----
True 0
False 1
2
head zhao zi yang tail 
head zhao zi yang tail 
zhao zi yang tail 
zhao zi yang 
zhao yang 

----double_link_list-----
True 0
False 1
2
head zhao zi yang tail 
head zhao zi yang tail 
zhao zi yang tail 
zhao zi yang 
zhao yang 

----double_cycle_link_list-----
True 0
False 1
2
head zhao zi yang tail 
head zhao zi yang tail 
zhao zi yang tail 
zhao zi yang 
zhao yang