python数据结构练习

备忘录：
        练习，即可。
1.自带结构练习
        list、元组、字典、列表基本操作

# list基本操作
li = []
li.append("hangzhou")
li.append("xiamen")
li.append("fuzhou")
li.append("quanzhou")
print(li)
li.remove("quanzhou")
print(li)
#降序
li.sort(reverse=True)
print(li)
#升序
li.sort(reverse=False)
print(li)
# 删除元素
del li[1]
print(li)
print("列表长度:%d"%(len(li)))
for tt in li:
    print(tt)

# 元组基本操作
tu=('Ali','Tencent','Jingdong')
print(tu)
print("tu[0] : ",tu[0])
for xx in tu :
    print(xx)
#元组中的元素值是不允许删除的，但可以使用del语句来删除整个元组
del tu

# 字典基本操作
dictionary = {}
print(dictionary)
dictionary = {'Ali':'云计算','Tencent':'游戏','Jingdong':'电商'}
print(dictionary)
print(dictionary['Ali'])
dictionary.clear()
print(dictionary)
# 集合基本操作
se=set('abcdefg')
print(se)
se=set(('Ali','Tencent','Jingdong'))
print(se)

2.单链表练习

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

# 单链表类
class SingleLinkList(object):

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

    def is_empty(self):
        return self.__head == None

    def length(self):
        cursor = self.__head
        count = 0
        while cursor != None:
            count +=1
            cursor = cursor.next
        return count

    def travel(self):
        cursor = self.__head
        while cursor != None:
            print(cursor.element,end=" ")
            cursor = cursor.next
        print("")

    def add(self, item):
        """链表头部添加元素"""
        node = Node(item)
        node.next = self.__head
        self.__head = node

    def append(self, item):
        """链表尾部添加元素"""
        node = Node(item)
        if self.is_empty():
            self.__head = node
        else:
            cursor = self.__head
            # 找到最后一个
            while cursor.next != None:
                cursor = cursor.next
            cursor.next = node

    def insert(self,position,item):
        if position <=0:
            self.add(item)
        elif position > (self.length()-1):
            self.append(item)
        else:
            pre = self.__head
            count = 0
            #指定位置插入
            while count < (position-1):
                count += 1
                pre = pre.next
            node = Node(item)
            node.next = pre.next
            pre.next = node

    def remove(self,item):
        cursor = self.__head
        pre = None
        while cursor != None:
            if cursor.element == item:
                if cursor == self.__head:
                    self.__head = cursor.next
                else:
                    pre.next = cursor.next
                break
            else:
                pre = cursor
                cursor = cursor.next

    def search(self,item):
        cursor = self.__head
        while cursor != None:
            if cursor.element == item:
                return True
            else:
                cursor = cursor.next
        return  False

def main():
    sl = SingleLinkList()
    print("是否为空:",sl.is_empty())
    print("长度:",sl.length())

    sl.add("杭州")
    sl.travel()

    sl.add("厦门")
    sl.travel()

    sl.append("福州")
    sl.travel()

    sl.append("泉州")
    sl.travel()

    sl.insert(3,"苏州")
    sl.travel()

    print("查找：", sl.search("泉州"))

    try:
        sl.remove("苏州")
        sl.travel()
    except:
        print("异常")
        sl.travel()

if __name__ == '__main__':
    main()

3.双链表练习

class Node(object):
    def __init__(self,item):
        self.element = item
        self.next = None
        self.prev = None

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

    def is_empty(self):
        return self.__head == None

    def length(self):
        cursor  = self.__head
        count = 0
        while cursor != None:
            count +=1
            cursor = cursor.next
        return count

    def travel(self):
        cursor = self.__head
        while cursor !=None:
            print(cursor.element, end=" ")
            cursor = cursor.next
        print("")

    def add(self,item):
        node = Node(item)
        if self.is_empty():
            node.next = self.__head
            self.__head = node
        else:
            node.next = self.__head
            self.__head = node
            node.next.prev = node

    def append(self,item):
        node=Node(item)
        if self.is_empty():
            self.__head=node
        else:
            cursor = self.__head
            while cursor.next !=None:
                cursor = cursor.next
            cursor.next = node
            node.prev = cursor

    def insert(self,position,item):
        if position <=0:
            self.add(item)
        elif position > (self.length()-1):
            self.append(item)
        else:
            cursor = self.__head
            count = 0
            while count <position:
                count +=1
                cursor = cursor.next
            node = Node(item)
            node.next = cursor
            node.prev = cursor.prev
            cursor.prev.next = node
            cursor.prev = node

    def remove(self,item):
        cursor = self.__head
        while cursor != None:
            if cursor.element == item:
                if cursor == self.__head:
                    self.__head = cursor.next
                    if cursor.next:
                        cursor.next.prev = None
                else:
                    cursor.prev.next = cursor.next
                    if cursor.next:
                        if cursor.next:
                            cursor.next.prev = cursor.prev
                break
            else:
                cursor = cursor.next

    def search(self,item):
         cursor = self.__head
         while cursor != None:
             if cursor.element == item:
                 return True
             else:
                 cursor = cursor.next
         return False

