#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <cmath>
#include <string>
#include <queue>
#include <iomanip>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <complex>
#include <stack>
#include <fstream>

#define null nullptr
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()

using namespace std;
typedef int64_t ll;
typedef double long dl;
typedef uint64_t ull;
//const dl EPS = 1e-6;
//////
//struct wor {
//    dl x = 0, y = 0;
//};
//
////
//dl dist(wor a, wor b) {
//    dl answer = sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
//    return answer;
//}

//
////
//wor intersect(wor a, wor b, wor c) {
//    if (b.x - a.x == 0) {
//        return {b.x, c.y};
//    }
//    if (b.y - a.y == 0) {
//        return {c.x, b.y};
//    }
//    wor A;
//    A.x = b.x - a.x;
//    A.y = b.y - a.y;
//    dl C = A.x * c.x + A.y * c.y;
//
//    wor answer;
//    dl C1 = -A.x * a.y + A.y * a.x;
//    answer.y = (C1 - A.y * C / A.x) / (-A.x - A.y * A.y / A.x);
//    answer.x = (C - A.y * answer.y) / A.x;
//
//    return answer;
//}
//
////
//ll vec(wor a, wor b) {
//    return a.x * b.y - a.y * b.x;
//}
//
//ll scal(wor &a, wor &b) {
//    return a.x * b.x + a.y * b.y;
//}

//
//bool rely(wor a, wor b, wor c) {
//    return min(a.x, b.x) < c.x + 1e-8 && c.x < max(b.x, a.x) + 1e-8 && min(a.y, b.y) < c.y + 1e-8 &&
//           c.y < max(b.y, a.y) + 1e-8;
//}
//
////
//wor operator-(wor a, wor b) {
//    wor res;
//    res.x = a.x - b.x;
//    res.y = a.y - b.y;
//    return res;
//}
//
//wor operator+(wor a, wor b) {
//    wor res;
//    res.x = a.x + b.x;
//    res.y = a.y + b.y;
//    return res;
//}
//
//wor operator/(wor a, dl b) {
//    wor res;
//    res.x = a.x / b;
//    res.y = a.y / b;
//    return res;
//}
//
//void operator/=(wor &a, dl b) {
//    a.x /= b;
//    a.y /= b;
//}
//
////
//bool is_in(vector<wor> &pol, wor c) {
//    for (int i = 1; i <= pol.size(); i++) {
//        wor a = pol[i % pol.size()] - pol[i - 1];
//        if (vec(a, c - pol[i - 1]) < 0) {
//            return false;
//        }
//    }
//    return true;
//}
//
//bool suit(vector<wor> &pol, wor c, dl length) {
//    for (int i = 1; i <= pol.size(); i++) {
//        auto inter = intersect(pol[i % pol.size()], pol[i - 1], c);
//        if (rely(pol[i % pol.size()], pol[i - 1], inter)) {
//            if (dist(inter, c) < length + 1e-8)return true;
//        }
//        if (dist(pol[i % pol.size()], c) < length + 1e-8) {
//            return true;
//        }
//        if (dist(pol[i - 1], c) < length + 1e-8) {
//            return true;
//        }
//    }
//    return false;
//}
//

//ll find(ll v, vector<ll> &parent) {
//    if (parent[v] == v) {
//        return v;
//    }
//    return parent[v] = find(parent[v], parent);
//}
//
//void merge(ll a, ll b, vector<ll> &parent, vector<ll> &size, vector<ll> &mi, vector<ll> &ma) {
//
//    if (size[a] > size[b]) {
//        parent[b] = a;
//        size[a] += size[b];
//        mi[a] = min(mi[a], mi[b]);
//        ma[a] = max(ma[a], ma[b]);
//    } else {
//        parent[a] = b;
//        size[b] += size[a];
//        mi[b] = min(mi[b], mi[a]);
//        ma[b] = max(ma[b], ma[a]);
//    }
//}
//dl func(dl x, dl h,dl l){
//    dl k = l - sqrt(x*x+h*h);
//    return x*k/sqrt(x*x+h*h);
//}
//void retro(ll node,vector<ll> &parent,vector<bool> &win,vector<bool> &loose,vector<ll> &am,vector<bool> &used){
//    used[node]=true;
//    if(node==0 || used[parent[node]])return;
//    if(loose[node]){
//        loose[parent[node]]=true;
//        retro(parent[node],parent,win,loose,am,used);
//    }else if(win[node]){
//        am[parent[node]]--;
//        if(am[parent[node]]==0){
//            win[parent[node]]=true;
//            retro(parent[node],parent,win,loose,am,used);
//        }
//    }
//}
//wor beg;
//
//bool comp(wor &a, wor &b) {
//    wor k = a - beg;
//    wor z = b - beg;
//    if (vec(k, z) == 0) {
//        return k.x * k.x + k.y * k.y < z.x * z.x + z.y * z.y;
//    }
//    return vec(k, z) > 0;
//}
//
//vector<wor> get_hull(vector<wor> arr) {
//    ll mi = 0;
//    for (int i = 1; i < arr.size(); i++) {
//        if (arr[i].x < arr[mi].x) {
//            mi = i;
//        } else if (arr[i].x == arr[mi].x && arr[i].y < arr[mi].y) {
//            mi = i;
//        }
//    }
//    swap(arr[0], arr[mi]);
//    beg = arr[0];
//    sort(arr.begin() + 1, arr.end(), comp);
//    vector<wor> answer;
//    answer.push_back(arr[0]);
//    answer.push_back(arr[1]);
//    for (int i = 2; i < arr.size(); i++) {
//        wor temp = arr[i] - answer.back();
//        wor temp1 = arr[i] - answer[answer.size() - 2];
//        while (answer.size() >= 2 && vec(temp1, temp) <= 0) {
//            answer.pop_back();
//            if (answer.size() == 1)break;
//            temp = arr[i] - answer.back();
//            temp1 = arr[i] - answer[answer.size() - 2];
//        }
//        answer.push_back(arr[i]);
//    }
//    return answer;
//}
//dl deg(wor &a, wor &b,wor &c){
//    wor k = a-b;
//    wor z = c-b;
//    return acos((k.x*z.x + k.y*z.y)/(dist(a,b)*dist(b,c)));
//}
//const dl PI = acos(-1);
//bool comp(ll a, ll b){
//    return sin(a)>sin(b);
//}

//bool byXbyY(wor a, wor b) {
//    if (a.x == b.x) {
//        return a.y < b.y;
//    }
//    return a.x < b.x;
//}
//const dl PI = acos(-1);
//
//dl get_x(dl a, dl b, dl h, dl d) {
//    if (h <= d) {
//        return b - a;
//    }
//    return (b - a) / h * d;
//}
//
//struct sq {
//    vector<wor> data;
//};
//
//sq build(wor a, wor b) {
//    wor c = b - a;
//    wor n;
//    n.x = -c.y;
//    n.y = c.x;
//    n /= 2;
//    wor center = a + (c / 2);
//    sq res;
//    res.data.push_back(a);
//    res.data.push_back(center - n);
//    res.data.push_back(b);
//    res.data.push_back(center + n);
//    return res;
//}
//
//dl dist_to_sq(wor p, sq s) {
//    if (is_in(s.data, p)) {
//        return 0;
//    }
//    dl answer = 1e16;
//    for (auto e : s.data) {
//        answer = min(answer, dist(p, e));
//    }
//    for (int i = 1; i <= s.data.size(); i++) {
//        auto inter = intersect(s.data[i % s.data.size()], s.data[i - 1], p);
//        if (rely(s.data[i % s.data.size()], s.data[i - 1], inter)) {
//            answer = min(answer, dist(p, inter));
//        }
//    }
//    return answer;
//}
//

//
//
//bool is_prime(ll p) {
//    for (ll i = 2; i * i <= p; i++) {
//        if (p % i == 0)return false;
//    }
//    return true;
//}
//
vector<pair<ll,ll>> canon(ll p) {
    vector<pair<ll,ll>> answer;
    for (ll i = 2; i * i <= p; i++) {
        if (p % i == 0) {
            ll k =0;
            while (p % i == 0) {
                p /= i;
                k++;
            }
            answer.push_back({i,k});
        }
    }
    if (p > 1)answer.push_back({p,1});
    return answer;
}
//

template<typename T, typename R>
istream &operator>>(istream &is, pair<T, R> &a) {
    is >> a.first >> a.second;
    return is;
}

template<typename T, typename R>
ostream &operator<<(ostream &os, pair<T, R> &a) {
    os << a.first << " " << a.second;
    return os;
}

template<typename T>
ostream &operator<<(ostream &os, vector<T> &a) {
    for (auto e : a) {
        os << e << " ";
    }
    return os;
}

template<typename T>
istream &operator>>(istream &is, vector<T> &a) {
    for (auto &e:a) {
        is >> e;
    }
    return is;
}

//ll bin_pow(ll a, ll b, ll mod){
//    ll res = 1;
//    while(b){
//        if(b&1){
//            res*=a;
//            res%=mod;
//        }
//        a*=a;
//        a%=mod;
//        b>>=1;
//    }
//    return res;
//}
//void count_sort(vector<ll> &p, vector<ll> &c) {
//    ll n = p.size();
//    vector<ll> am(n);
//    for (auto e : c) {
//        am[e]++;
//    }
//    vector<ll> pos(n);
//    vector<ll> res_p(n);
//    pos[0] = 0;
//    for (int i = 1; i < n; i++) {
//        pos[i] = pos[i - 1] + am[i - 1];
//    }
//    for (auto e : p) {
//        res_p[pos[c[e]]] = e;
//        pos[c[e]]++;
//    }
//    p.swap(res_p);
//}

//pair<vector<ll>, vector<ll>> suf_arr(string &s) {
//    s += " ";
//    ll n = s.length();
//    vector<ll> p(n), c(n);
//    {
//        vector<pair<char, ll>> arr(n);
//        for (int i = 0; i < n; i++)arr[i] = {s[i], i};
//        sort(all(arr));
//        for (int i = 0; i < n; i++)p[i] = arr[i].second;
//        c[p[0]] = 0;
//        for (int i = 1; i < n; i++) {
//            if (arr[i].first == arr[i - 1].first) {
//                c[p[i]] = c[p[i - 1]];
//            } else {
//                c[p[i]] = c[p[i - 1]] + 1;
//            }
//        }
//    }
//    ll k = 0;
//    while ((1ll << k) < n) {
//        for (int i = 0; i < n; i++) {
//            p[i] = (p[i] + n - (1ll << k)) % n;
//        }
//        count_sort(p, c);
//        vector<ll> c_new(n);
//        c_new[p[0]] = 0;
//        for (int i = 1; i < n; i++) {
//            pair<ll, ll> now = {c[p[i]], c[(p[i] + (1ll << k)) % n]};
//            pair<ll, ll> was = {c[p[i - 1]], c[(p[i - 1] + (1ll << k)) % n]};
//            if (was == now) {
//                c_new[p[i]] = c_new[p[i - 1]];
//            } else {
//                c_new[p[i]] = c_new[p[i - 1]] + 1;
//            }
//        }
//        c.swap(c_new);
//        k++;
//    }
//    vector<ll> lcp(n);
//    k = 0;
//    for (int i = 0; i < n - 1; i++) {
//        ll pid = c[i];
//        ll prev = p[pid - 1];
//        while (s[i + k] == s[prev + k]) {
//            k++;
//        }
//        lcp[pid] = k;
//        k = max(0ll, k - 1);
//    }
//    return {p, lcp};
//}
//void count_sort(vector<ll> &p, vector<ll> &c) {
//    ll n = p.size();
//    vector<ll> am(n);
//    for (auto e : c) {
//        am[e]++;
//    }
//    vector<ll> pos(n);
//    vector<ll> p_res(n);
//    pos[0] = 0;
//    for (int i = 1; i < n; i++) {
//        pos[i] = pos[i - 1] + am[i - 1];
//    }
//    for (auto e : p) {
//        p_res[pos[c[e]]] = e;
//        pos[c[e]]++;
//    }
//    p.swap(p_res);
//}
//
//pair<vector<ll>, vector<ll>> suf_arr(string &s) {
//    s += "$";
//    ll n = s.length();
//    vector<ll> p(n), c(n);
//    {
//        vector<pair<char, ll>> arr(n);
//        for (int i = 0; i < n; i++)arr[i] = {s[i], i};
//        sort(all(arr));
//        for (int i = 0; i < n; i++) {
//            p[i] = arr[i].second;
//        }
//        c[p[0]] = 0;
//        for (int i = 1; i < n; i++) {
//            if (arr[i].first == arr[i - 1].first) {
//                c[p[i]] = c[p[i - 1]];
//            } else {
//                c[p[i]] = c[p[i - 1]] + 1;
//            }
//        }
//    }
//    ll k = 0;
//    while ((1 << k) < n) {
//        for (int i = 0; i < n; i++) {
//            p[i] = (p[i] - (1 << k) + n) % n;
//        }
//        count_sort(p, c);
//        vector<ll> c_new(n);
//        c_new[p[0]] = 0;
//        for (int i = 1; i < n; i++) {
//            pair<ll, ll> was = {c[p[i - 1]], c[(p[i - 1] + (1 << k)) % n]};
//            pair<ll, ll> now = {c[p[i]], c[(p[i] + (1 << k)) % n]};
//            if (now == was) {
//                c_new[p[i]] = c_new[p[i - 1]];
//            } else {
//                c_new[p[i]] = c_new[p[i - 1]] + 1;
//            }
//        }
//        c.swap(c_new);
//        k++;
//    }
//    vector<ll> lcp(n);
//    k = 0;
//    for (int i = 0; i < n - 1; i++) {
//        ll id = c[i];
//        ll pid = p[id - 1];
//        while (s[i + k] == s[pid + k]) {
//            k++;
//        }
//        lcp[id] = k;
//        k = max(0ll, k - 1);
//    }
//    return {p, lcp};
//}
//const ll mod = 998244353;
//ll len = (mod-1)&(-(mod-1));
//ll LOG_gl = 23;
//ll base_gl = 31;
//vector<ll> bit_rev(ll n, ll log){
//    vector<ll> rev(n);
//    ll k = 0 ;
//    for(ll i =1 ; i < n; i ++){
//        rev[i]  = rev[i^(1ll<<k)] ^ (1ll<<(log-k-1));
//        if(!((i+1)&(i)))k++;
//    }
//    return rev;
//}
//vector<ll> get_w(ll n,ll log){
//    ll base = bin_pow(base_gl,(1ll<<(LOG_gl - log)),mod);
//    vector<ll> w(n);
//    w[0] =1;
//    for(int i = 1; i < n ; i ++){
//        w[i] = (w[i-1] * base)%mod;
//    }
//    return w;
//}
//ll w(ll pow, ll base, vector<ll> &ws, ll N){
//    return ws[pow*N/base];
//}
//void butterfly(ll &a, ll &b, ll w){
//    ll x = (a +b*w%mod)%mod;
//    ll y = (a + mod - b*w%mod)%mod;
//    a = x;
//    b = y;
//}
//vector<ll> fft(vector<ll> &a,ll n, ll LOG , bool back){
//    const ll nrev = bin_pow(n,mod-2,mod);
//    auto rev = bit_rev(n,LOG);
//    vector<ll> temp =a;
//    for(int i = 0 ; i < n; i ++){
//        temp[rev[i]] = a[i];
//    }
//    a.swap(temp);
//    auto ws = get_w(n,LOG);
//    for(ll dl = 1; dl < n; (dl <<=1)){
//        for(int i = 0 ; i < n ; i +=2*dl){
//            for(ll k = 0 ; k < dl ; k ++){
//                butterfly(a[i+k], a[i+dl + k], w(k,2*dl,ws,n));
//            }
//        }
//    }
//    if(back){
//        for(int i = 0 ; i < n; i ++){
//            (a[i] *=nrev)%=mod;
//        }
//        reverse(a.begin()+1,a.end());
//    }
//    return a;
//}
//vector<ll> mult(vector<ll> &a,vector<ll> &b){
//    ll n = a.size() + b.size();
//    while(n&(n-1)){
//        n++;
//    }
//    a.resize(n);
//    b.resize(n);
//    ll t = 0 , temp_c = n;
//    while(temp_c > 1){
//        t++;
//        temp_c>>=1;
//    }
//    a = fft(a,n,t,false);
//    b = fft(b,n,t,false);
//    for(int i = 0 ; i < n ; i ++){
//        (a[i]*=b[i])%=mod;
//    }
//    return fft(a,n,t,true);
//}

