Leetcode2471-逐层排序二叉树所需的最少操作数目

置换环

        层序遍历把每一层的元素都依次存到一个数组中。

        要解决的问题是每个数组要交换多少多少次。对于一个数组t，用p复制一份t，对p进行排序，然后遍历p，把p中的元素和下标映射到一个哈希表中。再遍历t，对于t中的一个位置i，如果t[i]!=p[i]说明需要交换，在哈希表中找到t[i]的下标j，交换t[i]和t[j]，这样就把原来t[i]上的元素给归位了；再次判断如果t[i]!=p[i]，则继续上述的交换。累计所有数组的交换次数即可。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> t[100005];
    int n=0;
    void dfs(TreeNode* root,int h){
        if(!root) return;
        n=max(n,h);
        t[h].push_back(root->val);
        dfs(root->left,h+1);
        dfs(root->right,h+1);
    }
    int minimumOperations(TreeNode* root) {
        dfs(root,0);
        int ans=0;
        for(int i=0;i<=n;i++){
            unordered_map<int,int> up;
            vector<int> p=t[i];
            int k=0;
            sort(p.begin(),p.end());
            for(int j=0;j<p.size();j++) up[p[j]]=j;
            for(int j=0;j<p.size();j++){
                if(t[i][j]==p[j]) continue;
                while(t[i][j]!=p[j] )swap(t[i][j],t[i][up[t[i][j]]]),k++;
                
            }
            ans+=k;
        }
        return ans;
    }
};

时间复杂度：O（nlogn）

空间复杂度：O（n）

        可以感性的知道，数组中的一定元素经过相互交换都可以到达目标位置，这样的交换其实说明这些数形成了一个环。于是也可以用并查集来维护这个数组的元素，来判断有多少个环，则交换次数为所有在环中的元素的个数减去环的个数。