def main():

    dl = DoubleLinkList()
    print("是否为空:",dl.is_empty())
    print("长度:",dl.length())

    dl.add("杭州")
    dl.travel()

    dl.append("福州")
    dl.travel()

    dl.add("厦门")
    dl.travel()

    dl.append("泉州")
    dl.travel()

    dl.insert(3,"苏州")
    dl.travel()

    print("查找：", dl.search("泉州"))

    try:
        dl.remove("苏州")
        dl.travel()
    except:
        print("异常")
        dl.travel()

if __name__ == '__main__':
    main()

4.单相循环链表练习

class Node(object):
    def __init__(self,element):
        self.element = element
        self.next = None

class SingleCycleLinkList(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):
        if self.is_empty():
            return 0
        cursor = self.__head
        count = 1
        while cursor.next != self.__head:
            count += 1
            cursor = cursor.next
        return count

    def travel(self):
        if self.is_empty():
            return
        cursor = self.__head
        while cursor.next != self.__head:
            print(cursor.element,end=" ")
            cursor = cursor.next
        print(cursor.element)

    def add(self,item):
        node  = Node(item)
        if self.is_empty():
            self.__head = node
            node.next = node
        else:
            cursor = self.__head
            while cursor.next != self.__head:
                cursor = cursor.next
            node.next = self.__head
            self.__head = node
            cursor.next = self.__head

    def append(self,item):
        node = Node(item)
        if self.is_empty():
            self.__head = node
            node.next = node
        else:
            cursor = self.__head
            while cursor.next != self.__head:
                cursor = cursor.next
            node.next = self.__head
            cursor.next = node

    def insert(self,position,item):
        if position < 0:
            self.add(item)
        elif position > (self.length()-1):
            self.append()
        else:
            prev = self.__head
            count  = 0
            while count < (position-1):
                count += 1
                prev = prev.next
            node = Node(item)
            node.next = prev.next
            prev.next = node

    def remove(self,item):
        if self.is_empty():
            return
        cursor = self.__head
        prev = None

        while cursor.next != self.__head:
            if cursor.element == item:
                if cursor == self.__head:
                    rear = self.__head
                    while rear.next != self.__head:
                        rear = rear.next
                    self.__head = cursor.next
                    rear.next = self.__head
                else:
                    prev.next = cursor.next
                return
            else:
                prev = cursor
                cursor = cursor.next
        if cursor.element == item:
            if cursor == self.__head:
                self.__head = Node
            else:
                prev.next = self.__head

    def search(self,item):
        if self.is_empty():
            return False
        cursor = self.__head
        while cursor.next != self.__head:
            if cursor.element == item:
                return True
            else:
                cursor = cursor.next
        if cursor.element == item:
            return True
        return False

def main():

    dl = SingleCycleLinkList()
    print("是否为空:",dl.is_empty())
    print("长度:",dl.length())

    dl.add("杭州")
    dl.travel()

    dl.append("福州")
    dl.travel()

    dl.add("厦门")
    dl.travel()

    dl.append("泉州")
    dl.travel()

    dl.insert(3,"苏州")
    dl.travel()

    print("查找：", dl.search("泉州"))

    try:
        dl.remove("苏州")
        dl.travel()
    except:
        print("异常")
        dl.travel()

if __name__ == '__main__':
    main()

5.栈练习

class Stack(object):
    def __init__(self):
        self.__list = []

    def push(self,item):
        self.__list.append(item)

    def pop(self):
        return self.__list.pop()

    def peek(self):
        if self.__list:
            return self.__list[-1]
        else:
            return None

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

    def size(self):
        return  len(self.__list)

def main():

    st = Stack()
    print("是否为空:",st.is_empty())
    print("长度:",st.size())

    st.push("杭州")
    print(st.pop())

    st.push("杭州")
    st.push("福州")
    st.push("厦门")
    st.push("泉州")

    print("",st.size())
    print("判断是否为空: ",st.is_empty())
    print("栈顶:", st.peek())

    for i in range(1,4):
        print("元素%d: %s"%(i,st.pop()))

if __name__ == '__main__':
    main()

