《剑指offer》预备知识-链表与二叉树

前言

最近在重温之前写过的剑指offer的代码，不得不说现在无论是社招还是校招，从搞java的到搞python的，都会被问点数据结构和算法类的题目。个人认为《剑指offer》编得相当不错，如果真的能扎扎实实搞懂里面的题目的话，应付中小厂的面试基本不会有什么问题。不过落落本身是搞数据和模型的，对数据结构和计算机类知识底子较薄，所以写出来的玩意只能拿来讨论参考。
在这一系列的笔记正式开始之前，先写一篇预备的知识。《剑指offer》涉及若干和链表与二叉树相关的题目，在这里我们先给出链表与树的定义，方便以后的解题。

二叉树

树结构在客观世界中广泛存在，如人类社会的族谱和各种社会组织机构都可用树形象表示。树在计算机领域中也得到广泛应用，如在编译源程序如下时，可用树表示源源程序如下的语法结构。又如在数据库系统中，树型结构也是信息的重要组织形式之一。二叉树（Binary tree）则是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个结点最多只能有两棵子树，且有左右之分。
在《剑指offer》中，我们定义一个二叉树的类。先定义节点，然后再定义树。：

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class BinaryTree:
    def __init__(self, rootObj):
        self.key = rootObj
        self.left = None
        self.right = None

    def insertLeft(self, newNode): # 左节点插入
        if self.left == None:
            self.left = BinaryTree(newNode)
        else:
            t = BinaryTree(newNode)
            t.left = self.left
            self.left = t

    def insertRight(self, newNode):  # 右节点插入
        if self.right == None:
            self.right = BinaryTree(newNode)
        else:
            t = BinaryTree(newNode)
            t.right = self.right
            self.right = t

    def getRightChild(self): # 右子节点
        return self.right

    def getLeftChild(self): # 左子节点
        return self.left

    def setRootVal(self, obj): # 设置根节点
        self.key = obj

    def getRootVal(self): # 获取根节点
        return self.key

链表

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。
在《剑指offer》中，我们尝试定义链表：

class ListNode(): # 定义链表节点
    __slots__ = ['val', 'next']

    def __init__(self, x):
        self.val = x
        self.next = None

    def getItem(self):
        return self.val

    def getNext(self):
        return self.next

    def setItem(self, newitem):
        self.val = newitem

    def setNext(self, newnext):
        self.next = newnext

class LinkList(): # 定义单链表
    def __init__(self):
        self.head = None  # 初始化为空链表

    def isEmpty(self): # 是否为空
        return self.head == None

    def size(self): # 链表长度
        current = self.head
        count = 0
        while current != None:
            count += 1
            current = current.getNext()
        return count

    def travel(self):
        current = self.head
        while current is not None:
            print(current.val)
            current = current.next
        return

    def add(self, item): # 在链表前端添加元素
        temp = ListNode(item)
        temp.setNext(self.head)
        self.head = temp

    def append(self, item):  # 在链表末端添加元素
        temp = ListNode(item)
        if self.isEmpty():
            self.head = temp  # 若为空表，将添加的元素设为第一个元素
        else:
            current = self.head
            while current.getNext() != None:
                current = current.getNext()  # 遍历链表
            current.setNext(temp)  # 此时current为链表最后的元素

    def search(self, item):  # 检索元素是否在链表中
        current = self.head
        founditem = False
        while current != None and not founditem:
            if current.getItem() == item:
                founditem = True
            else:
                current = current.getNext()
        return founditem

    def index(self, item):  # 索引元素在链表中的位置
        current = self.head
        count = 0
        found = None
        while current != None and not found:
            count += 1
            if current.getItem() == item:
                found = True
            else:
                current = current.getNext()
        if found:
            return count
        else:
            raise (ValueError, '%s is not in linkedlist' % item)

    def remove(self, item):  # 删除链表中的某项元素
        current = self.head
        pre = None
        while current != None:
            if current.getItem() == item:
                if not pre:
                    self.head = current.getNext()
                else:
                    pre.setNext(current.getNext())
                break
            else:
                pre = current
                current = current.getNext()

    def insert(self, pos, item):  # 插入元素
        if pos <= 1:
            self.add(item)
        elif pos > self.size():
            self.append(item)
        else:
            temp = ListNode(item)
            count = 1
            pre = None
            current = self.head
            while count < pos:
                count += 1
                pre = current
                current = current.getNext()
            pre.setNext(temp)
            temp.setNext(current)

小结

作为数据结构中最最常出现的两种结构，掌握它们是开启《剑指offer》篇章的基础。