2024年前端最新【算法】剑指 Offer II 085，2024年最新阿里巴巴二面是主管吗-CSDN博客

本文链接：https://blog.csdn.net/2401_84435866/article/details/138818801

最后

我可以将最近整理的前端面试题分享出来，其中包含HTML、CSS、JavaScript、服务端与网络、Vue、浏览器、数据结构与算法等等，还在持续整理更新中，希望大家都能找到心仪的工作。

开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】

篇幅有限，仅展示部分截图：

java

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> ans = new ArrayList<>();

        this.dfs(n, ans, new char[n \* 2], 0, 0);

        return ans;
    }

    private void dfs(int n, List<String> ans, char[] cs, int left, int right) {
        if (left == n && right == n) {
            ans.add(new String(cs));
            return;
        }

        if (left < n) {
            cs[left + right] = '(';
            dfs(n, ans, cs, left + 1, right);
        }
        if (right < left) {
            cs[left + right] = ')';
            dfs(n, ans, cs, left, right + 1);
        }
    }
}

c

#define MAX\_SIZE 1430

void dfs(int n, int \*returnSize, char \*\*ans, char \*cs, int left, int right) {
    if (left == n && right == n) {
        ans[(\*returnSize)] = calloc((n \* 2 + 1), sizeof(char));
        strcpy(ans[(\*returnSize)], cs);
        ++(\*returnSize);
        return;
    }

    if (left < n) {
        cs[left + right] = '(';
        dfs(n, returnSize, ans, cs, left + 1, right);
    }
    if (right < left) {
        cs[left + right] = ')';
        dfs(n, returnSize, ans, cs, left, right + 1);
    }
}

/\*\*
 \* Note: The returned array must be malloced, assume caller calls free().
 \*/
char \*\*generateParenthesis(int n, int \*returnSize) {
    \*returnSize = 0;
    char \*\*ans = malloc(MAX_SIZE \* sizeof(char \*));
    char \*cs = calloc((n \* 2 + 1), sizeof(char));
    dfs(n, returnSize, ans, cs, 0, 0);
    return ans;
}

c++

class Solution {
private:
    void dfs(int n, vector<string> &ans, string &buf, int left, int right) {
        if (left == n && right == n) {
            ans.push\_back(buf);
            return;
        }

        if (left < n) {
            buf.push\_back('(');
            dfs(n, ans, buf, left + 1, right);
            buf.pop\_back();
        }
        if (right < left) {
            buf.push\_back(')');
            dfs(n, ans, buf, left, right + 1);
            buf.pop\_back();
        }
    }

public:
    vector<string> generateParenthesis(int n) {
        vector<string> ans;
        string buf;
        dfs(n, ans, buf, 0, 0);
        return ans;
    }
};

python

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        ans = []

        def dfs(s, left, right):
            if left == n and right == n:
                ans.append(''.join(s))
                return
            if left < n:
                s.append('(')
                dfs(s, left + 1, right)
                s.pop()
            if right < left:
                s.append(')')
                dfs(s, left, right + 1)
                s.pop()

        dfs([], 0, 0)
        return ans

go

func generateParenthesis(n int) []string {
    var ans []string

	var dfs func(cs []byte, left int, right int)
	dfs = func(cs []byte, left int, right int) {
		if left == n && right == n {
			ans = append(ans, string(cs))
			return
		}

		if left < n {
			cs[left+right] = '('
			dfs(cs, left+1, right)
		}
		if right < left {
			cs[left+right] = ')'
			dfs(cs, left, right+1)
		}
	}

	dfs(make([]byte, n\*2), 0, 0)

	return ans
}

rust

impl Solution {
    pub fn generate\_parenthesis(n: i32) -> Vec<String> {
        let mut ans = Vec::new();

        fn dfs(n: usize, ans: &mut Vec<String>, buf: &mut String, left: usize, right: usize) {
            if left == n && right == n {
                ans.push(buf.clone());
                return;
            }
            if left < n {
                buf.push('(');
                dfs(n, ans, buf, left + 1, right);
                buf.pop();
            }
            if right < left {
                buf.push(')');
                dfs(n, ans, buf, left, right + 1);
                buf.pop();
            }
        }

        dfs(n as usize, &mut ans, &mut String::new(), 0, 0);

        ans
    }
}