//pair<vector<ll>, vector<ll>> manaker(string &s) {
//    ll n = s.length();
//    ll l = 0;
//    ll r = -1;
//    vector<ll> d1(n);
//    for (int i = 0; i < n; i++) {
//        ll k = i > r ? 1 : min(d1[l + r - i], r - i + 1);
//        while (i + k < n && i - k >= 0 && s[i + k] == s[i - k]) {
//            k++;
//        }
//        d1[i] = k;
//        if (i + k - 1 > r) {
//            r = i + k - 1;
//            l = i - k + 1;
//        }
//    }
//
//    vector<ll> d2(n);
//    l = 0;
//    r = -1;
//    for (int i = 0; i < n; i++) {
//        ll k = i > r ? 0 : min(d2[l + r - i + 1], r - i + 1);
//        while (i + k < n && i - k - 1 >= 0 && s[i + k] == s[i - k - 1]) {
//            k++;
//        }
//        d2[i] = k;
//        if (i + k - 1 > r) {
//            r = i + k - 1;
//            l = i - k;
//        }
//    }
//    return {d1, d2};
//}
//
//vector<ll> pref(string &s) {
//    ll n = s.length();
//    vector<ll> p(n);
//    p[0] = 0;
//    for (int i = 1; i < n; i++) {
//        ll j = p[i - 1];
//        while (j > 0 && s[j] != s[i]) {
//            j = p[j - 1];
//        }
//        if (s[i] == s[j])j++;
//        p[i] = j;
//    }
//    return p;
//}
//
//vector<ll> zf(string &s) {
//    ll n = s.length();
//    vector<ll> z(n);
//    ll l = 0;
//
//    ll r = 0;
//    for (int i = 1; i < n; i++) {
//        z[i] = i > r ? 0 : min(z[i - l], r - i + 1);
//        while (z[i] + i < n && s[z[i]] == s[z[i] + i]) {
//            z[i]++;
//        }
//        if (z[i] + i - 1 > r) {
//            l = i;
//            r = z[i] + i - 1;
//        }
//    }
//    return z;
//}
//const ll MAXN = 1e5;
//struct vertex{
//    map<char,int> next;
//    bool target=false;
//    bool realtarget = false;
//    int parent=0;
//    int suf_link = 0;
//};
//struct aho_korasik{
//
//    int sz;
//    vector<vertex> vert;
//    aho_korasik(){
//        vert.resize(MAXN);
//        sz = 2;
//        for(int i = CHAR_MIN; i <=CHAR_MAX;i ++){
//            vert[0].next[i]=1;
//        }
//    }
//    void add_str(const string& s){
//        if(s.empty())return;
//        int v = 1;
//        for(int i = 0 ; i < s.length() ; i ++){
//            if(vert[v].next.find(vert[v].next[s[i]]) == vert[v].next.end()){
//                vert[sz].parent = v;
//                vert[v].next[s[i]] = sz;
//                sz++;
//            }
//            v = vert[v].next[s[i]] ;
//        }
//        vert[v].realtarget = true;
//        vert[v].target = true;
//    }
//    void build_suf_links(){
//        queue<int> q;
//        q.push(1);
//        while(!q.empty()){
//            ll v = q.front();
//            q.pop();
//            if(vert[vert[v].suf_link].target){
//                vert[v].target = true;
//            }
//            for(auto &e : vert[v].next){
//                q.push(e.second);
//                int p = vert[v].suf_link;
//                while(vert[p].next.find(e.first) == vert[p].next.end()){
//                    p = vert[p].suf_link;
//                }
//                vert[e.second].suf_link = vert[p].next[e.first];
//
//            }
//        }
//    }
//};

//const ll MAXN = 4e5 + 100;
//vector<pair<ll, ll>> t;
//vector<ll> d;
//
//void push(ll v, ll vl, ll vr) {
//    if (d[v] != -1) {
//        if (vl == vr) {
//            t[v].second = t[v].first = 0;
//        } else {
//            d[2 * v + 1] = d[2 * v + 2] = d[v];
//            t[v].second = t[v].first = 0;
//        }
//        d[v] = -1;
//    }
//}
//pair<ll,ll> get(ll v, ll vl, ll vr ,ll l , ll r){
//    if(l>r)return{0,0};
//    push(v, vl, vr);
//    if (vr < l || vl > r) {
//        return{0,0};
//    }
//    if (l <= vl && vr <= r) {
//        return t[v];
//    }
//    ll m = (vl + vr) / 2;
//    auto f = get(2 * v + 1, vl, m, l, r);
//    auto s = get(2 * v + 2, m + 1, vr, l, r);
//    return {f.first+s.first,s.second+f.second};
//}
//void del(ll v, ll vl, ll vr, ll l, ll r) {
//    if(l>r)return;
//    push(v, vl, vr);
//    if (vr < l || vl > r) {
//        return;
//    }
//    if (l <= vl && vr <= r) {
//        d[v] = 0;
//        push(v, vl, vr);
//        return;
//    }
//    ll m = (vl + vr) / 2;
//    del(2 * v + 1, vl, m, l, r);
//    del(2 * v + 2, m + 1, vr, l, r);
//    t[v].second = t[2 * v + 1].second + t[2 * v + 2].second;
//    t[v].first = t[2 * v + 1].first + t[2 * v + 2].first;
//}
//
//void add(ll v, ll vl, ll vr, ll pos, ll val, ll am) {
//    push(v, vl, vr);
//    if (vl == vr) {
//        t[v].second += val;
//        t[v].first += am;
//        return;
//    }
//    ll m = (vl + vr) / 2;
//    if (pos <= m) {
//        add(2 * v + 1, vl, m, pos, val,am);
//    } else {
//        add(2 * v + 2, m + 1, vr, pos, val,am);
//    }
//    push(2*v+1,vl,m);
//    push(2*v+2,m+1,vr);
//    t[v].second = t[2 * v + 1].second + t[2 * v + 2].second;
//    t[v].first = t[2 * v + 1].first + t[2 * v + 2].first;
//}
//ll am_grans(string s){
//    ll n = s.length();
//    ll answer =0 ;
//    for(int i = 1 ; i < n; i ++){
//        if(s.substr(0,i) == s.substr(n-i,i)){
//            answer++;
//        }
//    }
//    return answer;
//}
int main() {
//    freopen("D:/CLionProjects/strings.txt","r",stdin);
//    freopen("D:/CLionProjects/res2.txt","w",stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    ll t;
    cin>>t;
    while(t--){
        ll n;
        cin>>n;
        vector<ll> arr(n);
        cin>>arr;
        sort(all(arr));
        vector<ll> res(n);
        for(int i =0 ; i < n/2; i ++){
            res[2*i] = arr[n-1-i];
            res[2*i+1] = arr[i];
        }
        reverse(all(res));
        cout<<res<<"\n";

    }
    return 0;
}


#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <cmath>
#include <string>
#include <queue>
#include <iomanip>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <complex>
#include <stack>
#include <fstream>

#define null nullptr
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()

using namespace std;
typedef int64_t ll;
typedef double long dl;
typedef uint64_t ull;
//const dl EPS = 1e-6;
//////
//struct wor {
//    dl x = 0, y = 0;
//};
//
////
//dl dist(wor a, wor b) {
//    dl answer = sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
//    return answer;
//}

//
////
//wor intersect(wor a, wor b, wor c) {
//    if (b.x - a.x == 0) {
//        return {b.x, c.y};
//    }
//    if (b.y - a.y == 0) {
//        return {c.x, b.y};
//    }
//    wor A;
//    A.x = b.x - a.x;
//    A.y = b.y - a.y;
//    dl C = A.x * c.x + A.y * c.y;
//
//    wor answer;
//    dl C1 = -A.x * a.y + A.y * a.x;
//    answer.y = (C1 - A.y * C / A.x) / (-A.x - A.y * A.y / A.x);
//    answer.x = (C - A.y * answer.y) / A.x;
//
//    return answer;
//}
//
////
//ll vec(wor a, wor b) {
//    return a.x * b.y - a.y * b.x;
//}
//
//ll scal(wor &a, wor &b) {
//    return a.x * b.x + a.y * b.y;
//}

//
//bool rely(wor a, wor b, wor c) {
//    return min(a.x, b.x) < c.x + 1e-8 && c.x < max(b.x, a.x) + 1e-8 && min(a.y, b.y) < c.y + 1e-8 &&
//           c.y < max(b.y, a.y) + 1e-8;
//}
//
////
//wor operator-(wor a, wor b) {
//    wor res;
//    res.x = a.x - b.x;
//    res.y = a.y - b.y;
//    return res;
//}
//
//wor operator+(wor a, wor b) {
//    wor res;
//    res.x = a.x + b.x;
//    res.y = a.y + b.y;
//    return res;
//}
//
//wor operator/(wor a, dl b) {
//    wor res;
//    res.x = a.x / b;
//    res.y = a.y / b;
//    return res;
//}
//
//void operator/=(wor &a, dl b) {
//    a.x /= b;
//    a.y /= b;
//}
//
////
//bool is_in(vector<wor> &pol, wor c) {
//    for (int i = 1; i <= pol.size(); i++) {
//        wor a = pol[i % pol.size()] - pol[i - 1];
//        if (vec(a, c - pol[i - 1]) < 0) {
//            return false;
//        }
//    }
//    return true;
//}
//
//bool suit(vector<wor> &pol, wor c, dl length) {
//    for (int i = 1; i <= pol.size(); i++) {
//        auto inter = intersect(pol[i % pol.size()], pol[i - 1], c);
//        if (rely(pol[i % pol.size()], pol[i - 1], inter)) {
//            if (dist(inter, c) < length + 1e-8)return true;
//        }
//        if (dist(pol[i % pol.size()], c) < length + 1e-8) {
//            return true;
//        }
//        if (dist(pol[i - 1], c) < length + 1e-8) {
//            return true;
//        }
//    }
//    return false;
//}
//

//ll find(ll v, vector<ll> &parent) {
//    if (parent[v] == v) {
//        return v;
//    }
//    return parent[v] = find(parent[v], parent);
//}
//
//void merge(ll a, ll b, vector<ll> &parent, vector<ll> &size, vector<ll> &mi, vector<ll> &ma) {
//
//    if (size[a] > size[b]) {
//        parent[b] = a;
//        size[a] += size[b];
//        mi[a] = min(mi[a], mi[b]);
//        ma[a] = max(ma[a], ma[b]);
//    } else {
//        parent[a] = b;
//        size[b] += size[a];
//        mi[b] = min(mi[b], mi[a]);
//        ma[b] = max(ma[b], ma[a]);
//    }
//}
//dl func(dl x, dl h,dl l){
//    dl k = l - sqrt(x*x+h*h);
//    return x*k/sqrt(x*x+h*h);
//}
//void retro(ll node,vector<ll> &parent,vector<bool> &win,vector<bool> &loose,vector<ll> &am,vector<bool> &used){
//    used[node]=true;
//    if(node==0 || used[parent[node]])return;
//    if(loose[node]){
//        loose[parent[node]]=true;
//        retro(parent[node],parent,win,loose,am,used);
//    }else if(win[node]){
//        am[parent[node]]--;
//        if(am[parent[node]]==0){
//            win[parent[node]]=true;
//            retro(parent[node],parent,win,loose,am,used);
//        }
//    }
//}
//wor beg;
//
//bool comp(wor &a, wor &b) {
//    wor k = a - beg;
//    wor z = b - beg;
//    if (vec(k, z) == 0) {
//        return k.x * k.x + k.y * k.y < z.x * z.x + z.y * z.y;
//    }
//    return vec(k, z) > 0;
//}
//
//vector<wor> get_hull(vector<wor> arr) {
//    ll mi = 0;
//    for (int i = 1; i < arr.size(); i++) {
//        if (arr[i].x < arr[mi].x) {
//            mi = i;
//        } else if (arr[i].x == arr[mi].x && arr[i].y < arr[mi].y) {
//            mi = i;
//        }
//    }
//    swap(arr[0], arr[mi]);
//    beg = arr[0];
//    sort(arr.begin() + 1, arr.end(), comp);
//    vector<wor> answer;
//    answer.push_back(arr[0]);
//    answer.push_back(arr[1]);
//    for (int i = 2; i < arr.size(); i++) {
//        wor temp = arr[i] - answer.back();
//        wor temp1 = arr[i] - answer[answer.size() - 2];
//        while (answer.size() >= 2 && vec(temp1, temp) <= 0) {
//            answer.pop_back();
//            if (answer.size() == 1)break;
//            temp = arr[i] - answer.back();
//            temp1 = arr[i] - answer[answer.size() - 2];
//        }
//        answer.push_back(arr[i]);
//    }
//    return answer;
//}
//dl deg(wor &a, wor &b,wor &c){
//    wor k = a-b;
//    wor z = c-b;
//    return acos((k.x*z.x + k.y*z.y)/(dist(a,b)*dist(b,c)));
//}
//const dl PI = acos(-1);
//bool comp(ll a, ll b){
//    return sin(a)>sin(b);
//}

