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

    2017-11-15 19:15:31
    该代码的性能优化就是尽可能减少循环变量i、j、k的实例化、初始化、比较、自增的次数,同时,不能引进其它可能的运算耗时。 解决过程 (1)优化方案一 for (int i = 0; i ; i++) for (int j = 0; j ...
    1. 首先我们看一段代码:

    复制代码
    for(int i=0;i<1000;i++){
    for(int j=0;j<100;j++){
    for(int k=0;k<10;k++){
    testFunction (i,j,k);
    }
    }
    }
    复制代码
    从给出的代码可知,不论如何优化,testFunction执行的次数都是相同的,该部分不存在优化的可能。那么,代码的优化只能从循环变量i、j、k的实例化、初始化、比较、自增等方面的耗时上进行分析。

    首先,我们先分析原题代码循环变量在实例化、初始化、比较、自增等方面的耗时情况:

    (注:由于单次耗时视不同机器配置而不同,上表相关耗时采用处理的次数进行说明)

    该代码的性能优化就是尽可能减少循环变量i、j、k的实例化、初始化、比较、自增的次数,同时,不能引进其它可能的运算耗时。

    1. 解决过程

    (1)优化方案一

    for (int i = 0; i < 10; i++)
    for (int j = 0; j < 100; j++)
    for (int k = 0; k < 1000; k++)
    testFunction (k, j, i);
    该方案主要是将循环次数最少的放到外面,循环次数最多的放里面,这样可以最大程度的(注:3个不同次数的循环变量共有6种排列组合情况,此种组合为最优)减少相关循环变量的实例化次数、初始化次数、比较次数、自增次数,方案耗时情况如下:

    原来代码中:i需要比较1000次,j需要比较1000*100次,k需要比较1000*100*10次。
    总的比较次数是1000+1000*100+10*100*1000次

    现在优化方案一:但是k需要比较10次,j需要比较10*100次,i需要比较10*100*1000次。
    总的比较次数是10+10*100+10*100*1000次
    所以后面的代码比前面的代码少比较1000+1000*100-(10+10*100)次!

    (2)优化方案二

    int i, j, k;
    for (i = 0; i < 10; i++)
    for (j = 0; j < 100; j++)
    for (k = 0; k < 1000; k++)
    testFunction (k, j, i);
    该方案在方案一的基础上,将循环变量的实例化放到循环外,这样可以进一步减少相关循环变量的实例化次数,方案耗时情况如下:

    变量 实例化(次数) 初始化(次数) 比较(次数) 自增(次数)
    i 1 1 10 10
    j 1 10 10 * 100 10 * 100
    k 1 10 * 100 10 * 100 * 1000 10 * 100 * 1000

    1. 总结

      从案例分析和解决过程中的三个表的分析可知,优化方案一和优化方案二的性能都比原代码的性能好,其中优化方案二的性能是最好的。在嵌套For循环中,将循环次数多的循环放在内侧,循环次数少的循环放在外侧,其性能会提高;减少循环变量的实例化,其性能也会提高。从测试数据可知,对于两种优化方案,如果在循环次数较少的情况下,其运行效果区别不大;但在循环次数较多的情况下,其效果就比较明显了。

    展开全文
  • list循环多重循环优化

    2020-05-14 17:08:34
    List,String>> list = new ArrayList(); //造数据 for(int i = 0;i;i++){ Map,String> m = new HashMap(); list.add(m);...利用map来进行获取 获取数据 效率要高于使用循环处理 尽量避免在循环中运算
      List<Map<String,String>> list = new ArrayList<>();
      	//造数据
           for(int i = 0;i<20000;i++){
               Map<String,String> m = new HashMap<>();
               list.add(m);
               m.put("count","test"+i);
           }
           //map 方式
           long start = System.currentTimeMillis();
            Map<String,String> map = new HashMap<>();
            for(Map<String,String> m:list){
                map.put(m.get("count"),m.get("count"));
            }
            for(Map<String,String> m:list){
                map.get(m.get("count"));
            }
            long end = System.currentTimeMillis();
            System.out.println(end-start);
            // list 方式取值
             start = System.currentTimeMillis();
           for(Map<String,String> m:list){
               for(Map<String,String> m1:list){
                   if(m1.get("count").equals(m.get("count"))){
                         m1.get("count");
                       break;
                   }
               }
           }
            end = System.currentTimeMillis();
            System.out.println(end-start);
    

    在这里插入图片描述

    List<Map<String,String>> list = new ArrayList<>();
            for(int i = 0;i<2000000;i++){
                Map<String,String> m = new HashMap<>();
                list.add(m);
                m.put("count","test"+i);
            }
            long start = System.currentTimeMillis();
            int len =  list.size();
            List<String> str = new ArrayList<>();
            str.add("1");
            str.add("2");
            str.add("3");
            str.add("5");
            str.add("7");
            str.add("7");
            str.add("9");
            str.add("10");
            str.add("11");
            final  boolean b =  str.contains("1");
            for (int i = 0; i < len; i++) {
                if(b){
                    list.get(i).get("count");
                }
            }
            long end = System.currentTimeMillis();
            System.out.println(end-start);
             start = System.currentTimeMillis();
    
            for (int i = 0; i < len; i++) {
                if(str.contains("1")){
                    list.get(i).get("count");
                }
            }
            end = System.currentTimeMillis();
            System.out.println(end-start);
    
    Connected to the target VM, address: '127.0.0.1:60132', transport: 'socket'
    
    47
    39
    
    
    Disconnected from the target VM, address: '127.0.0.1:60132', transport: 'socket'
    
    Process finished with exit code 0
    
    

    总结 利用map来进行获取 获取数据 效率要高于使用循环处理
    尽量避免在循环中运算

    展开全文
  • 二维前缀和预处理,四重循环超时。 最内层循环加 breakbreakbreak,AC代码: #include<iostream> #include<algorithm> #include<string> #include<cstdio> #include<cstring> #...

    题目链接:点击这里
    在这里插入图片描述
    在这里插入图片描述

    二维前缀和预处理,四重循环暴力超时。

    优化,最内层循环加 breakbreak,AC:

    #include<iostream>
    #include<algorithm>
    #include<string>
    #include<cstdio>
    #include<cstring>
    #include<cmath>
    #include<stack>
    #include<queue>
    #include<map>
    #include<set>
    
    using namespace std;
    typedef long long ll;
    const int MOD = 10000007;
    const int INF = 0x3f3f3f3f;
    const double PI = acos(-1.0);
    const int maxn = 300;
    int n, m, k, x;
    ll sum[maxn][maxn];
    
    int main()
    {
    	bool flag = false;
    	scanf("%d%d%d", &n, &m, &k);
    	for(register int i = 1; i <= n; ++i)
    	{
    		for(register int j = 1; j <= m; ++j)
    		{
    			scanf("%d", &x);
    			if(x<=k)	flag = true;
    			sum[i][j] = sum[i-1][j] + sum[i][j-1] - sum[i-1][j-1] + x;
    		}
    	}
    	
    	if(!flag)	//元素都大于k,无解 
    	{
    		printf("-1\n");
    		return 0;
    	}
    	
    	int ans = -1;
    	for(register int i = 1; i <= n; ++i)
    	{
    		for(register int j = i; j <= n; ++j)
    		{
    			for(register int q = 1; q <= m; ++q)
    			{
    				for(register int p = 1; p <= q; ++p)
    				{
    					int tmp = sum[j][q] - sum[j][p-1] - sum[i-1][q] + sum[i-1][p-1];//左上(i,p) 右下(j,q) 
    					if(tmp<=k)
    					{
    						ans = max(ans, (j-i+1)*(q-p+1));
    						break;	//小优化 
    					}
    				}	
    			}
    		}
    	}
    	printf("%d\n", ans);
    	return 0;
    }
    
    展开全文
  • public static function combine() { $data = array(); $args = func_get_args(); foreach ($args as $value) { if(is_array($value)) { $data[] = $value;
        public static function combine() {
    
            $data = array();
            $args = func_get_args();
    
            foreach ($args as $value) {
                if(is_array($value)) {
                    $data[] = $value;
                }else{
                    $data[] = array($value);
                }
            }
    
            //参数个数
            $total = count($data);
    
            if($total === 0 ) {
                return array();
            }elseif($total === 1) {
    
                return  is_array(current($data)) ?  current($data) :  array();
    
            }else{
    
                $result = array();
    
                $first = current($data);
                //弹出首个数组
                array_shift($data);
    
    
                if(is_array($data) === false){
                    return $result;
                }
    
                foreach ($first as $arg) {
    
                    $second = call_user_func_array('BiUtil::combine', $data);
    
                    foreach ($second as $a) {
                        if(is_array($a) === true) {
                            $result[] = array_merge(array($arg) , $a); 
                        }else{
    
                            $result[] = array($arg ,$a);
                        }
                    }
                }
    
                return $result;
            }
        }
    function combination(){
        $array = array();
        $arguments = func_get_args();
    
        //参数处理,这样可以模拟变长参数
        foreach($arguments as $argument){
            if(is_array($argument) === true){
                $array[] = $argument;
            }else{
                $array[] = array($argument);
            }
        }
    
        $size = count($array);
    
        if($size === 0){
            return array();
        }else if($size === 1){
    
            return is_array($array[0]) === true ? $array[0] : array();
        }else{
            $result = array();
            $a      = $array[0];
            array_shift($array);
    
            if(is_array($array) === false){
                return $result;
            }
    
            foreach($a as $val){
                $b = call_user_func_array("combination", $array);
    
                foreach($b as $c){
    
                    if(is_array($c) === true){
                        $result[] = array_merge(array($val), $c);
                    }else{
                        $result[] = array($val, $c);
                                                var_dump($result);
                            exit();
                    }
                }
            }
            return $result;
        }
    }
    展开全文
  • 多重For循环 优化

    2012-11-06 23:34:34
    多重For循环 优化
  • 多重循环优化

    2020-07-28 17:08:07
    1.不要在多重循环内进行字符串String的拼接,非常消耗内存 2.多线程优化 3.for循环判断退出的条件避免函数 4.避免新建对象 5.避免重复计算,a=bcd,可以先在循环外把c*d计算出来(如果可以)
  • 多重循环性能优化

    千次阅读 2018-12-19 09:16:41
    优化后的多重for循环可以提升大半的效率。 方法 一、实例化变量尽量放在for循环体外,只实例化一次。 二、普通变量改为寄存器变量,如i++改为++i。前置递增运算避免了不必要的工作,它把值加1后直接返回改变了运算...
  • 多重for循环优化

    2020-06-04 15:31:24
    //直接跳出多重for循环 String[] strA = new String[2]; strA[0] = "A1"; strA[1] = "A2"; String[] strB = new String[3]; strB[0] = "B1"; strB[1] = "B2"; strB[2] = "B3"; String[] strC = new String...
  • 多重for循环优化,提升运行效率

    万次阅读 多人点赞 2018-07-18 09:37:08
    循环次数较少的时候一般...客户体验会非常不好,才研究这个情况的,事实证明,优化后的多重for循环提升了一大半的效率,是不是很神奇。 当然,本文也有借鉴其他同胞的方法。 实例化变量放在for循环外,减少实...
  • 代码优化多重循环

    千次阅读 2013-09-17 09:03:23
    long t1,t2; int a1=0,a2=0; System.out.println("第一个循环"); t1=System.currentTimeMillis();//第一次循环计时 for(int i=0;i;i++){ for(int j=
  • 【引】 在上一篇有关并行化的《有关对耗时很大循环进行并行化优化的探讨 之一:并发搜索的处理》...【多重循环的操作】 有很多方法可以实现并行查询,必须并行化Linq就是很不错的途径,相比linq to entity,真正实
  • 循环的优化分为源码上的修改和编译器的优化,编译器能自动执行许多循环优化技术,但对源代码的修改可辅助编译器就行优化处理。 1. 源码上的优化 1. 多重循环的“外小内大”   在多重循环中,采用迭代次数较小的...
  • 多重循环控制条件

    2020-06-28 23:38:22
    1)统计3个班成绩情况,每个班有5名同学,求出各个班级的平均分和所有班级的平均分【学生的成绩从键盘输入】 2) 统计及格人数,每个班有...最后再进行优化。 分析:当不用一个二维数组来保存输入的成绩话,该怎么办呢。
  • 多重循环中将注意力放到最内层的代码段优化代码进而提高内存使用效率。,因为最内层循环的代码是运行次数最多的代码段,根据时间局部性原: 1.尽量保证最深层循环的次数是最多的; 2.尽量使用可重复而不是新定义...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 410
精华内容 164
关键字:

多重循环优化