Java 此代码的时间复杂度（使用BigO表示法）

有人能帮我解决下面代码中每个部分的时间复杂度，包括for循环和if循环以及所有循环

public class GaleShapley {
    private int N, engagedCount;
    private int[][] menPref;
    private int[][] womenPref;
    private int[] men;
    private int[] women;
    private int[] womenPartner;
    private boolean[] menEngaged;

    /** Constructor **/
    public GaleShapley(int[] m, int[] w, int[][] mp, int[][] wp) {
        N = mp.length;
        engagedCount = 0;
        men = m;
        women = w;
        menPref = mp;
        womenPref = wp;
        menEngaged = new boolean[N];
        womenPartner = new int[N];
        calcMatches();
    }

    /** function to calculate all matches **/
    private void calcMatches() {

        while (engagedCount < N) {
            int free;
            for (free = 0; free < N; free++)
                if (!menEngaged[free])
                    break;

            for (int i = 0; i < N && !menEngaged[free]; i++) {
                int index = womenIndexOf(menPref[free][i]);
                if (womenPartner[index] == 0) {
                    womenPartner[index] = men[free];
                    menEngaged[free] = true;
                    engagedCount++;
                } else {
                    int currentPartner = womenPartner[index];
                    if (morePreference(currentPartner, men[free], index)) {
                        womenPartner[index] = men[free];
                        menEngaged[free] = true;
                        menEngaged[menIndexOf(currentPartner)] = false;
                    }
                }
            }
        }
        printCouples();
    }

    /** function to check if women prefers new partner over old assigned partner **/
    private boolean morePreference(int curPartner, int newPartner, int index) {
        for (int i = 0; i < N; i++) {
            if (womenPref[index][i] == newPartner)
                return true;
            if (womenPref[index][i] == curPartner)
                return false;
        }
        return false;
    }

    /** get men index **/
    private int menIndexOf(int str) {
        for (int i = 0; i < N; i++)
            if (men[i] == str)
                return i;
        return -1;
    }

    /** get women index **/
    private int womenIndexOf(int str) {
        for (int i = 0; i < N; i++)
            if (women[i] == str)
                return i;
        return -1;
    }

    /** print couples **/
    public void printCouples() {

        System.out.println("Couples are : ");
        for (int i = 0; i < N; i++) {
            System.out.println(women[i] + " " + womenPartner[i]);
        }
    }

    /** main function **/
    public static void main(String[] args) {
        System.out.println("Gale Shapley Marriage Algorithm\n");
        /** list of men **/
        int[] m = { 1, 2, 3, 4, 5 };
        /** list of women **/
        int[] w = { 1, 2, 3, 4, 5 };

        /** men preference **/
        int[][] mp = { { 2, 4, 1, 3, 5 }, { 3, 1, 4, 2, 5 }, { 2, 3, 1, 4, 5 },
                { 4, 1, 3, 2, 5 }, { 2, 1, 4, 3, 5 } };
        /** women preference **/
        int[][] wp = { { 2, 1, 4, 3 }, { 4, 3, 1, 2 }, { 1, 4, 3, 2 },
                { 2, 1, 4, 3 }, { 2, 1, 4, 3 } };

        GaleShapley gs = new GaleShapley(m, w, mp, wp);
    }
}

public类GaleShapley{
私人帐户，专用帐户；
私有int[]menPref；
私人int[][]女性优先；
二等兵；
私营部门：妇女；
私人女性伴侣；
私人布尔值已启用；
/**建造师**/
公共广场（int[]m，int[]w，int[]mp，int[]wp）{
N=mp.长度；
engagedCount=0；
男性=男性；
女性=w；
menPref=mp；
女性pref=wp；
menEngaged=新布尔值[N]；
女性伴侣=新整数[N]；
calcMatches（）；
}
/**函数计算所有匹配项**/
私有无效calcMatches（）{
while（占用数量

---

我假设时间复杂度为O（n^2）。需要有人确认。

您的操作以

开始，而
循环（从0到N）

在这个循环中，有2个
for
循环（从0到N）

在第二个
for
循环中，调用方法
moreproference
、
menIndexOf
和
womenIndexOf
。
每个方法都包含一个for
循环的
（从0到N）

因此，您的算法的复杂性是
O（N^3）
N^3。如果组合FN，循环中有循环。这可以优化为n^2？？？如果是这样的话，怎么做？如果我们想优化，我们必须理解你的程序意味着什么。