//bool byXbyY(wor a, wor b) {
//    if (a.x == b.x) {
//        return a.y < b.y;
//    }
//    return a.x < b.x;
//}
//const dl PI = acos(-1);
//
//dl get_x(dl a, dl b, dl h, dl d) {
//    if (h <= d) {
//        return b - a;
//    }
//    return (b - a) / h * d;
//}
//
//struct sq {
//    vector<wor> data;
//};
//
//sq build(wor a, wor b) {
//    wor c = b - a;
//    wor n;
//    n.x = -c.y;
//    n.y = c.x;
//    n /= 2;
//    wor center = a + (c / 2);
//    sq res;
//    res.data.push_back(a);
//    res.data.push_back(center - n);
//    res.data.push_back(b);
//    res.data.push_back(center + n);
//    return res;
//}
//
//dl dist_to_sq(wor p, sq s) {
//    if (is_in(s.data, p)) {
//        return 0;
//    }
//    dl answer = 1e16;
//    for (auto e : s.data) {
//        answer = min(answer, dist(p, e));
//    }
//    for (int i = 1; i <= s.data.size(); i++) {
//        auto inter = intersect(s.data[i % s.data.size()], s.data[i - 1], p);
//        if (rely(s.data[i % s.data.size()], s.data[i - 1], inter)) {
//            answer = min(answer, dist(p, inter));
//        }
//    }
//    return answer;
//}
//

//
//
//bool is_prime(ll p) {
//    for (ll i = 2; i * i <= p; i++) {
//        if (p % i == 0)return false;
//    }
//    return true;
//}
//
vector<pair<ll,ll>> canon(ll p) {
    vector<pair<ll,ll>> answer;
    for (ll i = 2; i * i <= p; i++) {
        if (p % i == 0) {
            ll k =0;
            while (p % i == 0) {
                p /= i;
                k++;
            }
            answer.push_back({i,k});
        }
    }
    if (p > 1)answer.push_back({p,1});
    return answer;
}
//

template<typename T, typename R>
istream &operator>>(istream &is, pair<T, R> &a) {
    is >> a.first >> a.second;
    return is;
}

template<typename T, typename R>
ostream &operator<<(ostream &os, pair<T, R> &a) {
    os << a.first << " " << a.second;
    return os;
}

template<typename T>
ostream &operator<<(ostream &os, vector<T> &a) {
    for (auto e : a) {
        os << e << " ";
    }
    return os;
}

template<typename T>
istream &operator>>(istream &is, vector<T> &a) {
    for (auto &e:a) {
        is >> e;
    }
    return is;
}

//ll bin_pow(ll a, ll b, ll mod){
//    ll res = 1;
//    while(b){
//        if(b&1){
//            res*=a;
//            res%=mod;
//        }
//        a*=a;
//        a%=mod;
//        b>>=1;
//    }
//    return res;
//}
//void count_sort(vector<ll> &p, vector<ll> &c) {
//    ll n = p.size();
//    vector<ll> am(n);
//    for (auto e : c) {
//        am[e]++;
//    }
//    vector<ll> pos(n);
//    vector<ll> res_p(n);
//    pos[0] = 0;
//    for (int i = 1; i < n; i++) {
//        pos[i] = pos[i - 1] + am[i - 1];
//    }
//    for (auto e : p) {
//        res_p[pos[c[e]]] = e;
//        pos[c[e]]++;
//    }
//    p.swap(res_p);
//}

//pair<vector<ll>, vector<ll>> suf_arr(string &s) {
//    s += " ";
//    ll n = s.length();
//    vector<ll> p(n), c(n);
//    {
//        vector<pair<char, ll>> arr(n);
//        for (int i = 0; i < n; i++)arr[i] = {s[i], i};
//        sort(all(arr));
//        for (int i = 0; i < n; i++)p[i] = arr[i].second;
//        c[p[0]] = 0;
//        for (int i = 1; i < n; i++) {
//            if (arr[i].first == arr[i - 1].first) {
//                c[p[i]] = c[p[i - 1]];
//            } else {
//                c[p[i]] = c[p[i - 1]] + 1;
//            }
//        }
//    }
//    ll k = 0;
//    while ((1ll << k) < n) {
//        for (int i = 0; i < n; i++) {
//            p[i] = (p[i] + n - (1ll << k)) % n;
//        }
//        count_sort(p, c);
//        vector<ll> c_new(n);
//        c_new[p[0]] = 0;
//        for (int i = 1; i < n; i++) {
//            pair<ll, ll> now = {c[p[i]], c[(p[i] + (1ll << k)) % n]};
//            pair<ll, ll> was = {c[p[i - 1]], c[(p[i - 1] + (1ll << k)) % n]};
//            if (was == now) {
//                c_new[p[i]] = c_new[p[i - 1]];
//            } else {
//                c_new[p[i]] = c_new[p[i - 1]] + 1;
//            }
//        }
//        c.swap(c_new);
//        k++;
//    }
//    vector<ll> lcp(n);
//    k = 0;
//    for (int i = 0; i < n - 1; i++) {
//        ll pid = c[i];
//        ll prev = p[pid - 1];
//        while (s[i + k] == s[prev + k]) {
//            k++;
//        }
//        lcp[pid] = k;
//        k = max(0ll, k - 1);
//    }
//    return {p, lcp};
//}
//void count_sort(vector<ll> &p, vector<ll> &c) {
//    ll n = p.size();
//    vector<ll> am(n);
//    for (auto e : c) {
//        am[e]++;
//    }
//    vector<ll> pos(n);
//    vector<ll> p_res(n);
//    pos[0] = 0;
//    for (int i = 1; i < n; i++) {
//        pos[i] = pos[i - 1] + am[i - 1];
//    }
//    for (auto e : p) {
//        p_res[pos[c[e]]] = e;
//        pos[c[e]]++;
//    }
//    p.swap(p_res);
//}
//
//pair<vector<ll>, vector<ll>> suf_arr(string &s) {
//    s += "$";
//    ll n = s.length();
//    vector<ll> p(n), c(n);
//    {
//        vector<pair<char, ll>> arr(n);
//        for (int i = 0; i < n; i++)arr[i] = {s[i], i};
//        sort(all(arr));
//        for (int i = 0; i < n; i++) {
//            p[i] = arr[i].second;
//        }
//        c[p[0]] = 0;
//        for (int i = 1; i < n; i++) {
//            if (arr[i].first == arr[i - 1].first) {
//                c[p[i]] = c[p[i - 1]];
//            } else {
//                c[p[i]] = c[p[i - 1]] + 1;
//            }
//        }
//    }
//    ll k = 0;
//    while ((1 << k) < n) {
//        for (int i = 0; i < n; i++) {
//            p[i] = (p[i] - (1 << k) + n) % n;
//        }
//        count_sort(p, c);
//        vector<ll> c_new(n);
//        c_new[p[0]] = 0;
//        for (int i = 1; i < n; i++) {
//            pair<ll, ll> was = {c[p[i - 1]], c[(p[i - 1] + (1 << k)) % n]};
//            pair<ll, ll> now = {c[p[i]], c[(p[i] + (1 << k)) % n]};
//            if (now == was) {
//                c_new[p[i]] = c_new[p[i - 1]];
//            } else {
//                c_new[p[i]] = c_new[p[i - 1]] + 1;
//            }
//        }
//        c.swap(c_new);
//        k++;
//    }
//    vector<ll> lcp(n);
//    k = 0;
//    for (int i = 0; i < n - 1; i++) {
//        ll id = c[i];
//        ll pid = p[id - 1];
//        while (s[i + k] == s[pid + k]) {
//            k++;
//        }
//        lcp[id] = k;
//        k = max(0ll, k - 1);
//    }
//    return {p, lcp};
//}
//const ll mod = 998244353;
//ll len = (mod-1)&(-(mod-1));
//ll LOG_gl = 23;
//ll base_gl = 31;
//vector<ll> bit_rev(ll n, ll log){
//    vector<ll> rev(n);
//    ll k = 0 ;
//    for(ll i =1 ; i < n; i ++){
//        rev[i]  = rev[i^(1ll<<k)] ^ (1ll<<(log-k-1));
//        if(!((i+1)&(i)))k++;
//    }
//    return rev;
//}
//vector<ll> get_w(ll n,ll log){
//    ll base = bin_pow(base_gl,(1ll<<(LOG_gl - log)),mod);
//    vector<ll> w(n);
//    w[0] =1;
//    for(int i = 1; i < n ; i ++){
//        w[i] = (w[i-1] * base)%mod;
//    }
//    return w;
//}
//ll w(ll pow, ll base, vector<ll> &ws, ll N){
//    return ws[pow*N/base];
//}
//void butterfly(ll &a, ll &b, ll w){
//    ll x = (a +b*w%mod)%mod;
//    ll y = (a + mod - b*w%mod)%mod;
//    a = x;
//    b = y;
//}
//vector<ll> fft(vector<ll> &a,ll n, ll LOG , bool back){
//    const ll nrev = bin_pow(n,mod-2,mod);
//    auto rev = bit_rev(n,LOG);
//    vector<ll> temp =a;
//    for(int i = 0 ; i < n; i ++){
//        temp[rev[i]] = a[i];
//    }
//    a.swap(temp);
//    auto ws = get_w(n,LOG);
//    for(ll dl = 1; dl < n; (dl <<=1)){
//        for(int i = 0 ; i < n ; i +=2*dl){
//            for(ll k = 0 ; k < dl ; k ++){
//                butterfly(a[i+k], a[i+dl + k], w(k,2*dl,ws,n));
//            }
//        }
//    }
//    if(back){
//        for(int i = 0 ; i < n; i ++){
//            (a[i] *=nrev)%=mod;
//        }
//        reverse(a.begin()+1,a.end());
//    }
//    return a;
//}
//vector<ll> mult(vector<ll> &a,vector<ll> &b){
//    ll n = a.size() + b.size();
//    while(n&(n-1)){
//        n++;
//    }
//    a.resize(n);
//    b.resize(n);
//    ll t = 0 , temp_c = n;
//    while(temp_c > 1){
//        t++;
//        temp_c>>=1;
//    }
//    a = fft(a,n,t,false);
//    b = fft(b,n,t,false);
//    for(int i = 0 ; i < n ; i ++){
//        (a[i]*=b[i])%=mod;
//    }
//    return fft(a,n,t,true);
//}

//pair<vector<ll>, vector<ll>> manaker(string &s) {
//    ll n = s.length();
//    ll l = 0;
//    ll r = -1;
//    vector<ll> d1(n);
//    for (int i = 0; i < n; i++) {
//        ll k = i > r ? 1 : min(d1[l + r - i], r - i + 1);
//        while (i + k < n && i - k >= 0 && s[i + k] == s[i - k]) {
//            k++;
//        }
//        d1[i] = k;
//        if (i + k - 1 > r) {
//            r = i + k - 1;
//            l = i - k + 1;
//        }
//    }
//
//    vector<ll> d2(n);
//    l = 0;
//    r = -1;
//    for (int i = 0; i < n; i++) {
//        ll k = i > r ? 0 : min(d2[l + r - i + 1], r - i + 1);
//        while (i + k < n && i - k - 1 >= 0 && s[i + k] == s[i - k - 1]) {
//            k++;
//        }
//        d2[i] = k;
//        if (i + k - 1 > r) {
//            r = i + k - 1;
//            l = i - k;
//        }
//    }
//    return {d1, d2};
//}
//
//vector<ll> pref(string &s) {
//    ll n = s.length();
//    vector<ll> p(n);
//    p[0] = 0;
//    for (int i = 1; i < n; i++) {
//        ll j = p[i - 1];
//        while (j > 0 && s[j] != s[i]) {
//            j = p[j - 1];
//        }
//        if (s[i] == s[j])j++;
//        p[i] = j;
//    }
//    return p;
//}
//
//vector<ll> zf(string &s) {
//    ll n = s.length();
//    vector<ll> z(n);
//    ll l = 0;
//
//    ll r = 0;
//    for (int i = 1; i < n; i++) {
//        z[i] = i > r ? 0 : min(z[i - l], r - i + 1);
//        while (z[i] + i < n && s[z[i]] == s[z[i] + i]) {
//            z[i]++;
//        }
//        if (z[i] + i - 1 > r) {
//            l = i;
//            r = z[i] + i - 1;
//        }
//    }
//    return z;
//}
//const ll MAXN = 1e5;
//struct vertex{
//    map<char,int> next;
//    bool target=false;
//    bool realtarget = false;
//    int parent=0;
//    int suf_link = 0;
//};
//struct aho_korasik{
//
//    int sz;
//    vector<vertex> vert;
//    aho_korasik(){
//        vert.resize(MAXN);
//        sz = 2;
//        for(int i = CHAR_MIN; i <=CHAR_MAX;i ++){
//            vert[0].next[i]=1;
//        }
//    }
//    void add_str(const string& s){
//        if(s.empty())return;
//        int v = 1;
//        for(int i = 0 ; i < s.length() ; i ++){
//            if(vert[v].next.find(vert[v].next[s[i]]) == vert[v].next.end()){
//                vert[sz].parent = v;
//                vert[v].next[s[i]] = sz;
//                sz++;
//            }
//            v = vert[v].next[s[i]] ;
//        }
//        vert[v].realtarget = true;
//        vert[v].target = true;
//    }
//    void build_suf_links(){
//        queue<int> q;
//        q.push(1);
//        while(!q.empty()){
//            ll v = q.front();
//            q.pop();
//            if(vert[vert[v].suf_link].target){
//                vert[v].target = true;
//            }
//            for(auto &e : vert[v].next){
//                q.push(e.second);
//                int p = vert[v].suf_link;
//                while(vert[p].next.find(e.first) == vert[p].next.end()){
//                    p = vert[p].suf_link;
//                }
//                vert[e.second].suf_link = vert[p].next[e.first];
//
//            }
//        }
//    }
//};

