class  Demo
{
        public static void main(String[] args)
        {
                //计算1*1+2*2+3*3+...n*n
        System.out.println(count(100));
        }
        public static int count(int n){
       
        return n == 1 ? 1 : count(n-1) + n * n;//使用了递归,
        }
}
就是关于求平方和的,理解不是很透彻,希望高手赐教!

class Demo
{
               public static void main(String[] args)
        {
               
                int sum =getSum(4);
                System.out.println(sum);
               
        }

        public static int getSum(int n)
        {
                int s = 0;
                for(int i=0;i<=n;i++)
                {
                        s = s + i*i;
                }
                return s;
         }
}

1. class Demo {
   
2.                         public static void main(String[] args) {
   
3.                                 // 计算1*1+2*2+3*3+...n*n
   
4.                                 System.out.println(count(100));
   
5.                         }
   
6. 
   
7.                         /*
   
8.                          * 需求是计算出1*1+2*2+3*3+...n*n之和 return语句是三元表达式
   
9.                          * 可以理解为：
   
10.                          * if (n == 1){
    
11.                          *     return 1;
    
12.                          * } else {
    
13.                          *     return count(n - 1) + n * n;
    
14.                          * }
    
15.                          * 这里是用了递归算法，不断重复n * n的运算
    
16.                          * 根据传入的n = 100 ，count(n - 1) + n * n即100 * 100 + 99 * 99；
    
17.                          * 每次传入的值不断-1 ， 直到1为止 ，因1 * 1 ==1  ，则return 出 它们的和
    
18.                          */
    
19.                         public static int count(int n) {
    
20.                                 return n == 1 ? 1 : count(n - 1) + n * n;
    
21.                         }
    
22.                 }

复制代码

public static int count(int n){
        
        return n == 1 ? 1 : count(n-1) + n * n;//使用了递归,
        }
这句其实可以这样理解：
public static int count(int n){
          if(n==1)
          return n =1 ;
          return    n * n+count(n-1) ;
        }

递归 其实就是函数调用自己

理解这个很简单,只要代入几个值 验证一下 就可以发现规律 或者理解了!
比如说 你先设置n为3
函数为
public static int count(3)
{
     return n == 1 ? 1 : count(3-1) + 3 * 3; //这里的count(3-1) 即 又调用了 count(2)
}

public static int count(2)
{
     return n == 1 ? 1 : count(2-1) + 2 * 2;  //这里的count(2-1) 即 又调用了 count(1)
}

public static int count(1)
{
     return n == 1 ? 1 : count(2-1) + 2 * 2;  //这里当n=1时 return 1;
}

再总结
count(3)  return 的是 count(2)+3*3
count(2)  return 的是 count(1)+2*2
count(1)  return 的是 1
故 count(3) return 1+2*2+3*3 ;


但是递归要注意递归的次数。尽量避免内存溢出。(递归次数太多的话会造成调用函数太多)

return n == 1 ? 1 : count(n-1) + n * n;的意思是：如果n=1返回n=1     如果n！=1返回count(n-1) + n * n

求n的平方和就是n*n+（n-1）*（n-1）+（n-2）*（n-2）....2*2+1*1

class  Demo
{
        public static void main(String[] args) //这句话就不用讲了：主函数
        {
                //计算1*1+2*2+3*3+...n*n
        System.out.println(count(100));//输出递归调用后的函数值
        }
        public static int count(int n){
        
        return n == 1 ? 1 : count(n-1) + n * n;//使用了递归,当n=1时，返回n=1.否则调用count（n-1）+n*n的值。这样递归调用得出1*1+2*2+。。。+n*n的值。
        }
}

n == 1 ? 1 : count(n-1) + n * n;//使用了递归,
改成非递归：
int sum=0;
for(int i=1;i<=n;i++)
         sum+=i*i;