• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>

            C++研究

            C++細節深度探索及軟件工程

              C++博客 :: 首頁 :: 新隨筆 :: 聯系 :: 聚合  :: 管理 ::
              37 隨筆 :: 0 文章 :: 74 評論 :: 0 Trackbacks

            算法要求:試設計一個算法,將數組A[0..n-1]中的元素循環右移K位,并要求只用一個元素大小的存儲

            空間。元素移動或交換的次數為O(n)


            【分析】:本題的應用環境很廣泛,在實用中有很重要意義,如:實現高階乘除法,在游戲選關和各種

            特效中經常用到。目前手機等移動設備應用開發方興未艾,對此常用算法做一個深入的探討很有必要。

            作者: 天津大學計算機系    常興龍  MSN:cxl82116@msn.com 

                本題的難點在于同時對空間復雜度與時間復雜度都做了很高的要求,但就本題來講,仍有很多種解

            法。這里,探討常見的三種解法:
                           1.由于每個元素,跟與它相距r×k位形成了一個“循環”,因此算法保證每次都有一至

            二個元素正確歸位,設一個計數變量,當計數變量到達n時,算法結束
                           2.對1解法求精,1解中可能使一個元素多于一次的移動,但如果找到n與k的最大公約數

            ,就可以解決此問題,從而保證每個元素只移動一次。
                           3.第三種思想有一定的技巧,直觀理解比較困難,但手有有一副撲克牌,就能清楚地看

            到整個過程(把整個排列看成是一個環形)。它的算法是:先逆轉前n-k個元素,再逆轉后K個元素,再

            把整個序列逆轉。

            void EMove(int A[n] , int k)
            {
                
            for(int i = 0 ; i < n;) //i為到位的元素個數,做為算法出口
                {
                
            /**//* t是需要到位的元素的靜態指針 s 指向下一個K步到達的位置 ,
                    r初值為1 ,在每一循環圈中置初值一次,做為步進值
            */

                    s 
            = ( t + r * k ) % n ;  
                    A[t]
            <-->A[s]; //用A[t]為緩沖空間 , 使此鏈上一個記錄到位,到位位置的記錄緩存到緩沖區中
                    r++ ; i++;
                    s 
            = ( t +*k) %n;
                    
            if(s == t) //使兩個記錄到位,一圈結束
                    {
                        t
            ++;    //選擇親的起始點
                        r=1;
                        i
            ++;
                    }
            //if
                }
            //for
            }

            [解二]
            void EMove(int A[n] , int k)
            {
                
            for ( int i = 1; i <= k; i++ )
                    
            if ( n%== 0 && k%==0 ) p = j; 
                    
            /**//*上面為求最大公約數的O(n)寫法之一,還可以這么寫:
                        int p= int();  //這也是一個C++新奇的寫法,int = 0,稍用一下構造函數
                        while( n !=0 && k !=0)
                        {
                        n>k ? n%=k:k%=n;
                        }
                        p = n==0?k:n;
                        p為n與k的最大公約數
                        比較性能:注釋中的log(N)性能更好,但是破壞原來數據,
                        如果保留原數據,輾轉一下,得不償失,這也是棄用的理由
                    
            */

                    
            for ( i = 0 ; i < p ; i++//最大公約數,實質為保證每個元素都到位的子圈數目
                    //極限情況,若 n與k最大公約為1,則一圈就能成功,無需另先起點
                        j = i;
                        m 
            = ( i + k ) % n;
                        temp 
            = A[i]; //緩存
                        while( m != i)
                        
            {
                            
            //利用A[j],交換 temp 與A[m]的值
                            
            //A[j]為本次要到位的元素
                            
            //A[m]存本次己位的元素
                            
            //temp 緩存下次要到位的元素
                            A[j] = temp ; 
                            temp 
            = A[m] ; 
                            A[m] 
            = A[j] ; 
                            
            //前進一步
                            j = m ;
                            m 
            = ( j + k ) % n ;
                            
                        }
            //while
                    }
            //for
            }
            //Emove

            [解三]
            void Emove ( int A[n] , int k )
            {
                
            for ( i=0 ; i < ( n - k ) / 2 ; i++ )
                
            {
                    A[i]
            <-->A[ n-k-1-i];
                    
                }
            //逆轉前n-k
                for( i = n - k ; i < ( 2*- k) /2 ; i++)
                
            {
                    A[n
            -k+i]<-->A[k-1+i];
                }
             //逆轉后K項
                for ( i = 0 ; i < n/2 ; i++ )
                
            {
                    A[i]
            <-->A[n-1-i];
                }
            //逆轉整個鏈
            }



            補充:

            [1]反轉鏈的下標確定方法,可以通俗的描寫

            從 『鏈開始下標』到 (『鏈終止下標』-『鏈開始下標』)/2 ,反復做

                 交換 『鏈開始下標+i』,『鏈終止下標-i』

            [2]定義符號<-->為

            Swap( int & i , int & j )
            {
                
            int temp = i ;
                i 
            = j ; 
                j 
            = temp
            }


            關于交換算法,還有一種線性代數矩陣的寫法

            //交換x,y
            Swap( int & x , int & y )
            {
                
                x
            =x+y;
                y
            =x-y;
                x
            =x-y;
            }


            【思考】如果把本題擴充一下,改為把A中的一個子序列擴右移K位(其余要求不變)的算法?(進一步

            要求能夠處理K>子序列長度的情況?)(下次提供答案)

            posted on 2007-05-15 10:03 常興龍 閱讀(2498) 評論(6)  編輯 收藏 引用 所屬分類: Algorithm

            評論

            # re: 精煉循環右移[未登錄] 2007-07-06 16:53 yong
            第三種有意思,呵呵,怎么推出來的,琢磨琢磨...  回復  更多評論
              

            # re: 精煉循環右移 2008-08-29 20:08 李銳
            我也要好好看看,謝謝了  回復  更多評論
              

            # re: 精煉循環右移 2010-04-18 20:52 zy天
            A[n-k+i]<-->A[k-1+i];
            應該是A[n-k+1]<-->A[k-1+i]  回復  更多評論
              

            # re: 精煉循環右移 2010-04-28 22:28 tengzhao201
            //最高效的循環右移算法!!
            //這個是遞歸的寫法
            //author:tengzhao201 QQ:715572192
            //time:2010-4-24
            //時間復雜度為O(n),空間復雜度O(1),交換點在中間時比逆序法快一倍!!!
            //提速要點:由于取模運算的效率很低,去掉了取模運算后效率得到大提升;swap函數效率低,引入了temp變量
            void TZshift1(int* arr,int N,int K)
            {
            K=K%N;

            if(0==K)return;

            int temp,qq,pp=0;
            pp=0;qq=K;
            for(int i=0;i<N-K;i++,pp++,qq++)
            {
            //swap(arr[i%K],arr[i+K]);//問題的關鍵在于找到原來的第i個元素現在在哪里,通過觀察可以發現在arr[i%K]的位置,下面的代碼實現了arr[i%K]和arr[i+K]的互換
            if(K==pp)pp=0;
            temp=arr[pp];
            arr[pp]=arr[qq];
            arr[qq]=temp;
            }

            TZshift1(arr,K,K-pp);
            }

            //最高效的循環右移算法!!
            //非遞歸的寫法
            //author:tengzhao201 QQ:715572192
            //time:2010-4-24
            //時間復雜度為O(n),空間復雜度O(1),交換點在中間時比逆序法快一倍!!!
            //提速要點:采用非遞歸算法
            void TZshift2(int* arr,int N,int K)
            {
            K=K%N;
            if(0==K)
            return;

            //int count=0;
            int temp,qq,pp=0;

            while(K>0)
            {
            pp=0;qq=K;
            for(int i=0;i<N-K;i++,pp++,qq++)
            {
            //swap(arr[i%K],arr[i+K]);//問題的關鍵在于找到原來的第i個元素現在在哪里,通過觀察可以發現在arr[i%K]的位置,下面的代碼實現了arr[i%K]和arr[i+K]的互換

            if(K==pp)pp=0;
            temp=arr[pp];
            arr[pp]=arr[qq];
            arr[qq]=temp;
            //count+=2;
            }
            N=K;
            if(0==pp)
            return;
            K-=pp;
            //TZshift(arr,K,K-pp);
            }
            //cout<<"In tatal,has used "<<count<<" steps."<<endl;
            }  回復  更多評論
              

            # re: 精煉循環右移 2010-04-29 10:46 tengzhao201
            http://download.csdn.net/source/2296222  回復  更多評論
              

            # re: 精煉循環右移 2010-04-29 10:47 tengzhao201
            最高效循環右移課程設計下載地址:
            http://download.csdn.net/source/2296222  回復  更多評論
              

            > hi的博客
            久久婷婷五月综合色高清| 欧美午夜A∨大片久久| 久久香综合精品久久伊人| 久久午夜羞羞影院免费观看| 久久精品国产亚洲av日韩| 国产精品久久久久久| 久久久久久国产精品无码下载 | 99久久国产综合精品女同图片 | 久久午夜无码鲁丝片秋霞| 久久久精品国产sm调教网站| 成人a毛片久久免费播放| 国内精品九九久久精品| 色综合久久最新中文字幕| 亚洲午夜久久久| 国产精品九九久久免费视频| 亚洲AV乱码久久精品蜜桃| 欧美日韩精品久久久免费观看| 热re99久久6国产精品免费| 亚洲第一永久AV网站久久精品男人的天堂AV | 国产精品欧美亚洲韩国日本久久| 日本WV一本一道久久香蕉| 99久久亚洲综合精品网站| 精品久久久无码人妻中文字幕豆芽| 亚洲午夜无码久久久久小说| 久久一区二区三区免费| 久久精品无码一区二区三区日韩 | 国产国产成人精品久久| 中文字幕日本人妻久久久免费 | A级毛片无码久久精品免费 | A狠狠久久蜜臀婷色中文网| 中文精品久久久久人妻不卡| 久久夜色精品国产亚洲| 久久91精品国产91| 四虎久久影院| 一本久久精品一区二区| 欧美一级久久久久久久大片| 国产精品成人99久久久久91gav | 久久国内免费视频| 思思久久99热只有频精品66| 亚洲午夜久久久久妓女影院| 亚洲精品乱码久久久久久按摩|