数据结构

单链表

实现了单链表的判空、计算长度、遍历、头部添加、尾部追加、中间插入、删除指定元素、搜寻元素的功能

class Node():
  '''创建节点元素'''
  def __init__(self,item):
    '''item为存的值，next为指针'''
    self.elem = item
    self.next = None
    
class SingleLinkList():
  def __init__(self,node=None):
    '''初始化节点，可传可不传参'''
    self.__head = node 
  '''
  思路：
  判断头节点是否为空，则整个链表就是否为空
  '''
  def is_empty(self):
    '''判断链表是否为空'''
    return self.__head is None
  '''
  思路：
  需要一个计数的count，还需要一个游标，
  游标不停的移动到下一个节点，根据节点是否为空来判断是否走完
  移动的过程中，保证count的数值和移动的步数一致
  '''
  def length(self):
    '''计算链表长度'''
    count = 0
    cur = self.__head
    while cur != None:
      count += 1
      cur = cur.next
    return count
  '''
  思路：
  一个游标，移动游标，每到一个节点打印该节点的元素值，根据节点是否为空来判断，是否遍历完
  '''
  def travel(self):
    '''遍历整个链表'''
    cur = self.__head
    while cur != None:
      print(cur.elem,end=" ")
      cur = cur.next
  '''
  思路：
  头部节点原先所指的节点给新节点的next，
  头部节点指向新节点
  '''
  def add(self,item):
    '''头部添加节点'''
    node = Node(item)   
  	node.next = self.__head
    self.__head = node
  '''
  思路：
  通过cur.next ！= None 找到尾部节点，然后将新节点赋值给它，
  因为使用的是.next来判断，所以需要注意链表为空的情况，
  追加判断链表为空，直接使用self.__head = node
  '''
  def append(self,item):
    '''尾部追加节点'''
    node = Node(item)
    if self.__head is None:
      self.__head = node
    else:
      cur = self.__head
      while cur.next != None:
        cur = cur.next
      cur.next = node
  '''
  思路：
  根据插入位置，分别插入头部尾部和中间任意位置
  因为插入时，主要是操作前面的节点，所以需要找到前面节点的位置
  根据判断num 标识和pos的大小，能正好找到前一个节点
  然后交换数据就行
  特殊情况时，已经包含了，空格链表的情况将自动由尾插法插入
  '''   
  def insert(self,pos,item):
    '''中间位置插入节点'''
    if pos<0:
      self.add(item)
    elif pos>self.length()-1:
      self.append(item)
    else:
    	num = 0
      pre = self.__head
      while num<pos:	
        pre = pre.next
        num += 1
      node = Node(item)
      node.next = pre.next
      pre.next = node
  '''
  思路：
  需要双指针，一个指针为找到指定元素节点的位置，另个指针为指定元素节点的前一个节点
  找到元素时：正好是头节点，需要直接将头节点赋予当前游标的next
  '''
  def remove(self,item):
    '''删除链表中的指定的元素'''
    cur = self.__head
    pre = None
    while cur != None:
      if cur.elem == item:
        if cur==self.__head:
          self.__head = cur.next
        else:
          pre.next = cur.next
        break
      else:
        pre = cur
        cur = cur.next
  '''
  思路：
  一个游标判断节点元素和传来的值是否相等
  '''
  def search(self,item):
    '''判断元素是否存在'''
    cur = self.__head
    while cur!=None:
      if cur.elem ==item:
        return True
      cur = cur.next
    else:
      return False

二叉树

class Node():
    def __init__(self,item):
        self.elem = item
        self.lchild = None
        self.rchild = None

class Tree():
    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:
            cur_node = queue.pop(0)
            if cur_node.lchild is None:
                cur_node.lchild = node
                return
            else:
                queue.append(cur_node.lchild)
            if cur_node.rchild is None:
                cur_node.rchild = node
                return
            else:
                queue.append(cur_node.rchild)

    def breadth_travel(self):
      '''遍历'''
        if self.root is None:
            return
        queue = [self.root]
        while queue:
            cur_node = queue.pop(0)
            print(cur_node.elem)
            if cur_node.lchild is not None:
                queue.append(cur_node.lchild)
            if cur_node.rchild is not None:
                queue.append(cur_node.rchild)

    def preorder(self,node):
      '''先序遍历'''
        if node is None:
            return
        print(node.elem,end=" ")
        self.preorder(node.lchild)
        self.preorder(node.rchild)

    def inorder(self,node):
      '''中序遍历'''
        if node is None:
            return
        self.inorder(node.lchild)
        print(node.elem,end=" ")
        self.inorder(node.rchild)

    def outorder(self,node):
      '''后序遍历'''
        if node is None:
            return
        self.outorder(node.lchild)
        self.outorder(node.rchild)
        print(node.elem,end=" ")