假设二叉树采用二叉链存储结构，设计二叉树的先序遍历、中序遍历、后序通历和层次遍历算法；并用相关数据进行测试。

二叉树的先序遍历、中序遍历、后序遍历和层次遍历算法可以分别使用递归和非递归实现。

1. 先序遍历算法

先序遍历的顺序是先访问根节点，再访问左子树，最后访问右子树。先序遍历的递归算法如下：

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


def preorderTraversal(root: TreeNode):
    if root:
        print(root.val)
        preorderTraversal(root.left)
        preorderTraversal(root.right)

先序遍历的非递归算法可以使用栈来实现。遍历时先将根节点入栈，然后每次弹出栈顶元素，先访问其右子树，再访问其左子树，因为栈是后进先出的，所以先访问左子树。代码如下：

def preorderTraversal(root: TreeNode):
    if not root:
        return []
    stack, res = [root], []
    while stack:
        node = stack.pop()
        if node:
            res.append(node.val)
            stack.append(node.right)
            stack.append(node.left)
    return res

2. 中序遍历算法

中序遍历的顺序是先访问左子树，再访问根节点，最后访问右子树。中序遍历的递归算法如下：

def inorderTraversal(root: TreeNode):
    if root:
        inorderTraversal(root.left)
        print(root.val)
        inorderTraversal(root.right)

中序遍历的非递归算法也可以使用栈来实现。遍历时先将根节点入栈，然后每次将左子树全部入栈，最后弹出栈顶元素，访问其右子树。代码如下：

def inorderTraversal(root: TreeNode):
    stack, res = [], []
    while stack or root:
        while root:
            stack.append(root)
            root = root.left
        node = stack.pop()
        res.append(node.val)
        root = node.right
    return res

3. 后序遍历算法

后序遍历的顺序是先访问左子树，再访问右子树，最后访问根节点。后序遍历的递归算法如下：

def postorderTraversal(root: TreeNode):
    if root:
        postorderTraversal(root.left)
        postorderTraversal(root.right)
        print(root.val)

后序遍历的非递归算法可以使用两个栈来实现。遍历时先将根节点入栈1，然后每次弹出栈1的栈顶元素，将其左子树和右子树分别入栈1和栈2，最后遍历栈2即可。代码如下：

def postorderTraversal(root: TreeNode):
    if not root:
        return []
    stack1, stack2, res = [root], [], []
    while stack1:
        node = stack1.pop()
        if node:
            stack2.append(node)
            stack1.append(node.left)
            stack1.append(node.right)
    while stack2:
        res.append(stack2.pop().val)
    return res

4. 层次遍历算法

层次遍历的顺序是按照二叉树的层次依次访问节点。层次遍历可以使用队列来实现。遍历时先将根节点入队列，然后每次弹出队列的队首元素，访问其左子树和右子树，并将左子树和右子树分别入队列。代码如下：

def levelOrderTraversal(root: TreeNode):
    if not root:
        return []
    queue, res = [root], []
    while queue:
        level = []
        for i in range(len(queue)):
            node = queue.pop(0)
            level.append(node.val)
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        res.append(level)
    return res

以上是二叉树四种遍历算法的Python实现。