//const ll MAXN = 4e5 + 100;
//vector<pair<ll, ll>> t;
//vector<ll> d;
//
//void push(ll v, ll vl, ll vr) {
//    if (d[v] != -1) {
//        if (vl == vr) {
//            t[v].second = t[v].first = 0;
//        } else {
//            d[2 * v + 1] = d[2 * v + 2] = d[v];
//            t[v].second = t[v].first = 0;
//        }
//        d[v] = -1;
//    }
//}
//pair<ll,ll> get(ll v, ll vl, ll vr ,ll l , ll r){
//    if(l>r)return{0,0};
//    push(v, vl, vr);
//    if (vr < l || vl > r) {
//        return{0,0};
//    }
//    if (l <= vl && vr <= r) {
//        return t[v];
//    }
//    ll m = (vl + vr) / 2;
//    auto f = get(2 * v + 1, vl, m, l, r);
//    auto s = get(2 * v + 2, m + 1, vr, l, r);
//    return {f.first+s.first,s.second+f.second};
//}
//void del(ll v, ll vl, ll vr, ll l, ll r) {
//    if(l>r)return;
//    push(v, vl, vr);
//    if (vr < l || vl > r) {
//        return;
//    }
//    if (l <= vl && vr <= r) {
//        d[v] = 0;
//        push(v, vl, vr);
//        return;
//    }
//    ll m = (vl + vr) / 2;
//    del(2 * v + 1, vl, m, l, r);
//    del(2 * v + 2, m + 1, vr, l, r);
//    t[v].second = t[2 * v + 1].second + t[2 * v + 2].second;
//    t[v].first = t[2 * v + 1].first + t[2 * v + 2].first;
//}
//
//void add(ll v, ll vl, ll vr, ll pos, ll val, ll am) {
//    push(v, vl, vr);
//    if (vl == vr) {
//        t[v].second += val;
//        t[v].first += am;
//        return;
//    }
//    ll m = (vl + vr) / 2;
//    if (pos <= m) {
//        add(2 * v + 1, vl, m, pos, val,am);
//    } else {
//        add(2 * v + 2, m + 1, vr, pos, val,am);
//    }
//    push(2*v+1,vl,m);
//    push(2*v+2,m+1,vr);
//    t[v].second = t[2 * v + 1].second + t[2 * v + 2].second;
//    t[v].first = t[2 * v + 1].first + t[2 * v + 2].first;
//}
//ll am_grans(string s){
//    ll n = s.length();
//    ll answer =0 ;
//    for(int i = 1 ; i < n; i ++){
//        if(s.substr(0,i) == s.substr(n-i,i)){
//            answer++;
//        }
//    }
//    return answer;
//}
int main() {
//    freopen("D:/CLionProjects/strings.txt","r",stdin);
//    freopen("D:/CLionProjects/res2.txt","w",stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    ll t;
    cin>>t;
    while(t--){
        ll n;
        cin>>n;
        vector<ll> arr(n);
        cin>>arr;
        if(n == 1){
            cout<<arr<<"\n";
            continue;
        }
        sort(all(arr));
        vector<ll> res(n);
        for(int i =0 ; i < n/2; i ++){
            res[2*i] = arr[n-1-i];
            res[2*i+1] = arr[i];
        }
        if(n&1){
            res[n-1] = arr[(n+1)/2];
        }
        reverse(all(res));
        bool b = false;
        for(int i = 2; i < n &&!b; i ++){
            if(abs(res[i]-res[i-1]) < abs(res[i-1]-res[i-2])){
                b = true;
            }
        }
        if(b){
            if(n&1){
                for(int i = 1; i < n-1; i +=2) {
                    swap(res[i],res[i+1]);
                }
                cout<<res<<"\n";
            }else{
                for(int i =0 ; i < n-1; i +=2){
                    swap(res[i],res[i+1]);
                }
                cout<<res<<"\n";
            }

        }else{
            cout<<res<<"\n";
        }

    }
    return 0;
}


#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <cmath>
#include <string>
#include <queue>
#include <iomanip>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <complex>
#include <stack>
#include <fstream>

#define null nullptr
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()

using namespace std;
typedef int64_t ll;
typedef double long dl;
typedef uint64_t ull;
//const dl EPS = 1e-6;
//////
//struct wor {
//    dl x = 0, y = 0;
//};
//
////
//dl dist(wor a, wor b) {
//    dl answer = sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
//    return answer;
//}

//
////
//wor intersect(wor a, wor b, wor c) {
//    if (b.x - a.x == 0) {
//        return {b.x, c.y};
//    }
//    if (b.y - a.y == 0) {
//        return {c.x, b.y};
//    }
//    wor A;
//    A.x = b.x - a.x;
//    A.y = b.y - a.y;
//    dl C = A.x * c.x + A.y * c.y;
//
//    wor answer;
//    dl C1 = -A.x * a.y + A.y * a.x;
//    answer.y = (C1 - A.y * C / A.x) / (-A.x - A.y * A.y / A.x);
//    answer.x = (C - A.y * answer.y) / A.x;
//
//    return answer;
//}
//
////
//ll vec(wor a, wor b) {
//    return a.x * b.y - a.y * b.x;
//}
//
//ll scal(wor &a, wor &b) {
//    return a.x * b.x + a.y * b.y;
//}

//
//bool rely(wor a, wor b, wor c) {
//    return min(a.x, b.x) < c.x + 1e-8 && c.x < max(b.x, a.x) + 1e-8 && min(a.y, b.y) < c.y + 1e-8 &&
//           c.y < max(b.y, a.y) + 1e-8;
//}
//
////
//wor operator-(wor a, wor b) {
//    wor res;
//    res.x = a.x - b.x;
//    res.y = a.y - b.y;
//    return res;
//}
//
//wor operator+(wor a, wor b) {
//    wor res;
//    res.x = a.x + b.x;
//    res.y = a.y + b.y;
//    return res;
//}
//
//wor operator/(wor a, dl b) {
//    wor res;
//    res.x = a.x / b;
//    res.y = a.y / b;
//    return res;
//}
//
//void operator/=(wor &a, dl b) {
//    a.x /= b;
//    a.y /= b;
//}
//
////
//bool is_in(vector<wor> &pol, wor c) {
//    for (int i = 1; i <= pol.size(); i++) {
//        wor a = pol[i % pol.size()] - pol[i - 1];
//        if (vec(a, c - pol[i - 1]) < 0) {
//            return false;
//        }
//    }
//    return true;
//}
//
//bool suit(vector<wor> &pol, wor c, dl length) {
//    for (int i = 1; i <= pol.size(); i++) {
//        auto inter = intersect(pol[i % pol.size()], pol[i - 1], c);
//        if (rely(pol[i % pol.size()], pol[i - 1], inter)) {
//            if (dist(inter, c) < length + 1e-8)return true;
//        }
//        if (dist(pol[i % pol.size()], c) < length + 1e-8) {
//            return true;
//        }
//        if (dist(pol[i - 1], c) < length + 1e-8) {
//            return true;
//        }
//    }
//    return false;
//}
//

//ll find(ll v, vector<ll> &parent) {
//    if (parent[v] == v) {
//        return v;
//    }
//    return parent[v] = find(parent[v], parent);
//}
//
//void merge(ll a, ll b, vector<ll> &parent, vector<ll> &size, vector<ll> &mi, vector<ll> &ma) {
//
//    if (size[a] > size[b]) {
//        parent[b] = a;
//        size[a] += size[b];
//        mi[a] = min(mi[a], mi[b]);
//        ma[a] = max(ma[a], ma[b]);
//    } else {
//        parent[a] = b;
//        size[b] += size[a];
//        mi[b] = min(mi[b], mi[a]);
//        ma[b] = max(ma[b], ma[a]);
//    }
//}
//dl func(dl x, dl h,dl l){
//    dl k = l - sqrt(x*x+h*h);
//    return x*k/sqrt(x*x+h*h);
//}
//void retro(ll node,vector<ll> &parent,vector<bool> &win,vector<bool> &loose,vector<ll> &am,vector<bool> &used){
//    used[node]=true;
//    if(node==0 || used[parent[node]])return;
//    if(loose[node]){
//        loose[parent[node]]=true;
//        retro(parent[node],parent,win,loose,am,used);
//    }else if(win[node]){
//        am[parent[node]]--;
//        if(am[parent[node]]==0){
//            win[parent[node]]=true;
//            retro(parent[node],parent,win,loose,am,used);
//        }
//    }
//}
//wor beg;
//
//bool comp(wor &a, wor &b) {
//    wor k = a - beg;
//    wor z = b - beg;
//    if (vec(k, z) == 0) {
//        return k.x * k.x + k.y * k.y < z.x * z.x + z.y * z.y;
//    }
//    return vec(k, z) > 0;
//}
//
//vector<wor> get_hull(vector<wor> arr) {
//    ll mi = 0;
//    for (int i = 1; i < arr.size(); i++) {
//        if (arr[i].x < arr[mi].x) {
//            mi = i;
//        } else if (arr[i].x == arr[mi].x && arr[i].y < arr[mi].y) {
//            mi = i;
//        }
//    }
//    swap(arr[0], arr[mi]);
//    beg = arr[0];
//    sort(arr.begin() + 1, arr.end(), comp);
//    vector<wor> answer;
//    answer.push_back(arr[0]);
//    answer.push_back(arr[1]);
//    for (int i = 2; i < arr.size(); i++) {
//        wor temp = arr[i] - answer.back();
//        wor temp1 = arr[i] - answer[answer.size() - 2];
//        while (answer.size() >= 2 && vec(temp1, temp) <= 0) {
//            answer.pop_back();
//            if (answer.size() == 1)break;
//            temp = arr[i] - answer.back();
//            temp1 = arr[i] - answer[answer.size() - 2];
//        }
//        answer.push_back(arr[i]);
//    }
//    return answer;
//}
//dl deg(wor &a, wor &b,wor &c){
//    wor k = a-b;
//    wor z = c-b;
//    return acos((k.x*z.x + k.y*z.y)/(dist(a,b)*dist(b,c)));
//}
//const dl PI = acos(-1);
//bool comp(ll a, ll b){
//    return sin(a)>sin(b);
//}

//bool byXbyY(wor a, wor b) {
//    if (a.x == b.x) {
//        return a.y < b.y;
//    }
//    return a.x < b.x;
//}
//const dl PI = acos(-1);
//
//dl get_x(dl a, dl b, dl h, dl d) {
//    if (h <= d) {
//        return b - a;
//    }
//    return (b - a) / h * d;
//}
//
//struct sq {
//    vector<wor> data;
//};
//
//sq build(wor a, wor b) {
//    wor c = b - a;
//    wor n;
//    n.x = -c.y;
//    n.y = c.x;
//    n /= 2;
//    wor center = a + (c / 2);
//    sq res;
//    res.data.push_back(a);
//    res.data.push_back(center - n);
//    res.data.push_back(b);
//    res.data.push_back(center + n);
//    return res;
//}
//
//dl dist_to_sq(wor p, sq s) {
//    if (is_in(s.data, p)) {
//        return 0;
//    }
//    dl answer = 1e16;
//    for (auto e : s.data) {
//        answer = min(answer, dist(p, e));
//    }
//    for (int i = 1; i <= s.data.size(); i++) {
//        auto inter = intersect(s.data[i % s.data.size()], s.data[i - 1], p);
//        if (rely(s.data[i % s.data.size()], s.data[i - 1], inter)) {
//            answer = min(answer, dist(p, inter));
//        }
//    }
//    return answer;
//}
//

//
//
//bool is_prime(ll p) {
//    for (ll i = 2; i * i <= p; i++) {
//        if (p % i == 0)return false;
//    }
//    return true;
//}
//
vector<pair<ll,ll>> canon(ll p) {
    vector<pair<ll,ll>> answer;
    for (ll i = 2; i * i <= p; i++) {
        if (p % i == 0) {
            ll k =0;
            while (p % i == 0) {
                p /= i;
                k++;
            }
            answer.push_back({i,k});
        }
    }
    if (p > 1)answer.push_back({p,1});
    return answer;
}
//

template<typename T, typename R>
istream &operator>>(istream &is, pair<T, R> &a) {
    is >> a.first >> a.second;
    return is;
}

template<typename T, typename R>
ostream &operator<<(ostream &os, pair<T, R> &a) {
    os << a.first << " " << a.second;
    return os;
}

template<typename T>
ostream &operator<<(ostream &os, vector<T> &a) {
    for (auto e : a) {
        os << e << " ";
    }
    return os;
}

template<typename T>
istream &operator>>(istream &is, vector<T> &a) {
    for (auto &e:a) {
        is >> e;
    }
    return is;
}

//ll bin_pow(ll a, ll b, ll mod){
//    ll res = 1;
//    while(b){
//        if(b&1){
//            res*=a;
//            res%=mod;
//        }
//        a*=a;
//        a%=mod;
//        b>>=1;
//    }
//    return res;
//}
//void count_sort(vector<ll> &p, vector<ll> &c) {
//    ll n = p.size();
//    vector<ll> am(n);
//    for (auto e : c) {
//        am[e]++;
//    }
//    vector<ll> pos(n);
//    vector<ll> res_p(n);
//    pos[0] = 0;
//    for (int i = 1; i < n; i++) {
//        pos[i] = pos[i - 1] + am[i - 1];
//    }
//    for (auto e : p) {
//        res_p[pos[c[e]]] = e;
//        pos[c[e]]++;
//    }
//    p.swap(res_p);
//}

