排序算法总结--树排序

树排序是利用搜索二叉树的性质来进行排序。

我们知道，搜索二叉树的中序遍历输出就是一个有序的序列。所以我们可以根据跟定的一组元素，构造一个搜索二叉树。

所以算法的就分为了两步：1.构造一个搜索二叉树   2.中序遍历输出

来看代码实现

首先我们创建一个搜索二叉树

//二叉排序树节点的数据结构
typedef struct b_node{
    int value;//节点的值
    struct b_node *l_tree;//左子树
    struct b_node *r_tree;//右子树
    struct b_node *p_parent;//父节点
} BNode, *PBNode;



/**
* 分配一个节点内存
* */
PBNode allocate_node()
{
    PBNode p_node = NULL;
    p_node = (PBNode)malloc(sizeof(struct b_node));
    if (p_node == NULL)
       return NULL;
    memset(p_node , 0, sizeof(struct b_node));
    return p_node ;
}
/**
* 设置一个节点的值
* */
void set_value(PBNode p_node , int value)
{
    if (p_node == NULL)
        return;
    p_node ->value = value;
    p_node ->l_tree = NULL;
    p_node ->r_tree = NULL;
    return;
}
/**
* 向二叉查找树中添加一个节点，使得新的二叉树依然时二叉查找树
* 非递归方法实现
* */
void insert_node(PBNode *root, int value)
{
    if (*root == NULL)
    {
        *root = allocate_node();
        set_value(*root, value);
    }
    else
    {
        PBNode p = *root;
        PBNode pp = NULL;//保存父亲节点
        bool is_left = false;
        while (p != NULL)
        {
            pp = p;
            is_left = false;
            if (value < p->value)
            {
                is_left = true;
                p = p->l_tree;
            }
            else if (value > p->value)
            {
                p = p->r_tree;
            }
         }
         PBNode node = allocate_node();
         set_value(node, value);
         if (is_left)
         {
             pp->l_tree = node;
             node->p_parent = pp;
         }
         else
         {
             pp->r_tree = node;
             node->p_parent = pp;
         }
    }
}
/**
* 插入法创建bst
* */
void create_bst(PBNode *root, int value[], int len)
{
    int i = 0;
    for (; i < len; i++)
    {
        insert_node(root, value[i]);
    }
}

然后中序遍历输出，得到的就是一个有序的序列

void MidTraverse(PBNode p_root)
{
       if (p_root != NULL)
       {
             MidTraverse(p_root->l_tree);
             printf("%d\n", p_root->value);
             MidTraverse(p_root->r_tree);
       }
       return;
}

复杂度分析：

时间复杂度：创建树的复杂度，最差情况是n^2，最好的情况是nlogn。搜索树的复杂度和树的高度有关，小于n，大于logn。所以整体的复杂度是介于O(n^2)到N(nlogn)之间。

空间复杂度：创建树要申请n个空间，所以空间复杂度是O(n)

 

我们知道对于二叉搜索树而言，如果不是平衡的，性能退化比较严重。最差的情况，搜索树就退化成了链表。所以对于二叉搜索树来说，如何保持平衡是关键。

普通二叉搜索树可以优化成红黑树，AVL等，持续学习中。。。