We will use the heap data structure to solve this problem (we will use max heap), since the problem is to assign count variable i, we will create priority queue with pair, the first part of the pair is the size of subarray and the second part of the pair is another pair which contains indices l and r, left index and right index of the subarray.

A/c to the question if the size of the left and right subarray with the equal number of 0s in them we have to choose the left part, so to solve the problem we multiply the indexes with -1 so that left part is chosen.

While a priority queue is not empty, we pick the max element from the top of the priority queue and pop it from the priority queue.

Now, l=be the left index of the subarray and r be the right index of the subarray. We take the mid index as (l+r)/2 and fill it with cnt and increment it with one each time. If l==r then there is no possibility of partition among it so simply continue, else one part will be the subarray of l to mid-1 and the other part will be mid+1 to r with length (mid-l) and (r-mid) respectively.

Push them with their respective length and indices into the priority queue.

We repeat the process untill the priority queue is not empty.

C++ Implementation:

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;

ll arr[200005];

// solve function to solve the entire problem which 
// takes n as the parameter,n is size of the array arr[].
void solve(ll n)
{
    // priority queue as our max heap
    priority_queue<pair<ll, pair<ll, ll> > > pq; 
    // Here, pq with pair of len and pair of 
    // indices as its elements.
    
    // base case as len of entire array as first input 
    // from index 1 to n but its multiplied with -1 
    // so that left sub-array can be chosen if len of two 
    // sub-arrays are equals.
    pq.push({ n, { -1, -n } });
    
    // initialise count as 1.
    ll cnt = 1;
    
    // if priority_queue is not empty 
    // then do the following operation.
    while (!pq.empty()) {
        // declare pair
        pair<ll, pair<ll, ll> > p = pq.top();
        pq.pop();
        ll l = p.second.first * (-1); // initialize left index
        ll r = p.second.second * (-1); // initialise right index
        ll mid = (l + r) / 2; // take mid index of the sub-array
        arr[mid] = cnt; // assign cnt value to mid index.
        cnt++; // increment count variable.

        // base case condition if only single element is present.
        if (l == r)
            continue;
        else {
            // declare left subarray
            if ((mid - 1) >= 0 and (mid - 1) >= l) {
                ll len = mid - l; // len of left sub-array
                pq.push({ len, { (-1) * l, (-1) * (mid - 1) } });
            }
            // declare right sub-array
            if ((mid + 1) <= n and (mid + 1) <= r) {
                ll len = r - mid; // len of right sub-array
                pq.push({ len, { (-1) * (mid + 1), (-1) * r } });
            }
        }
    }
    
    // iterate through final result array.
    for (ll i = 1; i <= n; i++)
        cout << arr[i] << " ";
    cout << "\n";
}

int main()
{
    ll t;
    
    cout << "Enter number of test cases: ";
    cin >> t;
    
    while (t--) {
        cout << "Enter size of array: ";
        ll n;
        cin >> n;
    
        // call solve function.
        solve(n);
    }
    
    return 0;
}

Output:

Enter number of test cases: 4
Enter size of array: 5
2 4 1 3 5 
Enter size of array: 4
3 1 2 4 
Enter size of array: 9
6 2 4 7 1 8 3 5 9 
Enter size of array: 3
2 1 3