//pair<vector<ll>, vector<ll>> suf_arr(string &s) {
//    s += " ";
//    ll n = s.length();
//    vector<ll> p(n), c(n);
//    {
//        vector<pair<char, ll>> arr(n);
//        for (int i = 0; i < n; i++)arr[i] = {s[i], i};
//        sort(all(arr));
//        for (int i = 0; i < n; i++)p[i] = arr[i].second;
//        c[p[0]] = 0;
//        for (int i = 1; i < n; i++) {
//            if (arr[i].first == arr[i - 1].first) {
//                c[p[i]] = c[p[i - 1]];
//            } else {
//                c[p[i]] = c[p[i - 1]] + 1;
//            }
//        }
//    }
//    ll k = 0;
//    while ((1ll << k) < n) {
//        for (int i = 0; i < n; i++) {
//            p[i] = (p[i] + n - (1ll << k)) % n;
//        }
//        count_sort(p, c);
//        vector<ll> c_new(n);
//        c_new[p[0]] = 0;
//        for (int i = 1; i < n; i++) {
//            pair<ll, ll> now = {c[p[i]], c[(p[i] + (1ll << k)) % n]};
//            pair<ll, ll> was = {c[p[i - 1]], c[(p[i - 1] + (1ll << k)) % n]};
//            if (was == now) {
//                c_new[p[i]] = c_new[p[i - 1]];
//            } else {
//                c_new[p[i]] = c_new[p[i - 1]] + 1;
//            }
//        }
//        c.swap(c_new);
//        k++;
//    }
//    vector<ll> lcp(n);
//    k = 0;
//    for (int i = 0; i < n - 1; i++) {
//        ll pid = c[i];
//        ll prev = p[pid - 1];
//        while (s[i + k] == s[prev + k]) {
//            k++;
//        }
//        lcp[pid] = k;
//        k = max(0ll, k - 1);
//    }
//    return {p, lcp};
//}
//void count_sort(vector<ll> &p, vector<ll> &c) {
//    ll n = p.size();
//    vector<ll> am(n);
//    for (auto e : c) {
//        am[e]++;
//    }
//    vector<ll> pos(n);
//    vector<ll> p_res(n);
//    pos[0] = 0;
//    for (int i = 1; i < n; i++) {
//        pos[i] = pos[i - 1] + am[i - 1];
//    }
//    for (auto e : p) {
//        p_res[pos[c[e]]] = e;
//        pos[c[e]]++;
//    }
//    p.swap(p_res);
//}
//
//pair<vector<ll>, vector<ll>> suf_arr(string &s) {
//    s += "$";
//    ll n = s.length();
//    vector<ll> p(n), c(n);
//    {
//        vector<pair<char, ll>> arr(n);
//        for (int i = 0; i < n; i++)arr[i] = {s[i], i};
//        sort(all(arr));
//        for (int i = 0; i < n; i++) {
//            p[i] = arr[i].second;
//        }
//        c[p[0]] = 0;
//        for (int i = 1; i < n; i++) {
//            if (arr[i].first == arr[i - 1].first) {
//                c[p[i]] = c[p[i - 1]];
//            } else {
//                c[p[i]] = c[p[i - 1]] + 1;
//            }
//        }
//    }
//    ll k = 0;
//    while ((1 << k) < n) {
//        for (int i = 0; i < n; i++) {
//            p[i] = (p[i] - (1 << k) + n) % n;
//        }
//        count_sort(p, c);
//        vector<ll> c_new(n);
//        c_new[p[0]] = 0;
//        for (int i = 1; i < n; i++) {
//            pair<ll, ll> was = {c[p[i - 1]], c[(p[i - 1] + (1 << k)) % n]};
//            pair<ll, ll> now = {c[p[i]], c[(p[i] + (1 << k)) % n]};
//            if (now == was) {
//                c_new[p[i]] = c_new[p[i - 1]];
//            } else {
//                c_new[p[i]] = c_new[p[i - 1]] + 1;
//            }
//        }
//        c.swap(c_new);
//        k++;
//    }
//    vector<ll> lcp(n);
//    k = 0;
//    for (int i = 0; i < n - 1; i++) {
//        ll id = c[i];
//        ll pid = p[id - 1];
//        while (s[i + k] == s[pid + k]) {
//            k++;
//        }
//        lcp[id] = k;
//        k = max(0ll, k - 1);
//    }
//    return {p, lcp};
//}
//const ll mod = 998244353;
//ll len = (mod-1)&(-(mod-1));
//ll LOG_gl = 23;
//ll base_gl = 31;
//vector<ll> bit_rev(ll n, ll log){
//    vector<ll> rev(n);
//    ll k = 0 ;
//    for(ll i =1 ; i < n; i ++){
//        rev[i]  = rev[i^(1ll<<k)] ^ (1ll<<(log-k-1));
//        if(!((i+1)&(i)))k++;
//    }
//    return rev;
//}
//vector<ll> get_w(ll n,ll log){
//    ll base = bin_pow(base_gl,(1ll<<(LOG_gl - log)),mod);
//    vector<ll> w(n);
//    w[0] =1;
//    for(int i = 1; i < n ; i ++){
//        w[i] = (w[i-1] * base)%mod;
//    }
//    return w;
//}
//ll w(ll pow, ll base, vector<ll> &ws, ll N){
//    return ws[pow*N/base];
//}
//void butterfly(ll &a, ll &b, ll w){
//    ll x = (a +b*w%mod)%mod;
//    ll y = (a + mod - b*w%mod)%mod;
//    a = x;
//    b = y;
//}
//vector<ll> fft(vector<ll> &a,ll n, ll LOG , bool back){
//    const ll nrev = bin_pow(n,mod-2,mod);
//    auto rev = bit_rev(n,LOG);
//    vector<ll> temp =a;
//    for(int i = 0 ; i < n; i ++){
//        temp[rev[i]] = a[i];
//    }
//    a.swap(temp);
//    auto ws = get_w(n,LOG);
//    for(ll dl = 1; dl < n; (dl <<=1)){
//        for(int i = 0 ; i < n ; i +=2*dl){
//            for(ll k = 0 ; k < dl ; k ++){
//                butterfly(a[i+k], a[i+dl + k], w(k,2*dl,ws,n));
//            }
//        }
//    }
//    if(back){
//        for(int i = 0 ; i < n; i ++){
//            (a[i] *=nrev)%=mod;
//        }
//        reverse(a.begin()+1,a.end());
//    }
//    return a;
//}
//vector<ll> mult(vector<ll> &a,vector<ll> &b){
//    ll n = a.size() + b.size();
//    while(n&(n-1)){
//        n++;
//    }
//    a.resize(n);
//    b.resize(n);
//    ll t = 0 , temp_c = n;
//    while(temp_c > 1){
//        t++;
//        temp_c>>=1;
//    }
//    a = fft(a,n,t,false);
//    b = fft(b,n,t,false);
//    for(int i = 0 ; i < n ; i ++){
//        (a[i]*=b[i])%=mod;
//    }
//    return fft(a,n,t,true);
//}

//pair<vector<ll>, vector<ll>> manaker(string &s) {
//    ll n = s.length();
//    ll l = 0;
//    ll r = -1;
//    vector<ll> d1(n);
//    for (int i = 0; i < n; i++) {
//        ll k = i > r ? 1 : min(d1[l + r - i], r - i + 1);
//        while (i + k < n && i - k >= 0 && s[i + k] == s[i - k]) {
//            k++;
//        }
//        d1[i] = k;
//        if (i + k - 1 > r) {
//            r = i + k - 1;
//            l = i - k + 1;
//        }
//    }
//
//    vector<ll> d2(n);
//    l = 0;
//    r = -1;
//    for (int i = 0; i < n; i++) {
//        ll k = i > r ? 0 : min(d2[l + r - i + 1], r - i + 1);
//        while (i + k < n && i - k - 1 >= 0 && s[i + k] == s[i - k - 1]) {
//            k++;
//        }
//        d2[i] = k;
//        if (i + k - 1 > r) {
//            r = i + k - 1;
//            l = i - k;
//        }
//    }
//    return {d1, d2};
//}
//
//vector<ll> pref(string &s) {
//    ll n = s.length();
//    vector<ll> p(n);
//    p[0] = 0;
//    for (int i = 1; i < n; i++) {
//        ll j = p[i - 1];
//        while (j > 0 && s[j] != s[i]) {
//            j = p[j - 1];
//        }
//        if (s[i] == s[j])j++;
//        p[i] = j;
//    }
//    return p;
//}
//
//vector<ll> zf(string &s) {
//    ll n = s.length();
//    vector<ll> z(n);
//    ll l = 0;
//
//    ll r = 0;
//    for (int i = 1; i < n; i++) {
//        z[i] = i > r ? 0 : min(z[i - l], r - i + 1);
//        while (z[i] + i < n && s[z[i]] == s[z[i] + i]) {
//            z[i]++;
//        }
//        if (z[i] + i - 1 > r) {
//            l = i;
//            r = z[i] + i - 1;
//        }
//    }
//    return z;
//}
//const ll MAXN = 1e5;
//struct vertex{
//    map<char,int> next;
//    bool target=false;
//    bool realtarget = false;
//    int parent=0;
//    int suf_link = 0;
//};
//struct aho_korasik{
//
//    int sz;
//    vector<vertex> vert;
//    aho_korasik(){
//        vert.resize(MAXN);
//        sz = 2;
//        for(int i = CHAR_MIN; i <=CHAR_MAX;i ++){
//            vert[0].next[i]=1;
//        }
//    }
//    void add_str(const string& s){
//        if(s.empty())return;
//        int v = 1;
//        for(int i = 0 ; i < s.length() ; i ++){
//            if(vert[v].next.find(vert[v].next[s[i]]) == vert[v].next.end()){
//                vert[sz].parent = v;
//                vert[v].next[s[i]] = sz;
//                sz++;
//            }
//            v = vert[v].next[s[i]] ;
//        }
//        vert[v].realtarget = true;
//        vert[v].target = true;
//    }
//    void build_suf_links(){
//        queue<int> q;
//        q.push(1);
//        while(!q.empty()){
//            ll v = q.front();
//            q.pop();
//            if(vert[vert[v].suf_link].target){
//                vert[v].target = true;
//            }
//            for(auto &e : vert[v].next){
//                q.push(e.second);
//                int p = vert[v].suf_link;
//                while(vert[p].next.find(e.first) == vert[p].next.end()){
//                    p = vert[p].suf_link;
//                }
//                vert[e.second].suf_link = vert[p].next[e.first];
//
//            }
//        }
//    }
//};

//const ll MAXN = 4e5 + 100;
//vector<pair<ll, ll>> t;
//vector<ll> d;
//
//void push(ll v, ll vl, ll vr) {
//    if (d[v] != -1) {
//        if (vl == vr) {
//            t[v].second = t[v].first = 0;
//        } else {
//            d[2 * v + 1] = d[2 * v + 2] = d[v];
//            t[v].second = t[v].first = 0;
//        }
//        d[v] = -1;
//    }
//}
//pair<ll,ll> get(ll v, ll vl, ll vr ,ll l , ll r){
//    if(l>r)return{0,0};
//    push(v, vl, vr);
//    if (vr < l || vl > r) {
//        return{0,0};
//    }
//    if (l <= vl && vr <= r) {
//        return t[v];
//    }
//    ll m = (vl + vr) / 2;
//    auto f = get(2 * v + 1, vl, m, l, r);
//    auto s = get(2 * v + 2, m + 1, vr, l, r);
//    return {f.first+s.first,s.second+f.second};
//}
//void del(ll v, ll vl, ll vr, ll l, ll r) {
//    if(l>r)return;
//    push(v, vl, vr);
//    if (vr < l || vl > r) {
//        return;
//    }
//    if (l <= vl && vr <= r) {
//        d[v] = 0;
//        push(v, vl, vr);
//        return;
//    }
//    ll m = (vl + vr) / 2;
//    del(2 * v + 1, vl, m, l, r);
//    del(2 * v + 2, m + 1, vr, l, r);
//    t[v].second = t[2 * v + 1].second + t[2 * v + 2].second;
//    t[v].first = t[2 * v + 1].first + t[2 * v + 2].first;
//}
//
//void add(ll v, ll vl, ll vr, ll pos, ll val, ll am) {
//    push(v, vl, vr);
//    if (vl == vr) {
//        t[v].second += val;
//        t[v].first += am;
//        return;
//    }
//    ll m = (vl + vr) / 2;
//    if (pos <= m) {
//        add(2 * v + 1, vl, m, pos, val,am);
//    } else {
//        add(2 * v + 2, m + 1, vr, pos, val,am);
//    }
//    push(2*v+1,vl,m);
//    push(2*v+2,m+1,vr);
//    t[v].second = t[2 * v + 1].second + t[2 * v + 2].second;
//    t[v].first = t[2 * v + 1].first + t[2 * v + 2].first;
//}
//ll am_grans(string s){
//    ll n = s.length();
//    ll answer =0 ;
//    for(int i = 1 ; i < n; i ++){
//        if(s.substr(0,i) == s.substr(n-i,i)){
//            answer++;
//        }
//    }
//    return answer;
//}
int main() {
//    freopen("D:/CLionProjects/strings.txt","r",stdin);
//    freopen("D:/CLionProjects/res2.txt","w",stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    ll t;
    cin>>t;
    while(t--){
        ll n;
        cin>>n;
        vector<ll> arr(n);
        cin>>arr;
        if(n == 1){
            cout<<arr<<"\n";
            continue;
        }
        sort(all(arr));
        vector<ll> res(n);
        for(int i =0 ; i < n/2; i ++){
            res[2*i] = arr[n-1-i];
            res[2*i+1] = arr[i];
        }
        if(n&1){
            res[n-1] = arr[(n+1)/2];
        }
        reverse(all(res));
        bool b = false;
        for(int i = 2; i < n &&!b; i ++){
            if(abs(res[i]-res[i-1]) < abs(res[i-1]-res[i-2])){
                b = true;
            }
        }
        if(b){
            if(n&1){
                for(int i = 1; i < n-1; i +=2) {
                    swap(res[i],res[i+1]);
                }
                for(int i= 1 ; i < n; i ++){
                    cout<<res[i]<<" ";
                }
                cout<<res[0]<<"\n";
                continue;
            }else{
                for(int i =0 ; i < n-1; i +=2){
                    swap(res[i],res[i+1]);
                }
                cout<<res<<"\n";
            }

        }else{
            cout<<res<<"\n";
        }

    }
    return 0;
}


#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <cmath>
#include <string>
#include <queue>
#include <iomanip>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <complex>
#include <stack>
#include <fstream>

#define null nullptr
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()

using namespace std;
typedef int64_t ll;
typedef double long dl;
typedef uint64_t ull;
//const dl EPS = 1e-6;
//////
//struct wor {
//    dl x = 0, y = 0;
//};
//
////
//dl dist(wor a, wor b) {
//    dl answer = sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
//    return answer;
//}

//
////
//wor intersect(wor a, wor b, wor c) {
//    if (b.x - a.x == 0) {
//        return {b.x, c.y};
//    }
//    if (b.y - a.y == 0) {
//        return {c.x, b.y};
//    }
//    wor A;
//    A.x = b.x - a.x;
//    A.y = b.y - a.y;
//    dl C = A.x * c.x + A.y * c.y;
//
//    wor answer;
//    dl C1 = -A.x * a.y + A.y * a.x;
//    answer.y = (C1 - A.y * C / A.x) / (-A.x - A.y * A.y / A.x);
//    answer.x = (C - A.y * answer.y) / A.x;
//
//    return answer;
//}
//
////
//ll vec(wor a, wor b) {
//    return a.x * b.y - a.y * b.x;
//}
//
//ll scal(wor &a, wor &b) {
//    return a.x * b.x + a.y * b.y;
//}

//
//bool rely(wor a, wor b, wor c) {
//    return min(a.x, b.x) < c.x + 1e-8 && c.x < max(b.x, a.x) + 1e-8 && min(a.y, b.y) < c.y + 1e-8 &&
//           c.y < max(b.y, a.y) + 1e-8;
//}
//
////
//wor operator-(wor a, wor b) {
//    wor res;
//    res.x = a.x - b.x;
//    res.y = a.y - b.y;
//    return res;
//}
//
//wor operator+(wor a, wor b) {
//    wor res;
//    res.x = a.x + b.x;
//    res.y = a.y + b.y;
//    return res;
//}
//
//wor operator/(wor a, dl b) {
//    wor res;
//    res.x = a.x / b;
//    res.y = a.y / b;
//    return res;
//}
//
//void operator/=(wor &a, dl b) {
//    a.x /= b;
//    a.y /= b;
//}
//
////
//bool is_in(vector<wor> &pol, wor c) {
//    for (int i = 1; i <= pol.size(); i++) {
//        wor a = pol[i % pol.size()] - pol[i - 1];
//        if (vec(a, c - pol[i - 1]) < 0) {
//            return false;
//        }
//    }
//    return true;
//}
//
//bool suit(vector<wor> &pol, wor c, dl length) {
//    for (int i = 1; i <= pol.size(); i++) {
//        auto inter = intersect(pol[i % pol.size()], pol[i - 1], c);
//        if (rely(pol[i % pol.size()], pol[i - 1], inter)) {
//            if (dist(inter, c) < length + 1e-8)return true;
//        }
//        if (dist(pol[i % pol.size()], c) < length + 1e-8) {
//            return true;
//        }
//        if (dist(pol[i - 1], c) < length + 1e-8) {
//            return true;
//        }
//    }
//    return false;
//}
//

