精华内容
下载资源
问答
  • 多层for循环优化

    千次阅读 2019-05-12 13:33:51
    1.6.1 找出最大周长的三角形 /*可以用穷举找出最长,三重循环。*/ for (i = 0; i ;++i) { for (j = i + 1; j ; ++j) { for (k = j + 1; k ; ++k) { len = b[i] + b[j] + b[k]; m
    • 1.6.1 找出最大周长的三角形
    /*可以用穷举找出最长,三重循环。*/
    for (i = 0; i < a;++i) {
    		for (j = i + 1; j < a; ++j) {
    			for (k = j + 1; k < a; ++k) {
    				len = b[i] + b[j] + b[k];
    				ma = max(b[i], max(b[j], b[k]));
    				ans = len - ma;
    				if (ma < ans) { z = max(z, len); }
    			}
    	}
    	}
    

    • 1.6.2 Ants(POJ No.1852)
      Description
      An army of ants walk on a horizontal pole of length l cm, each with a constant speed of 1 cm/s. When a walking ant reaches an end of the pole, it immediatelly falls off it. When two ants meet they turn back and start walking in opposite directions. We know the original positions of ants on the pole, unfortunately, we do not know the directions in which the ants are walking. Your task is to compute the earliest and the latest possible times needed for all ants to fall off the pole.
    /*2只蚂蚁相遇,把它看成相遇后还是沿原方向前行结果也是一样的*/
    for (i = 0; i < n; ++i) {
    		mint = max(mint, min(x[i], L - x[i]));
    	}
    for (i = 0; i < n; ++i) {
    		maxt = max(maxt, max(x[i], L - x[i]));
    	}
    

    • 1.6.3 抽签问题
      你的朋友提议玩一个游戏,将写有数字的n个纸片放入口袋中,你可以从口袋中抽取4次纸片,每次记下纸片上的数字后都将其放回口袋中,如果这四个数字的和为m,
      就是你赢,否则就是你的朋友赢,你挑战了好几次,结果一次也没有赢,于是撕破口袋,取出所有的纸片,检查自己是否有赢的可能性。
      请编写一个程序,判断当纸片上写的数字是K1,K2,K3,…,Kn 时,是否存在抽取四次和为m的情况,如果存在,输出Yes,若不存在,输出No。
    /*如果n在合理范围内,可以直接四重循环穷举(循环:n^4)*/ 
    bool f = false;
    	for (a = 0; a < n;++a) {
    		for (b =0; b < n;++b) {
    			for (c = 0; c < n;++c) {
    				for (d = 0; d < n;++d) {
    					if (k[a] + k[b] + k[c]+k[d]==m) {f = true;}
    				}
    		     }
    		  }
    	   }
    
    /*如果n过大,四重循环效率太慢,我们可以用二分搜索算法替换最内侧的循环*/
    //循环:n^3logn ;排序:nlogn
    bool binary_search(int *a,int n,int key) {
    	int low, high,mid;
    	bool f = false;
    	low = 0;
    	high = n;
    	while (low <= high) {
    		mid = (low + high) / 2;
    		if (key < a[mid]) { high = mid - 1; }
    		else if (key > a[mid]) { low = mid + 1; }
    		else {f = true; break;}
    	}
    	return f;
    }
    ----------
    sort(k,k+n);
    bool f = false;
    	for (a = 0; a < n;++a) {
    		for (b = 0; b < n;++b) {
    			for (c =0; c < n;++c) {
    if (binary_search(k, n, m - (k[a] + k[b] + k[c])))
                                                     { f = true;}
    		     }
    		  }
    	   }
    
    /*同样道理,我们可以尝试用二分搜索来替换内侧两重循环;(循环:n^2logn;排序:n^2logn)*/
    //先将内侧两重循环排好序
    for (i = 0; i < n; ++i) {
    		for (int j = 0; j < n;++j) {
    			kk[i*n+j] = k[i] + k[j];
    		} 
    	}
    	sort(kk,kk+n*n);
    //再来搜索
    bool f = false;
    	for (a = 0; a < n;++a) {
    		for (b = 0; b < n;++b) {
    				if (binary_search(kk,kk+n*n, m - (k[a] + k[b]))) { f = true; }        
    		  }
    	   }	
    
    展开全文
  • for循环优化

    千次阅读 2019-08-24 18:29:56
    一、多个for循环,遵循外小内大 stratTime=System.nanoTime(); for(inti=0;i<10000000;i++){ for(intj=0;j<10;j++){ } } endTime=System.nanoTime(); System.out.p...

    一、多个for循环,遵循外小内大

    stratTime = System.nanoTime();  
    for (int i = 0; i < 10000000; i++) {  
        for (int j = 0; j < 10; j++) {  
              
        }  
    }  
    endTime = System.nanoTime();  
    System.out.println("外大内小耗时:"+ (endTime - stratTime));  

    改为:

    stratTime = System.nanoTime();  
    for (int i = 0; i <10 ; i++) {  
        for (int j = 0; j < 10000000; j++) {  
              
        }  
    }  
    endTime = System.nanoTime();  
    System.out.println("外小内大耗时:"+(endTime - stratTime)); 
    

    消耗时间对比:

    外大内小耗时:200192114  
    外小内大耗时:97995997

    原因:

    两者的循环次数是一直的,造成性能差异,主要是实例化次数和初始化次数不一样。

     

    二、提取与循环无关的表达式到循环外

    stratTime = System.nanoTime();  
    for (int i = 0; i < 10000000; i++) {  
        i=i*a*b;  
    }  
    endTime = System.nanoTime();  
    System.out.println("未提取耗时:"+(endTime - stratTime)); 
    

    改为:

    stratTime = System.nanoTime();  
    c = a*b;  
    for (int i = 0; i < 10000000; i++) {  
        i=i*c;  
    }  
    endTime = System.nanoTime();  
    System.out.println("已提取耗时:"+(endTime - stratTime)); 

    耗时对比:

    未提取耗时:45973050  
    已提取耗时:1955

     

    三、消除循环终止时的方法调用

    stratTime = System.nanoTime();  
    for (int i = 0; i < list.size(); i++) {  
          
    }  
    endTime = System.nanoTime();  
    System.out.println("未优化list耗时:"+(endTime - stratTime)); 

    改为:

    stratTime = System.nanoTime();  
    int size = list.size();  
    for (int i = 0; i < size; i++) {  
          
    }  
    endTime = System.nanoTime();  
    System.out.println("优化list耗时:"+(endTime - stratTime));

    耗时对比:

    未优化list耗时:27375  
    优化list耗时:2444

     

    四、异常捕获

    stratTime = System.nanoTime();  
    for (int i = 0; i < 10000000; i++) {  
        try {  
        } catch (Exception e) {  
        }  
    }  
    endTime = System.nanoTime();  
    System.out.println("在内部捕获异常耗时:"+(endTime - stratTime)); 

    改为:

    stratTime = System.nanoTime();  
    try {  
        for (int i = 0; i < 10000000; i++) {  
        }  
    } catch (Exception e) {  
      
    }  
    endTime = System.nanoTime();  
    System.out.println("在外部捕获异常耗时:"+(endTime - stratTime)); 

    耗时对比:

    在内部捕获异常耗时:12150142  
    在外部捕获异常耗时:1955

     

    五、拆分为多个循环

    https://www.cnblogs.com/yulinlewis/p/9784693.html

    展开全文
  • 层For循环的一些性能优化

    千次阅读 2019-07-03 15:08:51
    //方法 /*Map, User> map = new HashMap(); for (int i = 0; i (); i++) { map.put(list1.get(i).getAge(), list1.get(i)); } for (int j =0; j (); j ++) { //Map, Integer> map1 = new HashMap(); //...
    import JavaBase.User;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    import java.util.function.Function;
    import java.util.stream.Collectors;
    
    /**
     * @author 633805 LYH
     * @version V1.0
     * @description 对类的描述
     * @create 2019-07-02 20:37
     * @since 1.7
     */
    public class ForTest {
    
        public static void main(String[] args) {
    
    
            List<User> list1 = new ArrayList<>();
    
    
    
            List<User> list2 = new ArrayList<>();
    
            long start = System.currentTimeMillis();
    
            for (int i =0 ; i< 5000; i++){
                User user = User.builder().name("lyh"+i).age(12 + i).build();
    
                list1.add(user);
            }
    
            for (int i =0 ; i< 5000; i++) {
    
                User user2 = User.builder().age(12 + i).build();
    
                list2.add(user2);
            }
    
            //方法一
            /*for (User us : list1 ) {
    
                for(User user : list2) {
                    if (user.getAge() == us.getAge()) {
                        user.setName(us.getName());
                    }
                }
            }*/
    
            //方法二
            /*for(int i =0 ; i < list1.size(); i++) {
                for (int j = 0; j < list2.size(); j++) {
                    if (list1.get(i).getAge().equals(list2.get(j).getAge())) {
                        list2.get(j).setName(list1.get(i).getName());
                    }
                }
            }*/
    
            //方法三
            /*int i, j, leni, lenj;
            for( i =0 , leni = list1.size(); i < leni; i++) {
                for ( j = 0, lenj = list2.size(); j < lenj; j++) {
                    if (list1.get(i).getAge().equals(list2.get(j).getAge())) {
                        list2.get(j).setName(list1.get(i).getName());
                    }
                }
            }*/
    
            //方法四
            /*Map<Integer, User> map = new HashMap<>();
            for (int i = 0; i < list1.size(); i++) {
                map.put(list1.get(i).getAge(), list1.get(i));
            }
    
            for (int j =0; j < list2.size(); j ++) {
                //Map<User, Integer> map1 = new HashMap<>();
                //map1.put(list2.get(j), list2.get(j).getAge());
    
                if (map.get(list2.get(j).getAge()) != null) {
                    list2.get(j).setName( map.get(list2.get(j).getAge()).getName() );
                }
            }*/
    
            //方法五
            Map<Integer, User> map = list1.stream().collect(Collectors.toMap(User::getAge, Function.identity() , (key1, key2) -> key2));
    
            list2 = list2.stream().map(user -> {
                Integer age = user.getAge();
                User user1 = map.get(age);
                user.setName(user1.getName());
                return user;
            }).collect(Collectors.toList());
    
            list1.addAll(list2);
    
            list1.forEach(System.out::println);
    
            System.out.println(list1.size());
    
            System.out.println(System.currentTimeMillis() - start);
    
    
        }
    }
    

     

    展开全文
  • JS之for循环优化

    千次阅读 2016-03-25 16:08:50
    其中for循环是最常见的循环结构,由部分组成:初始化、前测条件、后执行体、循环体。当代码运行遇到for循环时,先运行初始化代码,然后进入前侧条件。如果前侧条件为true,则运行循环体。循环体执行完后,后执行...
    众所周知Js中的循环大致可以分为4中: 
    
    1.for循环 
    Javascript代码   收藏代码
    1. for(var i=0;i<10;i++){  
    2.   //循环主题  
    3. }  

    其中for循环是最常见的循环结构,由四部分组成:初始化、前测条件、后执行体、循环体。当代码运行遇到for循环时,先运行初始化代码,然后进入前侧条件。如果前侧条件为true,则运行循环体。循环体执行完后,后执行代码开始运行。 
    2. while 循环  
    while循环是最简单的前测循环,有一个前测条件和一个循环体构成: 
    Javascript代码   收藏代码
    1. var  i = 0;  
    2. while(i < 10){  
    3.    //循环主题  
    4.    i++;  
    5. }  

    3. do..while循环  
    do-while 循环是js中唯一一种后测循环,由两部分组成,循环体和后测条件 
    Javascript代码   收藏代码
    1. var i = 0;  
    2. do{  
    3.     //循环体  
    4. }while(i++ < 10)  

    在do-while中至少会执行一次循环体 
    4 for-in循环 
    该循环有一个特别的用途:可以枚举任何对象的属性名。 
    Javascript代码   收藏代码
    1. for(var prop in object){  
    2.    //循环体  
    3. }  

    循环体每次运行时,prop变量被赋值为object的一个属性名,直到所有属性遍历完成才返回。所返回的属性包括对象实例属性和从原型链中继承而来的属性 

    以后对4中循环进行了大致的介绍,接下来说说如何在进行相关系能提升 
    4中循环类型中,只有for-in循环比其他几种明显要慢:主要原因在于每次迭代操作会同时搜索实例或原型属性,每次迭代都会产生更多开销。 

    如果循环类型与性能无关,可以从以下两个可选因素来提高整体性能 
    1.每次迭代处理的事务 
    2.迭代的次数 

    减少迭代的工作量 
    很明显,如果一次循环迭代要花很长时间去执行,那么多次循环需要花更多的时间。一个提升循环整体速度的好方法就是限制循环中耗时的操作数量。 
    一个典型的数组处理循环可以采用三种循环中的任何一种。最常见的写法如下: 
    Javascript代码   收藏代码
    1. for(var i = 0; i < items.length; i++){  
    2.     process(items[i]);  
    3. }  
    4.   
    5. var j = 0;  
    6. while(j < items.length){  
    7.     process(items[j]);  
    8. }  
    9.   
    10. var k = 0;  
    11. do{  
    12.    process(items[k]);  
    13. }while(k < items.length);  

       上面的每个循环中,每次进行循环体时都会产生如下操作: 
       1. 一次控制条件中的属性查找(items.length) 
       2. 一次控制条件中的数值大小的比较(i<items.length) 
       3. 一次控制条件结果是否为true的比较(i<items.length == true) 
       4. 一次自增操作(i++) 
       5. 一次数组查找(items[i]) 
       6. 一次函数调用( process(items[j]);) 

       这些简单循环中,尽管代码不多,但每次迭代都要进行许多操作。代码运行速度很大晨读上取决于函数process()对每个数组项的操作,尽管如此,减少每次迭代中的操作能大幅提高循环的整体性能。 
       优化循环的第一步就是减少对象成员及数组项的查找次数。前面例子中每次循环都要查找items.length,这样做很耗时,由于该值在循环运行过程中从未变过,因此产生了不必要的性能损失,提高整个循环的性能很简单,只查找一次属性,并把值存储到一个局部变量中,然后在控制条件中使用整个变量 
    Javascript代码   收藏代码
    1. for(var i = 0,len = item.length; i < len; i++){  
    2.     process(items[i]);  
    3. }  
    4.   
    5. var j = 0,  
    6.     len = items.length;  
    7. while(j < len ){  
    8.     process(items[j]);  
    9. }  
    10.   
    11. var k = 0,  
    12.     num = items.length;  
    13. do{  
    14.    process(items[k]);  
    15. }while(k < num);  


       还可以通过倒序循环来进行。 

    减少迭代次数 
       
       即使是循环体中最快的代码,累计迭代上千次也会慢下来。此外,循环体运行时也会带来小性能开销,不仅仅是增加总体运行时间。减少迭代次数能获得更加显著的性能提升。下面介绍一种广为人知的限制循环迭代次数的模式被称为“达夫设备(Duff's Device)”: 
       Duff's Device 是一个循环体展开技术,使得一次迭代实际执行了多次迭代的操作 
      
    Javascript代码   收藏代码
    1. var iterations = Math.floor(items.length/8),  
    2.     startAt = items.length%8,  
    3.     i = 0;  
    4. do{  
    5.     switch(startAt){  
    6.         case 0 : process(items[i++]);  
    7.         case 7 : process(items[i++]);  
    8.         case 6 : process(items[i++]);  
    9.         case 5 : process(items[i++]);  
    10.         case 4 : process(items[i++]);  
    11.         case 3 : process(items[i++]);  
    12.         case 2 : process(items[i++]);  
    13.         case 1 : process(items[i++]);  
    14.     }  
    15.     startAt =  0;  
    16.  }while(--iterations);  
    展开全文
  • for循环优化的基本概念、对for循环施行流水的优化、for循环的展开以及for循环的循环变量的数据类型是否对结果资源有影响 1. 流水线优化 2. for循环的展开 默认情况下for循环是被折叠的,所谓折叠可以理解...
  • 问题产生的背景是:数据库中有一字段 errorlist 内容为(举例):1,2,3,4... ...17-47更新(其实外侧还有循环导出十条 最外侧foreach 就是十次,最多一次导出一百条) 请教各位大神,我该如何优化
  • 前言我们都经常使用一些循环耗时计算的操作,特别是for循环,它是一种重复计算的操作,如果处理不好,耗时就比较大,如果处理书写得当将大大提高效率,下面总结几条for循环的常见优化方式。首先,我们初始化一个集合...
  • for循环嵌套优化

    千次阅读 2018-07-17 10:34:55
    最近生成密码字典的时候遇到了多层for循环嵌套的问题,如下 for (int i = 0; i &amp;lt; 1000; i++) for (int j = 0; j &amp;lt; 100; j++) for (int k = 0; k &amp;lt; 10; k++) testFunction ...
  • 嵌套For循环性能优化

    千次阅读 2019-08-05 16:40:50
    优化实例: for(int i = 0;i < 1000;i++){ for(int j = 0;j < 100;j++){ for(int k = 0; k < 10;k++){ System.out.print("hello world"); } } } 优化方案...
  • public class Test { public static void main(String[] args) { ... // 大循环在外面,小循环在里面,变量每次生成 long t = System.currentTimeMillis(); for (int i = 1; i ; i++) { for (int
  • 应用场景:当有两个相同list,或者部门内容相同,要比对两个list,每个list的大小都为1万,两层循环就是1万成1万次 list1.forEach(l1->{ list2.forEach(l2->{ //循环1万成1万次数 }); }); 我们的目的是...
  • 通过双层for循环输出九九乘法表

    千次阅读 2018-08-24 08:41:51
    一.实例说明: Java基本语法中的for循环非常灵活并且可以嵌套使用,其中双层for循环是程序开发中使用最频繁的,常用于操作表格数据,对于行数与列数相同的表格操作代码比较简...
  • 现在我想用多线程优化for循环,但是多线程的匿名内部类里面的全局变量只能是final的,final变量只能赋值一次啊,我就不能连续添加值到那个list里面了 怎么办?还有比如我现在开个线程,每个线程for循环一千次,...
  • 嵌套For循环性能优化分析

    万次阅读 多人点赞 2014-06-16 20:16:24
    转载:http://cgs1999.iteye.com/blog/1596671 1、案例描述 某日,在JavaEye上看到一道面试题,题目是这样的:请对以下的代码进行优化
  • Java多层循环优化

    2010-09-15 11:06:06
    代码如下: /* * 0.0.0 ~99.9.0 * 执行次数 100*10*1=1000次 * 执行时间 812 */ public void doThing(){ for(int i = 0;i
  • js-for循环的性能优化

    2020-11-23 15:33:21
    for :我能快!我还能快!我还能再快!
  • HLS中优化for循环总结!

    千次阅读 2020-06-23 17:40:45
    如果想要合并,应该采取以下的处理方法(这里假设有:J): 三、for循环优化之DATAFLOW 首先来看个简单的例子,正常的流程肯定是执行完A再执行B最后执行C: 如果按照上图的流程,肯定是串行处理的。这里就能用到...
  • JavaScript for循环for循环嵌套

    千次阅读 多人点赞 2017-09-18 20:03:17
    循环结构的概念 先来看看生活中的一些场景: (1)食堂阿姨打菜:接过顾客的餐盘→询问菜品→打菜→递回餐盘,重复以上过程,直到所有顾客的菜都打完了。 (2)快递员送快递:查看送件地址→赶往目的地→电话告知...
  • 双重大数组循环优化

    千次阅读 2018-03-04 19:19:19
    双重大数组循环优化 一、前言 这几天发现服务在凌晨时容易报警,持续半个小时才正常,第二天分析日志和检查代码发现,有一个过滤黑白名单的操作,其中黑名单的数据有39万,白名单数据30万,然后处理的数据也有80...
  • 多重循环性能优化

    千次阅读 2018-12-19 09:16:41
    优化后的多重for循环可以提升大半的效率。 方法 一、实例化变量尽量放在for循环体外,只实例化一次。 二、普通变量改为寄存器变量,如i++改为++i。前置递增运算避免了不必要的工作,它把值加1后直接返回改变了运算...
  • 之前对于使用多层嵌套for循环,一直以为只是对代码可读性和逻辑梳理有影响。可能对性能也有影响,但是一直不知道对性能影响在哪。最近在看虚拟机方面的书,感觉有一个点应该算多层嵌套for循环对jvm有影响,特此记录...
  • 多重循环优化

    千次阅读 2016-03-30 11:41:08
    平方和定理,又称为拉格朗日定理: 每个正整数都可以表示为至多4个正整数的平方和。 如果把0包括进去,就正好可以表示为4个数的平方和。 比如: 5 = 0^2 + 0^2 + 1^2 + 2^2 7 = 1^2 + 1^2 + 1^2 + 2^2 ...
  • python for 循环CPU满载

    千次阅读 2020-05-25 10:56:47
    就多写了几层for循环,除了风扇声音巨大,发热严重,倒是还没炸。估计会有其他的代码片段可以让CPU‘boom’,‘boom’。 while 1: for i in range(100000): print('第一层循环') for j in range(100000): print...
  • 利用for循环打印图形

    千次阅读 多人点赞 2019-03-30 11:41:01
    利用for循环打印图形时,我们需要记住外层循环列,内循环行,然后们需要做的不外乎是找到它们循环的规律罢了。 打印矩形图形 打印: ***** ***** ***** ***** 此图形是一个4行5列的矩形,比较简单 for(int i=1;i&...
  • MATLAB: 告别for循环

    万次阅读 2018-04-28 15:53:19
    在C语言的思路中,如果要对一个二维矩阵每个元素进行某种操作,似乎唯一的方法就是写两层for循环遍历整个矩阵。但是在MATLAB中,这种写法不仅代码量大,运行效率也极低。但是这绝不代表MATLAB时一门低效的语言。相反...
  • [TOC] 关于深度学习的一些理解的参考链接: ... 一、 基础知识 ...这样,我们一旦计算原函数的值,就可以用它来计算出导数的值。...二、循环神经网络 1)LSTM t.manual_seed(1000) inp...
  • OpenMP并行程序设计——for循环并行化详解

    万次阅读 多人点赞 2014-10-22 18:12:19
    在C/C++中使用OpenMP优化代码方便又简单,代码中需要并行处理的往往是一些比较耗时的for循环,所以重点介绍一下OpenMP中for循环的应用。个人感觉只要掌握了文中讲的这些就足够了,如果想要学习OpenMP可以到网上查查...
  • 专栏原创出处:github-源笔记文件 ,github-源码 ,欢迎...本节内容主要研究 for、foreach 循环的底层实现原理,再比较两种实现方式的性能。最后通过 RandomAccess 接口说明 JDK 让我们怎么去识别集合是否支持随机访...
  • 这样循环下去一共创建5个gameobjec,重复利用,实现显示N个条目。如图所示 只创建了5个GameObject,可以实现N个条目的显示。 2 详细设计 2.1 初始化滑动面板 void InitValue() { if (ConstraintCount ) ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 75,503
精华内容 30,201
关键字:

四层for循环优化