python数据结构

1 单链表

class SingleNode(object):
    """单链表的结点"""
    def __init__(self, item):
        self.item = item
        self.next = None


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

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

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

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

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

    def append(self, item):
        """尾部添加元素"""
        node = SingleNode(item)
        if self.is_empty():  # 先判断链表是否为空，若是空链表，则将_head指向新节点
            self._head = node
        else:   # 若不为空，则找到尾部，将尾节点的next指向新节点
            cur = self._head
            while cur.next is not None:
                cur = cur.next
            cur.next = node

    def insert(self, index, item):
        """指定位置添加元素"""
        if index <= 0:  # 头部插入
            self.add(item)
        elif index > (self.length() - 1):  # 尾部插入
            self.append(item)
        else:  # 找到指定位置
            node = SingleNode(item)
            count = 0
            # pre用来指向指定位置pos的前一个位置pos-1，初始从头节点开始移动到指定位置
            pre = self._head
            while count < (index - 1):
                count += 1
                pre = pre.next
            node.next = pre.next  # 先将新节点node的next指向插入位置的节点
            pre.next = node  # 将插入位置的前一个节点的next指向新节点

    def remove(self, item):
        """删除节点"""
        cur = self._head
        pre = None
        while cur is not None:
            if cur.item == item:  # 找到了指定元素
                if not pre:  # 如果第一个就是删除的节点
                    self._head = cur.next  # 将头指针指向头节点的后一个节点
                else:
                    pre.next = cur.next   # 将删除位置前一个节点的next指向删除位置的后一个节点
                break
            else:
                pre = cur  # 继续按链表后移节点
                cur = cur.next

    def search(self, item):
        """链表查找节点是否存在，并返回True或者False"""
        cur = self._head
        while cur is not None:
            if cur.item == item:
                return True
            cur = cur.next
        return False


if __name__ == "__main__":
    a = SingleLinkList()
    a.append("1")
    a.append("3")
    print(a.travel())
    a.remove("1")
    print(a.travel())

2双链表

class Node(object):
    """双向链表节点"""

    def __init__(self, item):
        self.item = item
        self.next = None
        self.prev = None


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

    def __init__(self):
        self._head = None

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

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

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

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

    def append(self, item):
        """尾部插入元素"""
        node = Node(item)
        if self.is_empty():
            self._head = node  # 如果是空链表，将_head指向node
        else:
            # 移动到链表尾部
            cur = self._head
            while cur.next is not 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 is not 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 is None:
                    # 如果链表只有这一个节点
                    self._head = None
                else:
                    # 将第二个节点的prev设置为None
                    cur.next.prev = None
                    # 将_head指向第二个节点
                    self._head = cur.next
                return
            while cur is not 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

3 队列

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)

4双端队列

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)

5循环队列

class LoopQueue(object):
    def __init__(self, size):
        self.size = size  # 定义队列长度
        self.queue = []  # 存储队列 列表

    def __str__(self):
        return str(self.queue)

    def in_queue(self, n):
        # 入队
        if self.is_full():
            return -1
        self.queue.append(n)  # 列表末尾添加新的对象

    def out_queue(self):
        # 出队
        if self.is_empty():
            return -1
        first_element = self.queue[0]   # 删除队头元素
        self.queue.remove(first_element)  # 删除队操作
        return first_element

    def delete(self, n):
        # 删除某元素
        element = self.queue[n]
        self.queue.remove(element)

    def in_put(self, n, m):
        # 插入某元素 n代表列表当前的第n位元素 m代表传入的值
        self.queue[n] = m

    def get_size(self):
        # 获取当前长度
        return len(self.queue)

    def get_number(self, n):
        # 获取某个元素
        element = self.queue[n]
        return element

    def is_empty(self):
        # 判断是否为空
        if len(self.queue) == 0:
            return True
        return False

    def is_full(self):
        # 判断队列是否满
        if len(self.queue) == self.size:
            return True
        return False

6 栈

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)

7 二叉树

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


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

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

    def preorder(self, root):
        """递归实现先序遍历 根节点->左子树->右子树"""
        if root is None:
            return
        print(root.elem)
        self.preorder(root.left_child)
        self.preorder(root.right_child)

    def inorder(self, root):
        """递归实现中序遍历 左子树->根节点->右子树"""
        if root is None:
            return
        self.inorder(root.left_child)
        print(root.elem)
        self.inorder(root.right_child)

    def postorder(self, root):
        """递归实现后续遍历 左子树->右子树->根节点"""
        if root is None:
            return
        self.postorder(root.left_child)
        self.postorder(root.right_child)
        print(root.elem)

    @staticmethod
    def breadth_travel(root):
        """利用队列实现树的层次遍历"""
        if root is None:
            return
        queue = list()
        queue.append(root)
        while queue:
            node = queue.pop(0)
            print(node.elem)
            if node.left_child is not None:
                queue.append(node.left_child)
            if node.right_child is not None:
                queue.append(node.right_child)

8 图

class Vertex(object):
    """顶点类，包含顶点信息及连接边"""

    def __init__(self, key):
        self.id = key
        self.connect = {}

    def add_neighbor(self, nbr, wight=0):
        # nbr是顶点对象所连接的另外节点
        # wight表示的权重，也就是两点之间的距离
        self.connect[nbr] = wight

    def get_connects(self):  # 返回顶点连接的其他点
        return [[i.id, v] for i, v in self.connect.items()]


class Graph(object):
    """实现图"""

    def __init__(self):
        self.vert_list = {}
        self.count_vertex = 0

    def add_vertex(self, key):
        """在列表中添加节点"""
        self.count_vertex += 1
        self.vert_list[key] = Vertex(key)

    def get_vertex(self, i):
        """查找顶点"""
        return self.vert_list[i].get_connects() if i in self.vert_list else None

    def add_edge(self, key, nbr, wight=0):
        """添加边"""
        if key not in self.vert_list:
            self.add_vertex(key)
        if nbr not in self.vert_list:
            self.add_vertex(nbr)
        self.vert_list[key].add_neighbor(self.vert_list[nbr], wight)

    def get_vertex_num(self):
        """返回所有顶点数量"""
        return self.count_vertex


if __name__ == "__main__":
    graph = Graph()
    graph.add_vertex('a')
    graph.add_vertex('b')
    graph.add_edge('a', 'b', 26)
    graph.add_edge('b', 'a', 12)
    graph.add_edge('a', 'c', 8)
    graph.add_edge('b', 'c', 12)
    print(graph.get_vertex_num())
    print(graph.get_vertex('a'))