//ll find(ll v, vector<ll> &parent) {
//    if (parent[v] == v) {
//        return v;
//    }
//    return parent[v] = find(parent[v], parent);
//}
//
//void merge(ll a, ll b, vector<ll> &parent, vector<ll> &size, vector<ll> &mi, vector<ll> &ma) {
//
//    if (size[a] > size[b]) {
//        parent[b] = a;
//        size[a] += size[b];
//        mi[a] = min(mi[a], mi[b]);
//        ma[a] = max(ma[a], ma[b]);
//    } else {
//        parent[a] = b;
//        size[b] += size[a];
//        mi[b] = min(mi[b], mi[a]);
//        ma[b] = max(ma[b], ma[a]);
//    }
//}
//dl func(dl x, dl h,dl l){
//    dl k = l - sqrt(x*x+h*h);
//    return x*k/sqrt(x*x+h*h);
//}
//void retro(ll node,vector<ll> &parent,vector<bool> &win,vector<bool> &loose,vector<ll> &am,vector<bool> &used){
//    used[node]=true;
//    if(node==0 || used[parent[node]])return;
//    if(loose[node]){
//        loose[parent[node]]=true;
//        retro(parent[node],parent,win,loose,am,used);
//    }else if(win[node]){
//        am[parent[node]]--;
//        if(am[parent[node]]==0){
//            win[parent[node]]=true;
//            retro(parent[node],parent,win,loose,am,used);
//        }
//    }
//}
//wor beg;
//
//bool comp(wor &a, wor &b) {
//    wor k = a - beg;
//    wor z = b - beg;
//    if (vec(k, z) == 0) {
//        return k.x * k.x + k.y * k.y < z.x * z.x + z.y * z.y;
//    }
//    return vec(k, z) > 0;
//}
//
//vector<wor> get_hull(vector<wor> arr) {
//    ll mi = 0;
//    for (int i = 1; i < arr.size(); i++) {
//        if (arr[i].x < arr[mi].x) {
//            mi = i;
//        } else if (arr[i].x == arr[mi].x && arr[i].y < arr[mi].y) {
//            mi = i;
//        }
//    }
//    swap(arr[0], arr[mi]);
//    beg = arr[0];
//    sort(arr.begin() + 1, arr.end(), comp);
//    vector<wor> answer;
//    answer.push_back(arr[0]);
//    answer.push_back(arr[1]);
//    for (int i = 2; i < arr.size(); i++) {
//        wor temp = arr[i] - answer.back();
//        wor temp1 = arr[i] - answer[answer.size() - 2];
//        while (answer.size() >= 2 && vec(temp1, temp) <= 0) {
//            answer.pop_back();
//            if (answer.size() == 1)break;
//            temp = arr[i] - answer.back();
//            temp1 = arr[i] - answer[answer.size() - 2];
//        }
//        answer.push_back(arr[i]);
//    }
//    return answer;
//}
//dl deg(wor &a, wor &b,wor &c){
//    wor k = a-b;
//    wor z = c-b;
//    return acos((k.x*z.x + k.y*z.y)/(dist(a,b)*dist(b,c)));
//}
//const dl PI = acos(-1);
//bool comp(ll a, ll b){
//    return sin(a)>sin(b);
//}

//bool byXbyY(wor a, wor b) {
//    if (a.x == b.x) {
//        return a.y < b.y;
//    }
//    return a.x < b.x;
//}
//const dl PI = acos(-1);
//
//dl get_x(dl a, dl b, dl h, dl d) {
//    if (h <= d) {
//        return b - a;
//    }
//    return (b - a) / h * d;
//}
//
//struct sq {
//    vector<wor> data;
//};
//
//sq build(wor a, wor b) {
//    wor c = b - a;
//    wor n;
//    n.x = -c.y;
//    n.y = c.x;
//    n /= 2;
//    wor center = a + (c / 2);
//    sq res;
//    res.data.push_back(a);
//    res.data.push_back(center - n);
//    res.data.push_back(b);
//    res.data.push_back(center + n);
//    return res;
//}
//
//dl dist_to_sq(wor p, sq s) {
//    if (is_in(s.data, p)) {
//        return 0;
//    }
//    dl answer = 1e16;
//    for (auto e : s.data) {
//        answer = min(answer, dist(p, e));
//    }
//    for (int i = 1; i <= s.data.size(); i++) {
//        auto inter = intersect(s.data[i % s.data.size()], s.data[i - 1], p);
//        if (rely(s.data[i % s.data.size()], s.data[i - 1], inter)) {
//            answer = min(answer, dist(p, inter));
//        }
//    }
//    return answer;
//}
//

//
//
//bool is_prime(ll p) {
//    for (ll i = 2; i * i <= p; i++) {
//        if (p % i == 0)return false;
//    }
//    return true;
//}
//
vector<pair<ll,ll>> canon(ll p) {
    vector<pair<ll,ll>> answer;
    for (ll i = 2; i * i <= p; i++) {
        if (p % i == 0) {
            ll k =0;
            while (p % i == 0) {
                p /= i;
                k++;
            }
            answer.push_back({i,k});
        }
    }
    if (p > 1)answer.push_back({p,1});
    return answer;
}
//

template<typename T, typename R>
istream &operator>>(istream &is, pair<T, R> &a) {
    is >> a.first >> a.second;
    return is;
}

template<typename T, typename R>
ostream &operator<<(ostream &os, pair<T, R> &a) {
    os << a.first << " " << a.second;
    return os;
}

template<typename T>
ostream &operator<<(ostream &os, vector<T> &a) {
    for (auto e : a) {
        os << e << " ";
    }
    return os;
}

template<typename T>
istream &operator>>(istream &is, vector<T> &a) {
    for (auto &e:a) {
        is >> e;
    }
    return is;
}

//ll bin_pow(ll a, ll b, ll mod){
//    ll res = 1;
//    while(b){
//        if(b&1){
//            res*=a;
//            res%=mod;
//        }
//        a*=a;
//        a%=mod;
//        b>>=1;
//    }
//    return res;
//}
//void count_sort(vector<ll> &p, vector<ll> &c) {
//    ll n = p.size();
//    vector<ll> am(n);
//    for (auto e : c) {
//        am[e]++;
//    }
//    vector<ll> pos(n);
//    vector<ll> res_p(n);
//    pos[0] = 0;
//    for (int i = 1; i < n; i++) {
//        pos[i] = pos[i - 1] + am[i - 1];
//    }
//    for (auto e : p) {
//        res_p[pos[c[e]]] = e;
//        pos[c[e]]++;
//    }
//    p.swap(res_p);
//}

//pair<vector<ll>, vector<ll>> suf_arr(string &s) {
//    s += " ";
//    ll n = s.length();
//    vector<ll> p(n), c(n);
//    {
//        vector<pair<char, ll>> arr(n);
//        for (int i = 0; i < n; i++)arr[i] = {s[i], i};
//        sort(all(arr));
//        for (int i = 0; i < n; i++)p[i] = arr[i].second;
//        c[p[0]] = 0;
//        for (int i = 1; i < n; i++) {
//            if (arr[i].first == arr[i - 1].first) {
//                c[p[i]] = c[p[i - 1]];
//            } else {
//                c[p[i]] = c[p[i - 1]] + 1;
//            }
//        }
//    }
//    ll k = 0;
//    while ((1ll << k) < n) {
//        for (int i = 0; i < n; i++) {
//            p[i] = (p[i] + n - (1ll << k)) % n;
//        }
//        count_sort(p, c);
//        vector<ll> c_new(n);
//        c_new[p[0]] = 0;
//        for (int i = 1; i < n; i++) {
//            pair<ll, ll> now = {c[p[i]], c[(p[i] + (1ll << k)) % n]};
//            pair<ll, ll> was = {c[p[i - 1]], c[(p[i - 1] + (1ll << k)) % n]};
//            if (was == now) {
//                c_new[p[i]] = c_new[p[i - 1]];
//            } else {
//                c_new[p[i]] = c_new[p[i - 1]] + 1;
//            }
//        }
//        c.swap(c_new);
//        k++;
//    }
//    vector<ll> lcp(n);
//    k = 0;
//    for (int i = 0; i < n - 1; i++) {
//        ll pid = c[i];
//        ll prev = p[pid - 1];
//        while (s[i + k] == s[prev + k]) {
//            k++;
//        }
//        lcp[pid] = k;
//        k = max(0ll, k - 1);
//    }
//    return {p, lcp};
//}
//void count_sort(vector<ll> &p, vector<ll> &c) {
//    ll n = p.size();
//    vector<ll> am(n);
//    for (auto e : c) {
//        am[e]++;
//    }
//    vector<ll> pos(n);
//    vector<ll> p_res(n);
//    pos[0] = 0;
//    for (int i = 1; i < n; i++) {
//        pos[i] = pos[i - 1] + am[i - 1];
//    }
//    for (auto e : p) {
//        p_res[pos[c[e]]] = e;
//        pos[c[e]]++;
//    }
//    p.swap(p_res);
//}
//
//pair<vector<ll>, vector<ll>> suf_arr(string &s) {
//    s += "$";
//    ll n = s.length();
//    vector<ll> p(n), c(n);
//    {
//        vector<pair<char, ll>> arr(n);
//        for (int i = 0; i < n; i++)arr[i] = {s[i], i};
//        sort(all(arr));
//        for (int i = 0; i < n; i++) {
//            p[i] = arr[i].second;
//        }
//        c[p[0]] = 0;
//        for (int i = 1; i < n; i++) {
//            if (arr[i].first == arr[i - 1].first) {
//                c[p[i]] = c[p[i - 1]];
//            } else {
//                c[p[i]] = c[p[i - 1]] + 1;
//            }
//        }
//    }
//    ll k = 0;
//    while ((1 << k) < n) {
//        for (int i = 0; i < n; i++) {
//            p[i] = (p[i] - (1 << k) + n) % n;
//        }
//        count_sort(p, c);
//        vector<ll> c_new(n);
//        c_new[p[0]] = 0;
//        for (int i = 1; i < n; i++) {
//            pair<ll, ll> was = {c[p[i - 1]], c[(p[i - 1] + (1 << k)) % n]};
//            pair<ll, ll> now = {c[p[i]], c[(p[i] + (1 << k)) % n]};
//            if (now == was) {
//                c_new[p[i]] = c_new[p[i - 1]];
//            } else {
//                c_new[p[i]] = c_new[p[i - 1]] + 1;
//            }
//        }
//        c.swap(c_new);
//        k++;
//    }
//    vector<ll> lcp(n);
//    k = 0;
//    for (int i = 0; i < n - 1; i++) {
//        ll id = c[i];
//        ll pid = p[id - 1];
//        while (s[i + k] == s[pid + k]) {
//            k++;
//        }
//        lcp[id] = k;
//        k = max(0ll, k - 1);
//    }
//    return {p, lcp};
//}
//const ll mod = 998244353;
//ll len = (mod-1)&(-(mod-1));
//ll LOG_gl = 23;
//ll base_gl = 31;
//vector<ll> bit_rev(ll n, ll log){
//    vector<ll> rev(n);
//    ll k = 0 ;
//    for(ll i =1 ; i < n; i ++){
//        rev[i]  = rev[i^(1ll<<k)] ^ (1ll<<(log-k-1));
//        if(!((i+1)&(i)))k++;
//    }
//    return rev;
//}
//vector<ll> get_w(ll n,ll log){
//    ll base = bin_pow(base_gl,(1ll<<(LOG_gl - log)),mod);
//    vector<ll> w(n);
//    w[0] =1;
//    for(int i = 1; i < n ; i ++){
//        w[i] = (w[i-1] * base)%mod;
//    }
//    return w;
//}
//ll w(ll pow, ll base, vector<ll> &ws, ll N){
//    return ws[pow*N/base];
//}
//void butterfly(ll &a, ll &b, ll w){
//    ll x = (a +b*w%mod)%mod;
//    ll y = (a + mod - b*w%mod)%mod;
//    a = x;
//    b = y;
//}
//vector<ll> fft(vector<ll> &a,ll n, ll LOG , bool back){
//    const ll nrev = bin_pow(n,mod-2,mod);
//    auto rev = bit_rev(n,LOG);
//    vector<ll> temp =a;
//    for(int i = 0 ; i < n; i ++){
//        temp[rev[i]] = a[i];
//    }
//    a.swap(temp);
//    auto ws = get_w(n,LOG);
//    for(ll dl = 1; dl < n; (dl <<=1)){
//        for(int i = 0 ; i < n ; i +=2*dl){
//            for(ll k = 0 ; k < dl ; k ++){
//                butterfly(a[i+k], a[i+dl + k], w(k,2*dl,ws,n));
//            }
//        }
//    }
//    if(back){
//        for(int i = 0 ; i < n; i ++){
//            (a[i] *=nrev)%=mod;
//        }
//        reverse(a.begin()+1,a.end());
//    }
//    return a;
//}
//vector<ll> mult(vector<ll> &a,vector<ll> &b){
//    ll n = a.size() + b.size();
//    while(n&(n-1)){
//        n++;
//    }
//    a.resize(n);
//    b.resize(n);
//    ll t = 0 , temp_c = n;
//    while(temp_c > 1){
//        t++;
//        temp_c>>=1;
//    }
//    a = fft(a,n,t,false);
//    b = fft(b,n,t,false);
//    for(int i = 0 ; i < n ; i ++){
//        (a[i]*=b[i])%=mod;
//    }
//    return fft(a,n,t,true);
//}

//pair<vector<ll>, vector<ll>> manaker(string &s) {
//    ll n = s.length();
//    ll l = 0;
//    ll r = -1;
//    vector<ll> d1(n);
//    for (int i = 0; i < n; i++) {
//        ll k = i > r ? 1 : min(d1[l + r - i], r - i + 1);
//        while (i + k < n && i - k >= 0 && s[i + k] == s[i - k]) {
//            k++;
//        }
//        d1[i] = k;
//        if (i + k - 1 > r) {
//            r = i + k - 1;
//            l = i - k + 1;
//        }
//    }
//
//    vector<ll> d2(n);
//    l = 0;
//    r = -1;
//    for (int i = 0; i < n; i++) {
//        ll k = i > r ? 0 : min(d2[l + r - i + 1], r - i + 1);
//        while (i + k < n && i - k - 1 >= 0 && s[i + k] == s[i - k - 1]) {
//            k++;
//        }
//        d2[i] = k;
//        if (i + k - 1 > r) {
//            r = i + k - 1;
//            l = i - k;
//        }
//    }
//    return {d1, d2};
//}
//
//vector<ll> pref(string &s) {
//    ll n = s.length();
//    vector<ll> p(n);
//    p[0] = 0;
//    for (int i = 1; i < n; i++) {
//        ll j = p[i - 1];
//        while (j > 0 && s[j] != s[i]) {
//            j = p[j - 1];
//        }
//        if (s[i] == s[j])j++;
//        p[i] = j;
//    }
//    return p;
//}
//
//vector<ll> zf(string &s) {
//    ll n = s.length();
//    vector<ll> z(n);
//    ll l = 0;
//
//    ll r = 0;
//    for (int i = 1; i < n; i++) {
//        z[i] = i > r ? 0 : min(z[i - l], r - i + 1);
//        while (z[i] + i < n && s[z[i]] == s[z[i] + i]) {
//            z[i]++;
//        }
//        if (z[i] + i - 1 > r) {
//            l = i;
//            r = z[i] + i - 1;
//        }
//    }
//    return z;
//}
//const ll MAXN = 1e5;
//struct vertex{
//    map<char,int> next;
//    bool target=false;
//    bool realtarget = false;
//    int parent=0;
//    int suf_link = 0;
//};
//struct aho_korasik{
//
//    int sz;
//    vector<vertex> vert;
//    aho_korasik(){
//        vert.resize(MAXN);
//        sz = 2;
//        for(int i = CHAR_MIN; i <=CHAR_MAX;i ++){
//            vert[0].next[i]=1;
//        }
//    }
//    void add_str(const string& s){
//        if(s.empty())return;
//        int v = 1;
//        for(int i = 0 ; i < s.length() ; i ++){
//            if(vert[v].next.find(vert[v].next[s[i]]) == vert[v].next.end()){
//                vert[sz].parent = v;
//                vert[v].next[s[i]] = sz;
//                sz++;
//            }
//            v = vert[v].next[s[i]] ;
//        }
//        vert[v].realtarget = true;
//        vert[v].target = true;
//    }
//    void build_suf_links(){
//        queue<int> q;
//        q.push(1);
//        while(!q.empty()){
//            ll v = q.front();
//            q.pop();
//            if(vert[vert[v].suf_link].target){
//                vert[v].target = true;
//            }
//            for(auto &e : vert[v].next){
//                q.push(e.second);
//                int p = vert[v].suf_link;
//                while(vert[p].next.find(e.first) == vert[p].next.end()){
//                    p = vert[p].suf_link;
//                }
//                vert[e.second].suf_link = vert[p].next[e.first];
//
//            }
//        }
//    }
//};