6.队列练习

class Queue(object):
    def __init__(self):
        self.__list = []

    def enqueue(self,item):
        self.__list.append(item)

    def dequeue(self):
        return self.__list.pop(0)

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

    def size(self):
        return len(self.__list)

def main():

    qu = Queue()
    print("是否为空:",qu.is_empty())
    print("长度:",qu.size())

    qu.enqueue("杭州")
    print(qu.dequeue())

    qu.enqueue("杭州")
    qu.enqueue("福州")
    qu.enqueue("厦门")
    qu.enqueue("泉州")

    print("",qu.size())
    print("判断是否为空: ",qu.is_empty())

    for i in range(1,5):
        print("元素%d: %s"%(i,qu.dequeue()))

if __name__ == '__main__':
    main()

7.双向队列练习

class Dequeue(object):
    def __init__(self):
        self.__list = []

    def add_front(self,item):
        self.__list.insert(0,item)

    def add_rear(self,item):
        self.__list.append(item)

    def pop_front(self):
        return self.__list.pop(0)

    def pop_rear(self):
        return  self.__list.pop()

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

    def size(self):
        return len(self.__list)

def main():

    de = Dequeue()
    print("是否为空:",de.is_empty())
    print("长度:",de.size())

    de.add_rear("杭州")
    print(de.pop_rear())

    de.add_rear("杭州")
    de.add_rear("福州")
    de.add_rear("厦门")
    de.add_rear("泉州")

    print("判断是否为空: ", de.is_empty())
    print("队列长度",de.size())

    for i in range(1,5):
        print("元素%d: %s"%(i,de.pop_rear()))

    de.add_rear("杭州")
    de.add_rear("福州")
    de.add_rear("厦门")
    de.add_rear("泉州")
    de.add_front("苏州")
    de.add_front("上海")
    print("队列长度", de.size())
    for i in range(1,7):
        print("元素%d: %s"%(i,de.pop_rear()))

if __name__ == '__main__':
    main()

8.二叉树练习
   

class Node(object):
    def __init__(self,item):
        self.element  = item
        self.leftChild = None
        self.rightChild = None

class Tree(object):
    def __init__(self):
        self.root = None

    def add(self,item):
        node = Node(item)
        if self.root is None:
            self.root = node
            return
        queue = [self.root]
        while queue:
            current_node = queue.pop(0)
            if current_node.leftChild is None:
                current_node.leftChild = node
                return
            else:
                queue.append(current_node.leftChild)
            if current_node.rightChild is None:
                current_node.rightChild = node
                return
            else:
                queue.append(current_node.rightChild)

    def breadth_travel(self):
        """广度遍历"""
        if self.root is None:
            return
        quque = [self.root]
        while quque:
            current_node = quque.pop(0)
            print(current_node.element,end=" ")
            if current_node.leftChild is not None:
                quque.append(current_node.leftChild)
            if current_node.rightChild is not None:
                quque.append(current_node.rightChild)

    def preorder(self,node):
        """先序遍历，取元素位置"""
        if node is None:
            return
        print(node.element,end=" ")
        self.preorder(node.leftChild)
        self.preorder(node.rightChild)

    def inorder(self,node):
        """中序遍历，取元素位置"""
        if node is None:
            return
        self.inorder(node.leftChild)
        print(node.element,end=" ")
        self.inorder(node.rightChild)

    def postorder(self,node):
        """后序遍历，取元素位置"""
        if node is None:
            return
        self.postorder(node.leftChild)
        self.postorder(node.rightChild)
        print(node.element, end=" ")

def main():

    tr = Tree()
    tr.add(0)
    tr.add(1)
    tr.add(2)
    tr.add(3)
    tr.add(4)
    tr.add(5)
    tr.add(6)
    tr.add(7)
    tr.add(8)
    tr.add(9)
    tr.add(10)
    tr.add(12)
    print("广度遍历:")
    tr.breadth_travel()
    print(" ")
    print("先序遍历:")
    tr.preorder(tr.root)
    print(" ")
    print("中序遍历:")
    tr.inorder(tr.root)
    print(" ")
    print("后序遍历:")
    tr.postorder(tr.root)
    print(" ")

    area = Tree()
    area.add("中国")
    area.add("浙江")
    area.add("福建")
    area.add("杭州")
    area.add("宁波")
    area.add("厦门")
    area.add("福州")
    print("广度遍历:")
    area.breadth_travel()
    print(" ")
    print("先序遍历:")
    area.preorder(area.root)
    print(" ")

if __name__ == '__main__':
    main()

         二叉树输出结果： 
        
以上，感谢。