精华内容
下载资源
问答
  • java中死循环什么意思 循环一次不再循环是死循环 还是不断循环才是死循环 能否简单的举个死循环单身例子
  • 什么循环依赖? 顾名思义,循环依赖就是A依赖B,B又依赖A,两者之间的依赖关系形成了一个圆环,通常是由于不正确的编码所导致。Spring只能解决属性循环依赖问题,不能解决构造函数循环依赖问题,因为这个问题无解...

    什么是循环依赖?

    顾名思义,循环依赖就是A依赖B,B又依赖A,两者之间的依赖关系形成了一个圆环,通常是由于不正确的编码所导致。Spring只能解决属性循环依赖问题,不能解决构造函数循环依赖问题,因为这个问题无解。

    接下来我们首先写一个Demo来演示Spring是如何处理属性循环依赖问题的。

    Talk is cheap. Show me the code

    第一步:定义一个类ComponentA,其有一个私有属性componentB。

    package com.tech.ioc;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    /**
     * @author 君战
     * **/
    @Component
    public class ComponentA {
    
    	@Autowired
    	private ComponentB componentB;
    
    	public void say(){
    		componentB.say();
    	}
    
    }
    
    

    第二步:定义一个类ComponentB,其依赖ComponentA。并定义一个say方法便于打印数据。

    package com.tech.ioc;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    /**
     * @author 君战
     * **/
    @Component
    public class ComponentB {
    
    	@Autowired
    	private ComponentA componentA;
    
    	public void say(){
    		System.out.println("componentA field " + componentA);
    		System.out.println(this.getClass().getName() + " -----> say()");
    	}
    
    }
    
    

    第三步:重点,编写一个类-SimpleContainer,模仿Spring底层处理循环依赖。如果理解这个代码,再去看Spring处理循环依赖的逻辑就会很简单。

    package com.tech.ioc;
    
    import java.beans.Introspector;
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    
    /**
     * 演示Spring中循环依赖是如何处理的,只是个简版,真实的Spring依赖处理远比这个复杂。
     * 但大体思路都相同。另外这个Demo很多情况都未考虑,例如线程安全问题,仅供参考。
     * @author 君战
     *
     * **/
    public class SimpleContainer {
    
    	/***
    	 * 用于存放完全初始化好的Bean,Bean处于就绪状态
    	 * 这个Map定义和Spring中一级缓存命名一致
    	 * */
    	private Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
    
    	/***
    	 * 用于存放刚创建出来的Bean,其属性还没有处理,因此存放在该缓存中的Bean还不可用。
    	 * 这个Map定义和Spring中三级缓存命名一致
    	 * */
    	private final Map<String, Object> singletonFactories = new HashMap<>(16);
    
    
    	public static void main(String[] args) {
    		SimpleContainer container = new SimpleContainer();
    		ComponentA componentA = container.getBean(ComponentA.class);
    		componentA.say();
    	}
    
    	public <T> T getBean(Class<T> beanClass) {
    		String beanName = this.getBeanName(beanClass);
    		// 首先根据beanName从缓存中获取Bean实例
    		Object bean = this.getSingleton(beanName);
    		if (bean == null) {
    			// 如果未获取到Bean实例,则创建Bean实例
    			return createBean(beanClass, beanName);
    		}
    		return (T) bean;
    	}
    	/***
    	 * 从一级缓存和二级缓存中根据beanName来获取Bean实例,可能为空
    	 * */
    	private Object getSingleton(String beanName) {
    		// 首先尝试从一级缓存中获取
    		Object instance = singletonObjects.get(beanName);
    		if (instance == null) { // Spring 之所以能解决循环依赖问题,也是靠着这个三级缓存--singletonFactories
    			instance = singletonFactories.get(beanName);
    		}
    		return instance;
    	}
    
    	/***
    	 * 创建指定Class的实例,返回完全状态的Bean(属性可用)
    	 *
    	 * */
    	private <T> T createBean(Class<T> beanClass, String beanName) {
    		try {
    			Constructor<T> constructor = beanClass.getDeclaredConstructor();
    			T instance = constructor.newInstance();
    			// 先将刚创建好的实例存放到三级缓存中,如果没有这一步,Spring 也无法解决三级缓存
    			singletonFactories.put(beanName, instance);
    			Field[] fields = beanClass.getDeclaredFields();
    			for (Field field : fields) {
    				Class<?> fieldType = field.getType();
    				field.setAccessible(true); 
    				// 精髓是这里又调用了getBean方法,例如正在处理ComponentA.componentB属性,
    				// 执行到这里时就会去实例化ComponentB。因为在getBean方法首先去查缓存,
    				// 而一级缓存和三级缓存中没有ComponentB实例数据,所以又会调用到当前方法,
    				// 而在处理ComponentB.componentA属性时,又去调用getBean方法去缓存中查找,
    				// 因为在前面我们将ComponentA实例放入到了三级缓存,因此可以找到。
    				// 所以ComponentB的实例化结束,方法出栈,返回到实例化ComponentA的方法栈中,
    				// 这时ComponentB已经初始化完成,因此ComponentA.componentB属性赋值成功!
    				field.set(instance, this.getBean(fieldType));
    			}
    			// 最后再将初始化好的Bean设置到一级缓存中。
    			singletonObjects.put(beanName, instance);
    			return instance;
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		throw new IllegalArgumentException();
    	}
    
    	/**
    	 * 将类名小写作为beanName,Spring底层实现和这个差不多,也是使用javaBeans的
    	 * {@linkplain Introspector#decapitalize(String)}
    	 **/
    	private String getBeanName(Class<?> clazz) {
    		String clazzName = clazz.getName();
    		int index = clazzName.lastIndexOf(".");
    		clazzName = clazzName.substring(index);
    		return Introspector.decapitalize(className);
    	}
    }
    

    如果各位同学已经阅读并理解上面的代码,那么接下来我们就进行真实的Spring处理循环依赖问题源码分析,相信再阅读起来就会很容易。

    底层源码分析

    分析从AbstractBeanFactory的doGetBean方法着手。可以看到在该方法首先调用transformedBeanName(其实就是处理BeanName问题),和我们自己写的getBeanName方法作用是一样的,但Spring考虑的远比这个复杂,因为有FactoryBean、别名问题。

    // AbstractBeanFactory#doGetBean
    protected <T> T doGetBean(
    			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
    			throws BeansException {
    
    		String beanName = transformedBeanName(name);
    		Object bean;
    
    		// !!!重点是这里,首先从缓存中beanName来获取对应的Bean。
    		Object sharedInstance = getSingleton(beanName);
    		if (sharedInstance != null && args == null) {
    			// 执行到这里说明缓存中存在指定beanName的Bean实例,getObjectForBeanInstance是用来处理获取到的Bean是FactoryBean问题
    			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    		else {
    			try {
    				// 删除与本次分析无关代码....
    				// 如果是单例Bean,则通过调用createBean方法进行创建
    				if (mbd.isSingleton()) {
    					sharedInstance = getSingleton(beanName, () -> {
    						try {
    							return createBean(beanName, mbd, args);
    						} catch (BeansException ex) {
    							destroySingleton(beanName);
    							throw ex;
    						}
    					});
    				
    				}	
    			catch (BeansException ex) {
    				cleanupAfterBeanCreationFailure(beanName);
    				throw ex;
    			}
    		}
    		return (T) bean;
    	}
    

    getSingleton方法存在重载方法,这里调用的是重载的getSingleton方法,注意这里传递的boolean参数值为true,因为该值决定了是否允许曝光早期Bean。

    // DefaultSingletonBeanRegistry#getSingleton
    public Object getSingleton(String beanName) {
    	return getSingleton(beanName, true);
    }
    
    // DefaultSingletonBeanRegistry#getSingleton
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    		// 首先从一级缓存中获取
    		Object singletonObject = this.singletonObjects.get(beanName);
    		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
    			// 如果一级缓存中未获取到,再从二级缓存中获取
    			singletonObject = this.earlySingletonObjects.get(beanName);
    			// 如果未从二级缓存中获取到并且allowEarlyReference值为true(前面传的为true)
    			if (singletonObject == null && allowEarlyReference) {
    				synchronized (this.singletonObjects) {
    				   //Double Check 
    					singletonObject = this.singletonObjects.get(beanName);
    					if (singletonObject == null) {
    						singletonObject = this.earlySingletonObjects.get(beanName);
    						if (singletonObject == null) {
    							// 最后尝试去三级缓存中获取
    							ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
    							if (singletonFactory != null) {
    								singletonObject = singletonFactory.getObject();
    								// 保存到二级缓存
    								this.earlySingletonObjects.put(beanName, singletonObject);
    								// 从三级缓存中移除
    								this.singletonFactories.remove(beanName);
    							}
    						}
    					}
    				}
    			}
    		}
    		return singletonObject;
    	}
    

    ok,看完Spring是如何从缓存中获取Bean实例后,那再看看creatBean方法是如何创建Bean的

    protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    		throws BeanCreationException {
    	// 删除与本次分析无关的代码...
    	try {// createBean方法底层是通过调用doCreateBean来完成Bean创建的。
    		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    		if (logger.isTraceEnabled()) {
    			logger.trace("Finished creating instance of bean '" + beanName + "'");
    		}
    		return beanInstance;
    	} catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
    		throw ex;
    	} catch (Throwable ex) {
    		throw new BeanCreationException(
    				mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
    	}
    }
    
    // AbstractAutowireCapableBeanFactory#doCreateBean
    protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    			throws BeanCreationException {
    
    		BeanWrapper instanceWrapper = null;
    		if (mbd.isSingleton()) {
    			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    		}
    		if (instanceWrapper == null) {
    			// 创建Bean实例
    			instanceWrapper = createBeanInstance(beanName, mbd, args);
    		}
    		Object bean = instanceWrapper.getWrappedInstance();
    		// 如果允许当前Bean早期曝光。只要Bean是单例的并且allowCircularReferences 属性为true(默认为true)
    		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
    				isSingletonCurrentlyInCreation(beanName));
    		if (earlySingletonExposure) {
    			// 这里调用了addSingletonFactory方法将刚创建好的Bean保存到了三级缓存中。
    			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    		}
    
    		// 删除与本次分析无关的代码.....
    		Object exposedObject = bean;
    		try {// Bean属性填充
    			populateBean(beanName, mbd, instanceWrapper);
    			// 初始化Bean,熟知的Aware接口、InitializingBean接口.....都是在这里调用
    			exposedObject = initializeBean(beanName, exposedObject, mbd);
    		} catch (Throwable ex) {
    			
    		}
    		// 删除与本次分析无关的代码.....
    		return exposedObject;
    	}
    

    先分析addSingletonFactory方法,因为在该方法中将Bean保存到了三级缓存中。

    protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    	Assert.notNull(singletonFactory, "Singleton factory must not be null");
    	synchronized (this.singletonObjects) {
    		// 如果一级缓存中不存在指定beanName的key
    		if (!this.singletonObjects.containsKey(beanName)) {
    			// 将刚创建好的Bean实例保存到三级缓存中
    			this.singletonFactories.put(beanName, singletonFactory);
    			// 从二级缓存中移除。
    			this.earlySingletonObjects.remove(beanName);
    			this.registeredSingletons.add(beanName);
    		}
    	}
    }
    

    处理Bean的依赖注入是由populateBean方法完成的,但整个执行链路太长了,这里就不展开讲了,只说下IoC容器在处理依赖时是如何一步一步调用到getBean方法的,这样就和我们自己写的处理字段注入的逻辑对上了。

    protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    	// 删除与本次分析无关代码...
    	PropertyDescriptor[] filteredPds = null;
    	if (hasInstAwareBpps) {
    		if (pvs == null) {
    			pvs = mbd.getPropertyValues();
    		}
    		// 遍历所有已注册的BeanPostProcessor接口实现类,如果实现类是InstantiationAwareBeanPostProcessor接口类型的,调用其postProcessProperties方法。
    		for (BeanPostProcessor bp : getBeanPostProcessors()) {
    			if (bp instanceof InstantiationAwareBeanPostProcessor) {
    				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
    				PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
    				// 删除与本次分析无关代码...
    				pvs = pvsToUse;
    			}
    		}
    		// 删除与本次分析无关代码...
    	}
    	
    }
    

    在Spring 中,@Autowired注解是由AutowiredAnnotationBeanPostProcessor类处理,而@Resource注解是由CommonAnnotationBeanPostProcessor类处理,这两个类都实现了InstantiationAwareBeanPostProcessor接口,都是在覆写的postProcessProperties方法中完成了依赖注入。这里我们就分析@Autowired注解的处理。

    // AutowiredAnnotationBeanPostProcessor#postProcessProperties
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
    		// 根据beanName以及bean的class去查找Bean的依赖元数据-InjectionMetadata 
    		InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
    		try {// 调用inject方法
    			metadata.inject(bean, beanName, pvs);
    		} catch (BeanCreationException ex) {
    			throw ex;
    		} catch (Throwable ex) {
    			throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
    		}
    		return pvs;
    	}
    

    在InjectionMetadata的inject方法中,获取当前Bean所有需要处理的依赖元素(InjectedElement),这是一个集合,遍历该集合,调用每一个依赖注入元素的inject方法。

    // InjectionMetadata#inject
    public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
    	// 获取当前Bean所有的依赖注入元素(可能是方法,也可能是字段)
    	Collection<InjectedElement> checkedElements = this.checkedElements;
    	Collection<InjectedElement> elementsToIterate =
    			(checkedElements != null ? checkedElements : this.injectedElements);
    	if (!elementsToIterate.isEmpty()) {
    		// 如果当前Bean的依赖注入项不为空,遍历该依赖注入元素
    		for (InjectedElement element : elementsToIterate) {
    			// 调用每一个依赖注入元素的inject方法。
    			element.inject(target, beanName, pvs);
    		}
    	}
    }
    

    在AutowiredAnnotationBeanPostProcessor类中定义了两个内部类-AutowiredFieldElement、AutowiredMethodElement继承自InjectedElement,它们分别对应字段注入和方法注入。

    以大家常用的字段注入为例,在AutowiredFieldElement的inject方法中,首先判断当前字段是否已经被处理过,如果已经被处理过直接走缓存,否则调用BeanFactory的resolveDependency方法来处理依赖。
    // AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject
    protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
    		Field field = (Field) this.member;
    		Object value;
    		if (this.cached) {// 如果当前字段已经被处理过,直接从缓存中获取
    			value = resolvedCachedArgument(beanName, this.cachedFieldValue);
    		} else {
    			// 构建依赖描述符
    			DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
    			desc.setContainingClass(bean.getClass());
    			Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
    			Assert.state(beanFactory != null, "No BeanFactory available");
    			TypeConverter typeConverter = beanFactory.getTypeConverter();
    			try {// 调用BeanFactory的resolveDependency来解析依赖
    				value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
    			} catch (BeansException ex) {
    				throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
    			}
    			// 删除与本次分析无关代码....
    		}
    		if (value != null) {
    			// 通过反射来对属性进行赋值
    			ReflectionUtils.makeAccessible(field);
    			field.set(bean, value);
    		}
    	}
    }
    

    在DefaultListableBeanFactory实现的resolveDependency方法,最终还是调用doResolveDependency方法来完成依赖解析的功能。在Spring源码中,如果存在do什么什么方法,那么该方法才是真正干活的方法。

    // DefaultListableBeanFactory#resolveDependency
    public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
    			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
    		// .....
    		// 如果在字段(方法)上添加了@Lazy注解,那么在这里将不会真正的去解析依赖
    		Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
    				descriptor, requestingBeanName);
    		if (result == null) {
    			// 如果未添加@Lazy注解,那么则调用doResolveDependency方法来解析依赖
    			result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
    		}
    		return result;
    }
    
    // DefaultListableBeanFactory#doResolveDependency
    public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
    			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
    
    	//.....
    	try {
    		// 根据名称以及类型查找合适的依赖
    		Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
    		if (matchingBeans.isEmpty()) {// 如果未找到相关依赖
    			if (isRequired(descriptor)) { // 如果该依赖是必须的(例如@Autowired的required属性),直接抛出异常
    				raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
    			}
    			return null;
    		}
    
    		String autowiredBeanName;
    		Object instanceCandidate;
    		// 如果查找到的依赖多于一个,例如某个接口存在多个实现类,并且多个实现类都注册到IoC容器中。
    		if (matchingBeans.size() > 1) {// 决定使用哪一个实现类,@Primary等方式都是在这里完成
    			autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
    			if (autowiredBeanName == null) {
    				if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
    					return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
    				} else { 
    					return null;
    				}
    			}
    			instanceCandidate = matchingBeans.get(autowiredBeanName);
    		} else {
    			// We have exactly one match.
    			Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
    			autowiredBeanName = entry.getKey();
    			instanceCandidate = entry.getValue();
    		}
    
    		if (autowiredBeanNames != null) {
    			autowiredBeanNames.add(autowiredBeanName);
    		}
    		// 如果查找到的依赖是某个类的Class(通常如此),而不是实例,
    		//调用描述符的方法来根据类型resolveCandidate方法来获取该类型的实例。
    		if (instanceCandidate instanceof Class) {
    			instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
    		}
    		//...
    }
    

    在依赖描述符的resolveCandidate方法中,是通过调用BeanFactory 的getBean方法来完成所依赖Bean实例的获取。

    // DependencyDescriptor#resolveCandidate
    public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)
    			throws BeansException {
    
    	return beanFactory.getBean(beanName);
    }
    

    而在getBean方法实现中,依然是通过调用doGetBean方法来完成。这也和我们自己写的依赖处理基本一致,只不过我们自己写的比较简单,而Spring要考虑和处理的场景复杂,因此代码比较繁杂,但大体思路都是一样的。

    // AbstractBeanFactory#getBean
    public Object getBean(String name) throws BeansException {
    	return doGetBean(name, null, null, false);
    }
    

    重点是前面我们写的处理循环依赖的Demo,如果理解那个代码,再看Spring的循环依赖处理,就会发现很简单。

    总结

    循环依赖就是指两个Bean之间存在相互引用关系,例如A依赖B,B又依赖A,但Spring只能解决属性循环依赖,不能解决构造函数循环依赖,这种场景也无法解决。

    Spring解决循环依赖的关键就是在处理Bean的属性依赖时,先将Bean存到三级缓存中,当存在循环依赖时,从三级缓存中获取到相关Bean,然后从三级缓存中移除,存入到二级缓存中,最后初始化完毕后存入到一级缓存中。

    展开全文
  • 姐: s->next = p;s->prior = p->prior;p->prior->next = s;p->prior = s

    姐:

    s->next = p;s->prior = p->prior;p->prior->next = s;p->prior = s
    在这里插入图片描述

    展开全文
  • 《剑offer》刷题笔记(递归和循环):矩形覆盖 转载请注明作者和出处:http://blog.csdn.net/u011475210 代码地址:https://github.com/WordZzzz/Note/tree/master/AtOffer 刷题平台:https://www.nowcoder.com/ ...

    《剑指offer》刷题笔记(递归和循环):矩形覆盖



    题目描述:

    我们可以用2 * 1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2 * 1的小矩形无重叠地覆盖一个2 * n的大矩形,总共有多少种方法?

    解题思路:

    和跳台阶的解题思路是一样的。

    对于2 * n的矩形,第一步有2种覆盖方法:横着放一个2 * 1的矩形、竖着放两个2 * 1的矩形;
    横着放一个2 * 1的矩形,剩下2 * n-1的矩形,则剩下覆盖方法是f(n-1)
    竖着放两个2 * 1的矩形,剩下2 * n-2的矩形,则剩下覆盖方法是f(n-2)
    所以f(n)=f(n-1)+f(n-2)。
    其中:f(1) = 1, f(2) = 2。

    实现f(n)=f(n-1)+f(n-2)的方法有很多种,递归、循环都可以。

    注意:由于递归比较耗费时间,加上python的运行效率本来就低,所以python的递归调用一般在牛客网的实例测试中下总是超时。

    C++版代码实现:

    递归:

    class Solution {
    public:
        int rectCover(int number) {
            if(number <= 0)
                return 0;
            else if(number < 3)
                return number;
            else
                return rectCover(number-1)+rectCover(number-2);
        }
    };

    循环:

    class Solution {
    public:
        int rectCover(int number) {
            if(number <= 0)
                return 0;
            else if(number < 3)
                return number;
            int first = 1, second = 2, third = 0;
            for (int i = 3; i <= number; i++) {
                third = first + second;
                first = second;
                second = third;
            }
            return third;
        }
    };

    Python 代码实现:

    递归:

    # -*- coding:utf-8 -*-
    class Solution:
        def rectCover(self, number):
            # write code here
            if number <= 0:
                return 0
            elif number < 3:
                return number
            else:
                return self.rectCover(number-1) + self.rectCover(number-2)

    循环:

    # -*- coding:utf-8 -*-
    class Solution:
        def rectCover(self, number):
            # write code here
            if number <= 0:
                return 0
            elif number < 3:
                return number
            first = 1
            second = 2
            third = 0
            for i in range(3,number+1):
                third = first + second
                first = second
                second = third
            return third

    系列教程持续发布中,欢迎订阅、关注、收藏、评论、点赞哦~~( ̄▽ ̄~)~

    完的汪(∪。∪)。。。zzz

    展开全文
  • 《剑offer》刷题笔记(递归和循环):跳台阶 转载请注明作者和出处:http://blog.csdn.net/u011475210 代码地址:https://github.com/WordZzzz/Note/tree/master/AtOffer 刷题平台:https://www.nowcoder.com/ 题...

    《剑指offer》刷题笔记(递归和循环):跳台阶



    题目描述:

    一只青蛙一次可以跳上1级台阶,也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

    解题思路:

    对于n级台阶,第一步有2种跳法:跳1级、跳2级;
    跳1级,剩下n-1级,则剩下跳法是f(n-1)
    跳2级,剩下n-2级,则剩下跳法是f(n-2)
    所以f(n)=f(n-1)+f(n-2)。

    实现f(n)=f(n-1)+f(n-2)的方法有很多种,递归、循环都可以。

    C++版代码实现:

    递归:

    class Solution {
    public:
        int jumpFloor(int number) {
            if(number <= 0)
                return 0;
            else if(number < 3)
                return number;
            else
                return jumpFloor(number-1)+jumpFloor(number-2);
        }
    };

    循环:

    class Solution {
    public:
        int jumpFloor(int number) {
            if(number <= 0)
                return 0;
            else if(number < 3)
                return number;
            int first = 1, second = 2, third = 0;
            for (int i = 3; i <= number; i++) {
                third = first + second;
                first = second;
                second = third;
            }
            return third;
        }
    };

    Python 代码实现:

    递归:

    # -*- coding:utf-8 -*-
    class Solution:
        def jumpFloor(self, number):
            # write code here
            if number <= 0:
                return 0
            elif number < 3:
                return number
            else:
                return self.jumpFloor(number-1) + self.jumpFloor(number-2)

    循环:

    # -*- coding:utf-8 -*-
    class Solution:
        def jumpFloor(self, number):
            # write code here
            if number <= 0:
                return 0
            elif number < 3:
                return number
            first = 1
            second = 2
            third = 0
            for i in range(3,number+1):
                third = first + second
                first = second
                second = third
            return third;

    系列教程持续发布中,欢迎订阅、关注、收藏、评论、点赞哦~~( ̄▽ ̄~)~

    完的汪(∪。∪)。。。zzz

    展开全文
  • 《剑offer》刷题笔记(递归和循环):变态跳台阶 转载请注明作者和出处:http://blog.csdn.net/u011475210 代码地址:https://github.com/WordZzzz/Note/tree/master/AtOffer 刷题平台:https://www.nowcoder.com/...
  • 事物周而复始地运动或变化。意思是转了一圈又一圈,一次又一次地循回。**循环 ,是C语言编程里非常重要的结构。使用循环,可以帮我们快速解决类似的、需要重复实现、处理的问题。以下分享学习C语言三种常见循环:...
  • 循环

    万次阅读 2016-09-19 13:47:34
    循环码     循环码是线性分组码的一个重要子集,是目前研究得最成熟的一类码。... 循环码最大的特点就是码字的循环特性,所谓循环特性是循环码中任一许用码组经过循环移位,所 得到的码组仍然是许用码组
  • 所谓的循环无关代码(Loop-invariant Code),的是循环中值不变的表达式。 如果能够在不改变程序语义的情况下,将这些循环无关代码提出循环之外,那么程序便可以避免重复执行这些表达式,从而达到性能提升的效果。...
  • Scala 循环

    千次阅读 2014-05-23 17:07:24
    Scala 循环
  • Java--for循环之双层循环嵌套 执行流程

    万次阅读 多人点赞 2017-07-30 15:44:38
    循环嵌套是在一个循环语句中再定义一个循环语句的语法结构。     while、do.. while和for循环语句都可以进行嵌套,并且他们之间可以进行互相嵌套。最常见的是在for循环中嵌套for循环。格式如下 for (初始...
  • 什么有校验码的存在? 计算机系统运行时,各个部之间要进行数据交换.交换的过程中,会有发生误码的可能(即0变成1或1变成0),由于计算机的储存是通过二进制代码来实现的的,误码会导致储存的内容发生改变。为确保...
  • 这个单循环链表(头指针在头结点)。强调:数据结构不是为了会写程序,只是利用程序设计语言来掌握一种思想。//单循环链表 Year:2011 Month:Three data: 24 #include #include #include using namespace s
  • 当变成循环队列之后,删除元素的空间仍然可以利用,最大限度的利用空间。 判断方式: 1、采用计数器来判断,空时,计数器为0,满时,计数器为maxsize。 2、另设一个布尔变量以匹别队列的空和满。 3、少用一个...
  • 循环链表

    千次阅读 2017-09-08 14:50:09
    通常链表都是一条龙,现在首尾相连,使得从结尾又能一下子跳回到开头,这就是循环链表 这里从以下几个方面阐述循环链表: 重要方法分析全部代码 一.重要方法分析 这里的链表实现了我博客中的接口 ...
  • 前言 循环依赖:就是N个类循环(嵌套)引用。...另需注意:这里循环引用不是方法之间的循环调用,而是对象的相互依赖关系。(方法之间循环调用若有出口也是OK的) 可以设想一下这个场景:如果在日常开发中我们...
  • //返回L第n个节点(n可超过L的总节点个数) LNode *creLNodePoint(CLinkList L, int n); //删除s的前驱节点 void delPrior(LNode *s);
  • Kotlin for 循环使用

    千次阅读 2019-05-09 15:58:27
    Kotlin 的for循环使用的是in 先写2个中java的for循环 //普通写法 String [] array ={"苹果","香蕉","菠萝"}; for (int i=0;i<array.length;i++){ System.out.println(array[i]); } //for each 写法 Stri...
  • 理解 Python 的 for 循环

    万次阅读 多人点赞 2019-04-19 21:18:55
    在本篇博客中,我们将讨论 Python 中 for 循环的原理。 我们将从一组基本例子和它的语法开始,还将讨论与 for 循环关联的 else 代码块的用处。 然后我们将介绍迭代对象、迭代器和迭代器协议,还会学习如何创建自己...
  • 首先你要确定for和while里面的各个字段分别表示什么含义: Python 中的循环语句有 2 种,分别是 while 循环和 for 循环 for 循环语句的执行流程如图 1 所示。 for 循环语句的执行流程图 图 1 for 循环语句的执行...
  • 在成功的加密项目中,激励循环(Incentive Loops)是很常见的。最棒的加密货币平台或代币通常都内置了鲁棒性(Robust)很好的激励循环(机制)。通过有机增长方式(译者注:Organic growth-有机增长,是一个公司...
  • Oracle 循环语句

    千次阅读 2013-07-20 17:28:46
    1、基本循环  在PL/SQL中最简单格式的循环语句是基本循环语句,这种循环语句以LOOP开始,以END LOOP结束,其语法如下:  LOOP statement1; ... EXIT [WHEN condition]; 注意:当编写基本循环时,一定要包含...
  • do…while循环 while循环 for循环
  • Java for循环及嵌套for循环详解

    千次阅读 2020-07-04 17:10:34
    概述:循环结构是在程序中需要反复执行某个功能而设置的一种程序结构。 形式: for(开始条件;循环条件;更改条件){ 循环体代码… } 案例解析(1):** 源代码如下: package cn.tedu.dayfour; public class ...
  • python:while循环、for循环

    千次阅读 多人点赞 2018-03-17 22:59:56
    循环: 在python编程中,python提供了for循环和while循环 while循环: 基本语法为: while 判断条件: 执行语句...... 1、while循环用于循环执行程序,以处理需要重复处理的任务。 2、while循环用于多次...
  • 单链表、循环链表、双向循环链表总结

    千次阅读 多人点赞 2019-11-23 18:56:31
    链表介绍 不带头结点的单向链表 带头结点的单向链表 循环链表 双向循环链表
  • (2)可以使用带标签的break,相当于goto,比如break a的是退出a所在的循环。但是不建议使用这种方法,因为跳多了出不来。** 举例子:int i=0; int j=0; a: for(;i&amp;lt;10;i++){ b:for(;...
  • nodejs事件和事件循环简介

    万次阅读 2020-12-06 21:37:03
    我们在javascript中监听这些事件,从而触发相应的处理。 同样的nodejs中也有事件,并且还有一个专门的events模块来进行专门的...同时事件和事件循环也是nodejs构建异步IO的非常重要的概念。 今天我们来详细了解一下。
  • SoundPool循环播放

    千次阅读 2018-02-02 20:14:27
    SoundPool循环播放 ...然后自己看了看文档,自己写了一个小东西,供大家参考,如有错误,请出来本人虚心改正。接下来请看 /** * 音频播放管理器 * * @author 79442 * @date 2018/2/2 */
  • Spring-bean的循环依赖以及解决方式

    万次阅读 多人点赞 2017-09-12 08:18:21
    什么循环依赖? 怎么检测循环依赖 Spring怎么解决循环依赖 Spring对于循环依赖无法解决的场景 Spring解决循环依赖的方式我们能够学到什么? 1. 什么循环依赖?循环依赖其实就是循环引用,也就是两个或则...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 657,214
精华内容 262,885
关键字:

后循环是指什么