//const ll MAXN = 4e5 + 100;
//vector<pair<ll, ll>> t;
//vector<ll> d;
//
//void push(ll v, ll vl, ll vr) {
//    if (d[v] != -1) {
//        if (vl == vr) {
//            t[v].second = t[v].first = 0;
//        } else {
//            d[2 * v + 1] = d[2 * v + 2] = d[v];
//            t[v].second = t[v].first = 0;
//        }
//        d[v] = -1;
//    }
//}
//pair<ll,ll> get(ll v, ll vl, ll vr ,ll l , ll r){
//    if(l>r)return{0,0};
//    push(v, vl, vr);
//    if (vr < l || vl > r) {
//        return{0,0};
//    }
//    if (l <= vl && vr <= r) {
//        return t[v];
//    }
//    ll m = (vl + vr) / 2;
//    auto f = get(2 * v + 1, vl, m, l, r);
//    auto s = get(2 * v + 2, m + 1, vr, l, r);
//    return {f.first+s.first,s.second+f.second};
//}
//void del(ll v, ll vl, ll vr, ll l, ll r) {
//    if(l>r)return;
//    push(v, vl, vr);
//    if (vr < l || vl > r) {
//        return;
//    }
//    if (l <= vl && vr <= r) {
//        d[v] = 0;
//        push(v, vl, vr);
//        return;
//    }
//    ll m = (vl + vr) / 2;
//    del(2 * v + 1, vl, m, l, r);
//    del(2 * v + 2, m + 1, vr, l, r);
//    t[v].second = t[2 * v + 1].second + t[2 * v + 2].second;
//    t[v].first = t[2 * v + 1].first + t[2 * v + 2].first;
//}
//
//void add(ll v, ll vl, ll vr, ll pos, ll val, ll am) {
//    push(v, vl, vr);
//    if (vl == vr) {
//        t[v].second += val;
//        t[v].first += am;
//        return;
//    }
//    ll m = (vl + vr) / 2;
//    if (pos <= m) {
//        add(2 * v + 1, vl, m, pos, val,am);
//    } else {
//        add(2 * v + 2, m + 1, vr, pos, val,am);
//    }
//    push(2*v+1,vl,m);
//    push(2*v+2,m+1,vr);
//    t[v].second = t[2 * v + 1].second + t[2 * v + 2].second;
//    t[v].first = t[2 * v + 1].first + t[2 * v + 2].first;
//}
//ll am_grans(string s){
//    ll n = s.length();
//    ll answer =0 ;
//    for(int i = 1 ; i < n; i ++){
//        if(s.substr(0,i) == s.substr(n-i,i)){
//            answer++;
//        }
//    }
//    return answer;
//}
int main() {
//    freopen("D:/CLionProjects/strings.txt","r",stdin);
//    freopen("D:/CLionProjects/res2.txt","w",stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    ll t;
    cin>>t;
    while(t--){
        ll n;
        cin>>n;
        vector<ll> arr(n);
        cin>>arr;
        if(n == 1){
            cout<<arr<<"\n";
            continue;
        }
        sort(all(arr));
        vector<ll> res(n);
        for(int i =0 ; i < n/2; i ++){
            res[2*i] = arr[n-1-i];
            res[2*i+1] = arr[i];
        }
        if(n&1){
            res[n-1] = arr[(n+1)/2];
        }
        reverse(all(res));
        bool b = false;
        for(int i = 2; i < n &&!b; i ++){
            if(abs(res[i]-res[i-1]) < abs(res[i-1]-res[i-2])){
                b = true;
            }
        }
        if(b){
            vector<ll> res(n);
            for(int i =0 ; i < n/2; i ++){
                res[2*i] = arr[i];
                res[2*i+1] = arr[n-1-i];
            }
            if(n&1){
                res[n-1] = arr[(n+1)/2];
            }
            reverse(all(res));
            cout<<res<<"\n";
        }else{
            cout<<res<<"\n";
        }

    }
    return 0;
}


#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <cmath>
#include <string>
#include <queue>
#include <iomanip>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <complex>
#include <stack>
#include <fstream>

#define null nullptr
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()

using namespace std;
typedef int64_t ll;
typedef double long dl;
typedef uint64_t ull;
//const dl EPS = 1e-6;
//////
//struct wor {
//    dl x = 0, y = 0;
//};
//
////
//dl dist(wor a, wor b) {
//    dl answer = sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
//    return answer;
//}

//
////
//wor intersect(wor a, wor b, wor c) {
//    if (b.x - a.x == 0) {
//        return {b.x, c.y};
//    }
//    if (b.y - a.y == 0) {
//        return {c.x, b.y};
//    }
//    wor A;
//    A.x = b.x - a.x;
//    A.y = b.y - a.y;
//    dl C = A.x * c.x + A.y * c.y;
//
//    wor answer;
//    dl C1 = -A.x * a.y + A.y * a.x;
//    answer.y = (C1 - A.y * C / A.x) / (-A.x - A.y * A.y / A.x);
//    answer.x = (C - A.y * answer.y) / A.x;
//
//    return answer;
//}
//
////
//ll vec(wor a, wor b) {
//    return a.x * b.y - a.y * b.x;
//}
//
//ll scal(wor &a, wor &b) {
//    return a.x * b.x + a.y * b.y;
//}

//
//bool rely(wor a, wor b, wor c) {
//    return min(a.x, b.x) < c.x + 1e-8 && c.x < max(b.x, a.x) + 1e-8 && min(a.y, b.y) < c.y + 1e-8 &&
//           c.y < max(b.y, a.y) + 1e-8;
//}
//
////
//wor operator-(wor a, wor b) {
//    wor res;
//    res.x = a.x - b.x;
//    res.y = a.y - b.y;
//    return res;
//}
//
//wor operator+(wor a, wor b) {
//    wor res;
//    res.x = a.x + b.x;
//    res.y = a.y + b.y;
//    return res;
//}
//
//wor operator/(wor a, dl b) {
//    wor res;
//    res.x = a.x / b;
//    res.y = a.y / b;
//    return res;
//}
//
//void operator/=(wor &a, dl b) {
//    a.x /= b;
//    a.y /= b;
//}
//
////
//bool is_in(vector<wor> &pol, wor c) {
//    for (int i = 1; i <= pol.size(); i++) {
//        wor a = pol[i % pol.size()] - pol[i - 1];
//        if (vec(a, c - pol[i - 1]) < 0) {
//            return false;
//        }
//    }
//    return true;
//}
//
//bool suit(vector<wor> &pol, wor c, dl length) {
//    for (int i = 1; i <= pol.size(); i++) {
//        auto inter = intersect(pol[i % pol.size()], pol[i - 1], c);
//        if (rely(pol[i % pol.size()], pol[i - 1], inter)) {
//            if (dist(inter, c) < length + 1e-8)return true;
//        }
//        if (dist(pol[i % pol.size()], c) < length + 1e-8) {
//            return true;
//        }
//        if (dist(pol[i - 1], c) < length + 1e-8) {
//            return true;
//        }
//    }
//    return false;
//}
//

//ll find(ll v, vector<ll> &parent) {
//    if (parent[v] == v) {
//        return v;
//    }
//    return parent[v] = find(parent[v], parent);
//}
//
//void merge(ll a, ll b, vector<ll> &parent, vector<ll> &size, vector<ll> &mi, vector<ll> &ma) {
//
//    if (size[a] > size[b]) {
//        parent[b] = a;
//        size[a] += size[b];
//        mi[a] = min(mi[a], mi[b]);
//        ma[a] = max(ma[a], ma[b]);
//    } else {
//        parent[a] = b;
//        size[b] += size[a];
//        mi[b] = min(mi[b], mi[a]);
//        ma[b] = max(ma[b], ma[a]);
//    }
//}
//dl func(dl x, dl h,dl l){
//    dl k = l - sqrt(x*x+h*h);
//    return x*k/sqrt(x*x+h*h);
//}
//void retro(ll node,vector<ll> &parent,vector<bool> &win,vector<bool> &loose,vector<ll> &am,vector<bool> &used){
//    used[node]=true;
//    if(node==0 || used[parent[node]])return;
//    if(loose[node]){
//        loose[parent[node]]=true;
//        retro(parent[node],parent,win,loose,am,used);
//    }else if(win[node]){
//        am[parent[node]]--;
//        if(am[parent[node]]==0){
//            win[parent[node]]=true;
//            retro(parent[node],parent,win,loose,am,used);
//        }
//    }
//}
//wor beg;
//
//bool comp(wor &a, wor &b) {
//    wor k = a - beg;
//    wor z = b - beg;
//    if (vec(k, z) == 0) {
//        return k.x * k.x + k.y * k.y < z.x * z.x + z.y * z.y;
//    }
//    return vec(k, z) > 0;
//}
//
//vector<wor> get_hull(vector<wor> arr) {
//    ll mi = 0;
//    for (int i = 1; i < arr.size(); i++) {
//        if (arr[i].x < arr[mi].x) {
//            mi = i;
//        } else if (arr[i].x == arr[mi].x && arr[i].y < arr[mi].y) {
//            mi = i;
//        }
//    }
//    swap(arr[0], arr[mi]);
//    beg = arr[0];
//    sort(arr.begin() + 1, arr.end(), comp);
//    vector<wor> answer;
//    answer.push_back(arr[0]);
//    answer.push_back(arr[1]);
//    for (int i = 2; i < arr.size(); i++) {
//        wor temp = arr[i] - answer.back();
//        wor temp1 = arr[i] - answer[answer.size() - 2];
//        while (answer.size() >= 2 && vec(temp1, temp) <= 0) {
//            answer.pop_back();
//            if (answer.size() == 1)break;
//            temp = arr[i] - answer.back();
//            temp1 = arr[i] - answer[answer.size() - 2];
//        }
//        answer.push_back(arr[i]);
//    }
//    return answer;
//}
//dl deg(wor &a, wor &b,wor &c){
//    wor k = a-b;
//    wor z = c-b;
//    return acos((k.x*z.x + k.y*z.y)/(dist(a,b)*dist(b,c)));
//}
//const dl PI = acos(-1);
//bool comp(ll a, ll b){
//    return sin(a)>sin(b);
//}

//bool byXbyY(wor a, wor b) {
//    if (a.x == b.x) {
//        return a.y < b.y;
//    }
//    return a.x < b.x;
//}
//const dl PI = acos(-1);
//
//dl get_x(dl a, dl b, dl h, dl d) {
//    if (h <= d) {
//        return b - a;
//    }
//    return (b - a) / h * d;
//}
//
//struct sq {
//    vector<wor> data;
//};
//
//sq build(wor a, wor b) {
//    wor c = b - a;
//    wor n;
//    n.x = -c.y;
//    n.y = c.x;
//    n /= 2;
//    wor center = a + (c / 2);
//    sq res;
//    res.data.push_back(a);
//    res.data.push_back(center - n);
//    res.data.push_back(b);
//    res.data.push_back(center + n);
//    return res;
//}
//
//dl dist_to_sq(wor p, sq s) {
//    if (is_in(s.data, p)) {
//        return 0;
//    }
//    dl answer = 1e16;
//    for (auto e : s.data) {
//        answer = min(answer, dist(p, e));
//    }
//    for (int i = 1; i <= s.data.size(); i++) {
//        auto inter = intersect(s.data[i % s.data.size()], s.data[i - 1], p);
//        if (rely(s.data[i % s.data.size()], s.data[i - 1], inter)) {
//            answer = min(answer, dist(p, inter));
//        }
//    }
//    return answer;
//}
//

//
//
//bool is_prime(ll p) {
//    for (ll i = 2; i * i <= p; i++) {
//        if (p % i == 0)return false;
//    }
//    return true;
//}
//
vector<pair<ll,ll>> canon(ll p) {
    vector<pair<ll,ll>> answer;
    for (ll i = 2; i * i <= p; i++) {
        if (p % i == 0) {
            ll k =0;
            while (p % i == 0) {
                p /= i;
                k++;
            }
            answer.push_back({i,k});
        }
    }
    if (p > 1)answer.push_back({p,1});
    return answer;
}
//

template<typename T, typename R>
istream &operator>>(istream &is, pair<T, R> &a) {
    is >> a.first >> a.second;
    return is;
}

template<typename T, typename R>
ostream &operator<<(ostream &os, pair<T, R> &a) {
    os << a.first << " " << a.second;
    return os;
}

template<typename T>
ostream &operator<<(ostream &os, vector<T> &a) {
    for (auto e : a) {
        os << e << " ";
    }
    return os;
}

template<typename T>
istream &operator>>(istream &is, vector<T> &a) {
    for (auto &e:a) {
        is >> e;
    }
    return is;
}

//ll bin_pow(ll a, ll b, ll mod){
//    ll res = 1;
//    while(b){
//        if(b&1){
//            res*=a;
//            res%=mod;
//        }
//        a*=a;
//        a%=mod;
//        b>>=1;
//    }
//    return res;
//}
//void count_sort(vector<ll> &p, vector<ll> &c) {
//    ll n = p.size();
//    vector<ll> am(n);
//    for (auto e : c) {
//        am[e]++;
//    }
//    vector<ll> pos(n);
//    vector<ll> res_p(n);
//    pos[0] = 0;
//    for (int i = 1; i < n; i++) {
//        pos[i] = pos[i - 1] + am[i - 1];
//    }
//    for (auto e : p) {
//        res_p[pos[c[e]]] = e;
//        pos[c[e]]++;
//    }
//    p.swap(res_p);
//}

