Question

为了总结任何给定二叉树中所有节点的深度，我编写了以下递归算法：

def nodeDepths(root):
    final=0
    helper(root,0,final)
    return final

def helper(node,d,final):
    if not node:
        return 
    final+=d
    helper(node.left,d+1,final)
    helper(node.right,d+1,final)

class BinaryTree:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

我的想法是：当我看到每个节点时，将该节点的深度添加到最终的总和中，然后递归调用左侧和右侧，以便它们可以执行相同的操作。在递归调用堆栈的末尾，最终的总和应具有正确的值。

实际结果：最终总和始终为0。

为什么这不起作用？

Answer 1

Python传递其自变量by assignment。因此，如果将列表而不是变量传递给上述方法，它将按以下方式工作：

import React, { Component } from 'react';
import { Route, Switch } from "react-router-dom";
import './App.css';
import PropTypes from 'prop-types';
import HeaderMenu from './components/HeaderMenu'
import MainPage from './components/MainPage'
import Works from './components/Works'
import Info from './components/Info' 
import Contact from './components/Contact'

class App extends Component {
  state = {
    userView: 0
}

handleChange = (userView) => {
    userView === 0 ? this.setState({ userView: 1}) : this.setState({ userView: 0})
}

render() {
return (
   <div className="App">
      <HeaderMenu
         handleChange={this.handleChange}
         userView={this.state.userView}
      />
      <Switch>
         <Route
           exact
           path="/"
           render={() => (
             <MainPage />
           )}
         />
        <Route
           exact
           path="/works"
           render={() => (
             <Works />
           )}
        />
        <Route
           exact
           path="/info"
           render={() => (
             <Info />
           )}
        />
        <Route
          exact
          path="/contact"
          render={() => (
            <Contact/>
          )}
        />
     </Switch>
   </div>
  );
}}

App.propTypes = {
  userView: PropTypes.oneOf([0, 1]).isRequired
}

export default App;

简单地说，

如果传入了可变对象，则可以对其进行更改，但是如果将其分配给它，则外部变量将不会反映这些更改。
如果传入了一个不可变的对象，则无法对其进行更改，并且外部变量将不会反映该更改。

总结二叉树中的节点深度

1 个答案: