设二叉树以二叉链表形式存放，用类C语言设计非递归算法判断一棵根结点为T的二叉树是否为二叉排序树。

可以采用中序遍历的方法来判断一棵二叉树是否为二叉排序树。中序遍历的结果应该是一个递增的序列，如果不是递增的，则不是二叉排序树。

具体实现如下：

#include <stdio.h>
#include <stdlib.h>

// 定义二叉树结构体
typedef struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
} TreeNode;

// 定义栈结构体
typedef struct Stack {
    TreeNode *node;
    struct Stack *next;
} Stack;

// 创建节点
TreeNode* createNode(int val) {
    TreeNode *node = (TreeNode*)malloc(sizeof(TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

// 插入节点
TreeNode* insertNode(TreeNode *node, int val) {
    if (node == NULL) {
        node = createNode(val);
        return node;
    }
    if (node->val > val) {
        node->left = insertNode(node->left, val);
    } else {
        node->right = insertNode(node->right, val);
    }
    return node;
}

// 创建栈
Stack* createStack() {
    Stack *stack = (Stack*)malloc(sizeof(Stack));
    stack->node = NULL;
    stack->next = NULL;
    return stack;
}

// 入栈
void push(Stack *stack, TreeNode *node) {
    Stack *newNode = createStack();
    newNode->node = node;
    newNode->next = stack->next;
    stack->next = newNode;
}

// 出栈
TreeNode* pop(Stack *stack) {
    if (stack->next == NULL) {
        return NULL;
    }
    TreeNode *node = stack->next->node;
    stack->next = stack->next->next;
    return node;
}

// 非递归中序遍历
int isBST(TreeNode *root) {
    if (root == NULL) {
        return 1;
    }
    Stack *stack = createStack();
    TreeNode *node = root;
    int flag = 1;
    int pre = node->val;
    while (node != NULL || stack->next != NULL) {
        while (node != NULL) {
            push(stack, node);
            node = node->left;
        }
        node = pop(stack);
        if (node->val < pre) {
            flag = 0;
            break;
        }
        pre = node->val;
        node = node->right;
    }
    return flag;
}

// 测试代码
int main() {
    // 构建二叉树
    TreeNode *root = createNode(4);
    insertNode(root, 2);
    insertNode(root, 6);
    insertNode(root, 1);
    insertNode(root, 3);
    insertNode(root, 5);
    insertNode(root, 7);
    // 判断是否为二叉排序树
    int flag = isBST(root);
    if (flag) {
        printf("This is a Binary Search Tree.\n");
    } else {
        printf("This is not a Binary Search Tree.\n");
    }
    return 0;
}

这里我们使用了一个栈来保存遍历的节点，用一个变量pre来保存上一个节点的值，从而判断是否递增。这个算法的时间复杂度为O(n)，空间复杂度为O(h)，其中h为树的高度。