「二叉搜索树 / set / 朝鲜树 / 替罪羊树」快速排序

要求

给定n个数，对这n个数进行排序

这题当然可以直接调用sort

#include<cstdio>
#include<vector>
#define ll long long
using namespace std;
ll read()
{
    ll x=,f=;char ch=getchar();
    while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
    while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}
    return x*f;
}
int n;
vector<int> a;
int main()
{
    n=read();
    for(int i=;i<=n;i++)
    {
        int x=read();
        a.push_back(x);
    }
    sort(a.begin(),a.end());
    for(vector<int>::iterator i=a.begin();i!=a.end();i++)
        printf("%d ",*i);
    return ;
}

用set实现排序，元素必须无重复

 #include<cstdio>
 #include<set>
 #define ll long long
 using namespace std;
 ll read()
 {
     ll x=,f=;char ch=getchar();
     while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
     while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}
     return x*f;
 }
 int n;
 set<int>st;
 int main()
 {
     n=read();
     for(int i=;i<=n;i++)
     {
         int x=read();
         st.insert(x);
     }
     for(set<int>::iterator i=st.begin();i!=st.end();i++)
         printf("%d ",*i);
     return ;
 }

用二叉搜索树来排序，但不能通过已经排序好的大数据点

 #include<cstdio>
 #define ll long long
 using namespace std;
 ll read()
 {
     ll x = , f = ; char ch = getchar();
     while (ch<'' || ch>'') { if (ch == '-')f = -; ch = getchar(); }
     while (ch >= ''&&ch <= '') { x = x *  + ch - ''; ch = getchar(); }
     return x * f;
 }
 int rt, cnt;    //rt为根节点标号，cnt为当前节点个数
 int t, n, ans;
 int v[], ls[], rs[];
 int insert(int &k, int x)
 {
     if (!k)
     {
         k = ++cnt;
         v[k] = x;
         return k;
     }
     if (x < v[k])  insert(ls[k], x);
     else   insert(rs[k], x);
     return k;
 }

 //中序遍历
 void dfs(int x)
 {
     if (!x)return;
     dfs(ls[x]);
     printf("%d ", v[x]);
     dfs(rs[x]);
 }
 int main()
 {
     n = read();
     for (int i = ; i <= n; i++)
     {
         int x = read();
         insert(rt, x);
     }
     dfs(rt);
     return ;
 }

可以打乱输入的数据实现深度期望

 #include<cstdio>
 #include<cstdlib>
 #include<algorithm>
 #define ll long long
 using namespace std;

 ll read()
 {
     ll x = , f = ; char ch = getchar();
     while (ch<'' || ch>'') { if (ch == '-')f = -; ch = getchar(); }
     while (ch >= ''&&ch <= '') { x = x *  + ch - ''; ch = getchar(); }
     return x * f;
 }
 int rt, cnt;
 int t, n, ans;
 int v[], ls[], rs[];

 int insert(int &k, int x)
 {
     if (!k)
     {
         k = ++cnt;
         v[k] = x;
         return k;
     }
     if (x < v[k])insert(ls[k], x);
     else insert(rs[k], x);
     return k;
 }
 void dfs(int x)
 {
     if (!x)return;
     dfs(ls[x]);
     printf("%d ", v[x]);
     dfs(rs[x]);
 }
 int a[];
 int main()
 {
     n = read();
     for (int i = ; i <= n; i++)
     {
         a[i] = read();
         swap(a[i], a[rand() % i + ]);
     }
     for (int i = ; i <= n; i++)
         insert(rt, a[i]);
     dfs(rt);
     return ;
 }

朝鲜树，当插入超过某个深度时重构整颗树

 #include<set>
 #include<cmath>
 #include<stack>
 #include<queue>
 #include<cstdio>
 #include<vector>
 #include<cstring>
 #include<cstdlib>
 #include<iostream>
 #include<algorithm>
 #define mod 1000000
 #define pi acos(-1)
 #define inf 0x7fffffff
 #define ll long long
 using namespace std;
 ll read()
 {
     ll x = , f = ; char ch = getchar();
     while (ch<'' || ch>'') { if (ch == '-')f = -; ch = getchar(); }
     while (ch >= ''&&ch <= '') { x = x *  + ch - ''; ch = getchar(); }
     return x * f;
 }
 bool flag;
 int rt, cnt;
 int t, n, ans;
 int v[], ls[], rs[];
 int a[];

 int insert(int &k, int x, int depth)
 {
     if (depth > )  flag = ;    //插入某个数时深度大于设定，将重构标志设为true
     if (!k)
     {
         k = ++cnt;
         v[k] = x;
         return k;
     }
     if (x < v[k])insert(ls[k], x, depth + );
     else insert(rs[k], x, depth + );
     return k;
 }
 void dfs(int x)
 {
     if (!x)return;
     dfs(ls[x]);
     printf("%d ", v[x]);
     dfs(rs[x]);
 }

 //简单重构，甚至没有利用前i个有序
 void rebuild(int &k, int l, int r)
 {
     if (l > r)return;
     int mid = (l + r) >> ;
     k = mid;
     v[k] = a[mid];
     rebuild(ls[k], l, mid - );
     rebuild(rs[k], mid + , r);
 }
 int main()
 {
     n = read();
     for (int i = ; i <= n; i++)
         a[i] = read();
     for (int i = ; i <= n; i++)
     {
         insert(rt, a[i], );
         if (flag)
         {
             for (int j = ; j <= i; j++)  ls[j] = rs[j] = v[j] = ;
             rebuild(rt, , i);  //对前i个重构
             flag = ;
         }
     }
     dfs(rt);
     return ;
 }

替罪羊树

通过非旋转的重构实现的二叉平衡树，是朝鲜树的高级版，详情可见https://www.cnblogs.com/lfri/p/10006414.html

参考链接：

http://hzwer.com/8016.html

https://baike.baidu.com/item/朝鲜树/17008833