(1)采用二叉链表存储结构，完成二叉树的层次遍历，先序遍历的非递归算法和中序遍历的非递归算法。代码

二叉树的层次遍历可以采用队列实现。先将根节点入队，然后每次出队一个节点，将其左右子节点入队，直到队列为空。

先序遍历的非递归算法可以采用栈实现。从根节点开始，将其入栈。然后每次出栈一个节点，将其右子节点入栈，再将其左子节点入栈（这样能保证左子节点先被访问）。直到栈为空。

中序遍历的非递归算法也可以采用栈实现。从根节点开始，将其入栈。然后每次将当前节点的所有左子节点入栈，直到左子节点为空。然后出栈一个节点，访问它，再将其右子节点入栈。重复上述过程，直到栈为空。

以下是具体实现的代码：

#include <iostream>
#include <queue>
#include <stack>
using namespace std;

// 二叉树结点的定义
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

// 层次遍历
void levelOrder(TreeNode* root) {
    if (!root) return;
    queue<TreeNode*> q;
    q.push(root);
    while (!q.empty()) {
        TreeNode* node = q.front();
        q.pop();
        cout << node->val << " ";
        if (node->left) q.push(node->left);
        if (node->right) q.push(node->right);
    }
}

// 先序遍历
void preOrder(TreeNode* root) {
    if (!root) return;
    stack<TreeNode*> s;
    s.push(root);
    while (!s.empty()) {
        TreeNode* node = s.top();
        s.pop();
        cout << node->val << " ";
        if (node->right) s.push(node->right);
        if (node->left) s.push(node->left);
    }
}

// 中序遍历
void inOrder(TreeNode* root) {
    if (!root) return;
    stack<TreeNode*> s;
    TreeNode* node = root;
    while (node || !s.empty()) {
        while (node) {
            s.push(node);
            node = node->left;
        }
        node = s.top();
        s.pop();
        cout << node->val << " ";
        node = node->right;
    }
}

int main() {
    /*
        1
       / \
      2   3
     / \
    4   5
    */
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);

    cout << "层次遍历：";
    levelOrder(root);
    cout << endl;

    cout << "先序遍历：";
    preOrder(root);
    cout << endl;

    cout << "中序遍历：";
    inOrder(root);
    cout << endl;

    return 0;
}