//pair<vector<ll>, vector<ll>> suf_arr(string &s) {
//    s += " ";
//    ll n = s.length();
//    vector<ll> p(n), c(n);
//    {
//        vector<pair<char, ll>> arr(n);
//        for (int i = 0; i < n; i++)arr[i] = {s[i], i};
//        sort(all(arr));
//        for (int i = 0; i < n; i++)p[i] = arr[i].second;
//        c[p[0]] = 0;
//        for (int i = 1; i < n; i++) {
//            if (arr[i].first == arr[i - 1].first) {
//                c[p[i]] = c[p[i - 1]];
//            } else {
//                c[p[i]] = c[p[i - 1]] + 1;
//            }
//        }
//    }
//    ll k = 0;
//    while ((1ll << k) < n) {
//        for (int i = 0; i < n; i++) {
//            p[i] = (p[i] + n - (1ll << k)) % n;
//        }
//        count_sort(p, c);
//        vector<ll> c_new(n);
//        c_new[p[0]] = 0;
//        for (int i = 1; i < n; i++) {
//            pair<ll, ll> now = {c[p[i]], c[(p[i] + (1ll << k)) % n]};
//            pair<ll, ll> was = {c[p[i - 1]], c[(p[i - 1] + (1ll << k)) % n]};
//            if (was == now) {
//                c_new[p[i]] = c_new[p[i - 1]];
//            } else {
//                c_new[p[i]] = c_new[p[i - 1]] + 1;
//            }
//        }
//        c.swap(c_new);
//        k++;
//    }
//    vector<ll> lcp(n);
//    k = 0;
//    for (int i = 0; i < n - 1; i++) {
//        ll pid = c[i];
//        ll prev = p[pid - 1];
//        while (s[i + k] == s[prev + k]) {
//            k++;
//        }
//        lcp[pid] = k;
//        k = max(0ll, k - 1);
//    }
//    return {p, lcp};
//}
//void count_sort(vector<ll> &p, vector<ll> &c) {
//    ll n = p.size();
//    vector<ll> am(n);
//    for (auto e : c) {
//        am[e]++;
//    }
//    vector<ll> pos(n);
//    vector<ll> p_res(n);
//    pos[0] = 0;
//    for (int i = 1; i < n; i++) {
//        pos[i] = pos[i - 1] + am[i - 1];
//    }
//    for (auto e : p) {
//        p_res[pos[c[e]]] = e;
//        pos[c[e]]++;
//    }
//    p.swap(p_res);
//}
//
//pair<vector<ll>, vector<ll>> suf_arr(string &s) {
//    s += "$";
//    ll n = s.length();
//    vector<ll> p(n), c(n);
//    {
//        vector<pair<char, ll>> arr(n);
//        for (int i = 0; i < n; i++)arr[i] = {s[i], i};
//        sort(all(arr));
//        for (int i = 0; i < n; i++) {
//            p[i] = arr[i].second;
//        }
//        c[p[0]] = 0;
//        for (int i = 1; i < n; i++) {
//            if (arr[i].first == arr[i - 1].first) {
//                c[p[i]] = c[p[i - 1]];
//            } else {
//                c[p[i]] = c[p[i - 1]] + 1;
//            }
//        }
//    }
//    ll k = 0;
//    while ((1 << k) < n) {
//        for (int i = 0; i < n; i++) {
//            p[i] = (p[i] - (1 << k) + n) % n;
//        }
//        count_sort(p, c);
//        vector<ll> c_new(n);
//        c_new[p[0]] = 0;
//        for (int i = 1; i < n; i++) {
//            pair<ll, ll> was = {c[p[i - 1]], c[(p[i - 1] + (1 << k)) % n]};
//            pair<ll, ll> now = {c[p[i]], c[(p[i] + (1 << k)) % n]};
//            if (now == was) {
//                c_new[p[i]] = c_new[p[i - 1]];
//            } else {
//                c_new[p[i]] = c_new[p[i - 1]] + 1;
//            }
//        }
//        c.swap(c_new);
//        k++;
//    }
//    vector<ll> lcp(n);
//    k = 0;
//    for (int i = 0; i < n - 1; i++) {
//        ll id = c[i];
//        ll pid = p[id - 1];
//        while (s[i + k] == s[pid + k]) {
//            k++;
//        }
//        lcp[id] = k;
//        k = max(0ll, k - 1);
//    }
//    return {p, lcp};
//}
//const ll mod = 998244353;
//ll len = (mod-1)&(-(mod-1));
//ll LOG_gl = 23;
//ll base_gl = 31;
//vector<ll> bit_rev(ll n, ll log){
//    vector<ll> rev(n);
//    ll k = 0 ;
//    for(ll i =1 ; i < n; i ++){
//        rev[i]  = rev[i^(1ll<<k)] ^ (1ll<<(log-k-1));
//        if(!((i+1)&(i)))k++;
//    }
//    return rev;
//}
//vector<ll> get_w(ll n,ll log){
//    ll base = bin_pow(base_gl,(1ll<<(LOG_gl - log)),mod);
//    vector<ll> w(n);
//    w[0] =1;
//    for(int i = 1; i < n ; i ++){
//        w[i] = (w[i-1] * base)%mod;
//    }
//    return w;
//}
//ll w(ll pow, ll base, vector<ll> &ws, ll N){
//    return ws[pow*N/base];
//}
//void butterfly(ll &a, ll &b, ll w){
//    ll x = (a +b*w%mod)%mod;
//    ll y = (a + mod - b*w%mod)%mod;
//    a = x;
//    b = y;
//}
//vector<ll> fft(vector<ll> &a,ll n, ll LOG , bool back){
//    const ll nrev = bin_pow(n,mod-2,mod);
//    auto rev = bit_rev(n,LOG);
//    vector<ll> temp =a;
//    for(int i = 0 ; i < n; i ++){
//        temp[rev[i]] = a[i];
//    }
//    a.swap(temp);
//    auto ws = get_w(n,LOG);
//    for(ll dl = 1; dl < n; (dl <<=1)){
//        for(int i = 0 ; i < n ; i +=2*dl){
//            for(ll k = 0 ; k < dl ; k ++){
//                butterfly(a[i+k], a[i+dl + k], w(k,2*dl,ws,n));
//            }
//        }
//    }
//    if(back){
//        for(int i = 0 ; i < n; i ++){
//            (a[i] *=nrev)%=mod;
//        }
//        reverse(a.begin()+1,a.end());
//    }
//    return a;
//}
//vector<ll> mult(vector<ll> &a,vector<ll> &b){
//    ll n = a.size() + b.size();
//    while(n&(n-1)){
//        n++;
//    }
//    a.resize(n);
//    b.resize(n);
//    ll t = 0 , temp_c = n;
//    while(temp_c > 1){
//        t++;
//        temp_c>>=1;
//    }
//    a = fft(a,n,t,false);
//    b = fft(b,n,t,false);
//    for(int i = 0 ; i < n ; i ++){
//        (a[i]*=b[i])%=mod;
//    }
//    return fft(a,n,t,true);
//}

//pair<vector<ll>, vector<ll>> manaker(string &s) {
//    ll n = s.length();
//    ll l = 0;
//    ll r = -1;
//    vector<ll> d1(n);
//    for (int i = 0; i < n; i++) {
//        ll k = i > r ? 1 : min(d1[l + r - i], r - i + 1);
//        while (i + k < n && i - k >= 0 && s[i + k] == s[i - k]) {
//            k++;
//        }
//        d1[i] = k;
//        if (i + k - 1 > r) {
//            r = i + k - 1;
//            l = i - k + 1;
//        }
//    }
//
//    vector<ll> d2(n);
//    l = 0;
//    r = -1;
//    for (int i = 0; i < n; i++) {
//        ll k = i > r ? 0 : min(d2[l + r - i + 1], r - i + 1);
//        while (i + k < n && i - k - 1 >= 0 && s[i + k] == s[i - k - 1]) {
//            k++;
//        }
//        d2[i] = k;
//        if (i + k - 1 > r) {
//            r = i + k - 1;
//            l = i - k;
//        }
//    }
//    return {d1, d2};
//}
//
//vector<ll> pref(string &s) {
//    ll n = s.length();
//    vector<ll> p(n);
//    p[0] = 0;
//    for (int i = 1; i < n; i++) {
//        ll j = p[i - 1];
//        while (j > 0 && s[j] != s[i]) {
//            j = p[j - 1];
//        }
//        if (s[i] == s[j])j++;
//        p[i] = j;
//    }
//    return p;
//}
//
//vector<ll> zf(string &s) {
//    ll n = s.length();
//    vector<ll> z(n);
//    ll l = 0;
//
//    ll r = 0;
//    for (int i = 1; i < n; i++) {
//        z[i] = i > r ? 0 : min(z[i - l], r - i + 1);
//        while (z[i] + i < n && s[z[i]] == s[z[i] + i]) {
//            z[i]++;
//        }
//        if (z[i] + i - 1 > r) {
//            l = i;
//            r = z[i] + i - 1;
//        }
//    }
//    return z;
//}
//const ll MAXN = 1e5;
//struct vertex{
//    map<char,int> next;
//    bool target=false;
//    bool realtarget = false;
//    int parent=0;
//    int suf_link = 0;
//};
//struct aho_korasik{
//
//    int sz;
//    vector<vertex> vert;
//    aho_korasik(){
//        vert.resize(MAXN);
//        sz = 2;
//        for(int i = CHAR_MIN; i <=CHAR_MAX;i ++){
//            vert[0].next[i]=1;
//        }
//    }
//    void add_str(const string& s){
//        if(s.empty())return;
//        int v = 1;
//        for(int i = 0 ; i < s.length() ; i ++){
//            if(vert[v].next.find(vert[v].next[s[i]]) == vert[v].next.end()){
//                vert[sz].parent = v;
//                vert[v].next[s[i]] = sz;
//                sz++;
//            }
//            v = vert[v].next[s[i]] ;
//        }
//        vert[v].realtarget = true;
//        vert[v].target = true;
//    }
//    void build_suf_links(){
//        queue<int> q;
//        q.push(1);
//        while(!q.empty()){
//            ll v = q.front();
//            q.pop();
//            if(vert[vert[v].suf_link].target){
//                vert[v].target = true;
//            }
//            for(auto &e : vert[v].next){
//                q.push(e.second);
//                int p = vert[v].suf_link;
//                while(vert[p].next.find(e.first) == vert[p].next.end()){
//                    p = vert[p].suf_link;
//                }
//                vert[e.second].suf_link = vert[p].next[e.first];
//
//            }
//        }
//    }
//};

//const ll MAXN = 4e5 + 100;
//vector<pair<ll, ll>> t;
//vector<ll> d;
//
//void push(ll v, ll vl, ll vr) {
//    if (d[v] != -1) {
//        if (vl == vr) {
//            t[v].second = t[v].first = 0;
//        } else {
//            d[2 * v + 1] = d[2 * v + 2] = d[v];
//            t[v].second = t[v].first = 0;
//        }
//        d[v] = -1;
//    }
//}
//pair<ll,ll> get(ll v, ll vl, ll vr ,ll l , ll r){
//    if(l>r)return{0,0};
//    push(v, vl, vr);
//    if (vr < l || vl > r) {
//        return{0,0};
//    }
//    if (l <= vl && vr <= r) {
//        return t[v];
//    }
//    ll m = (vl + vr) / 2;
//    auto f = get(2 * v + 1, vl, m, l, r);
//    auto s = get(2 * v + 2, m + 1, vr, l, r);
//    return {f.first+s.first,s.second+f.second};
//}
//void del(ll v, ll vl, ll vr, ll l, ll r) {
//    if(l>r)return;
//    push(v, vl, vr);
//    if (vr < l || vl > r) {
//        return;
//    }
//    if (l <= vl && vr <= r) {
//        d[v] = 0;
//        push(v, vl, vr);
//        return;
//    }
//    ll m = (vl + vr) / 2;
//    del(2 * v + 1, vl, m, l, r);
//    del(2 * v + 2, m + 1, vr, l, r);
//    t[v].second = t[2 * v + 1].second + t[2 * v + 2].second;
//    t[v].first = t[2 * v + 1].first + t[2 * v + 2].first;
//}
//
//void add(ll v, ll vl, ll vr, ll pos, ll val, ll am) {
//    push(v, vl, vr);
//    if (vl == vr) {
//        t[v].second += val;
//        t[v].first += am;
//        return;
//    }
//    ll m = (vl + vr) / 2;
//    if (pos <= m) {
//        add(2 * v + 1, vl, m, pos, val,am);
//    } else {
//        add(2 * v + 2, m + 1, vr, pos, val,am);
//    }
//    push(2*v+1,vl,m);
//    push(2*v+2,m+1,vr);
//    t[v].second = t[2 * v + 1].second + t[2 * v + 2].second;
//    t[v].first = t[2 * v + 1].first + t[2 * v + 2].first;
//}
//ll am_grans(string s){
//    ll n = s.length();
//    ll answer =0 ;
//    for(int i = 1 ; i < n; i ++){
//        if(s.substr(0,i) == s.substr(n-i,i)){
//            answer++;
//        }
//    }
//    return answer;
//}
int main() {
//    freopen("D:/CLionProjects/strings.txt","r",stdin);
//    freopen("D:/CLionProjects/res2.txt","w",stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    ll t;
    cin>>t;
    while(t--){
        ll n;
        cin>>n;
        vector<ll> arr(n);
        cin>>arr;
        if(n == 1){
            cout<<arr<<"\n";
            continue;
        }
        sort(all(arr));
        vector<ll> res(n);
        for(int i =0 ; i < n/2; i ++){
            res[2*i] = arr[n-1-i];
            res[2*i+1] = arr[i];
        }
        if(n&1){
            res[n-1] = arr[(n+1)/2];
        }
        reverse(all(res));
        cout<<res<<"\n";

    }
    return 0;
}


/*
ID: henrybu2
LANG: C++
PROB: dualpal
*/

#include <iostream>
#include <cmath>
#include <cstdio>
#include <vector>
#include <string>
#include <sstream>
#include <iomanip>
#include <stack>
#include <fstream>
#include <algorithm>
#include <set>
#include <iterator>
#include <stdio.h>
#include <string.h>
#include <initializer_list>
#include <map>
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl "\n"
#define ll long long
using namespace std;

#include <iostream>
#include <fstream>
using namespace std;

vector<int> numbers;

int main()
{
	IOS;

	//freopen("lemonade.in", "r", stdin);
	//freopen("lemonade.out", "w", stdout);

	int N; cin >> N;

	for (int i = 0; i < N; ++i)
	{
		int x; cin >> x;
		vector<int> temp;
		for (int j = 0; j < x; ++j)
		{
			int y; cin >> y;
			temp.push_back(y);
		}

		sort(temp.begin(), temp.end());

		int mid;
		if (x % 2 != 0) int mid = x / 2;
		else
		{
			mid = x / 2 - 1;
		}

		cout << temp[mid] << " ";

		for (int a = mid + 1; a < temp.size(); ++a)
		{
			cout << temp[a] << " ";
		}

		for (int b = mid - 1; b >= 0; --b)
		{
			cout << temp[b] << " ";
		}

		cout << endl;

	}

}