• <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>
            

    
            

            




            







												


        


            


            The Fourth Dimension Space
            

            枯葉北風寒，忽然年以殘，念往昔，語默心酸。二十光陰無一物，韶光賤，寐難安； 不畏形影單，道途阻且慢，哪曲折，如渡飛湍。斬浪劈波酬壯志，同把酒，共言歡！  -如夢令
            

            




            
	
					
	
            
		
            
			SortWizard(排序精靈）——我的排序類
		
            
		
            //排序精靈
            //Copyright:abilitytao,Nanjing University Of Science And Technology 





            /////////////////////////BEGIN_TEMPLATE_BY_ABILITYTAO_ACM//////////////////////////////////////
            #include<iostream>
            #include            <cstdio>
            #include            <algorithm>
            #include            <cmath>
            using namespace std;


            template            <class T>
            class SortWizard
            {
            private:
                T             *a;
                            int n;
            public:
                SortWizard()            {    a=NULL;n=0;}
                SortWizard(T             *a,int n){this->a=a;this->n=n;}
                            void Set(T *a,int n){this->a=a;this->n=n;}
                            void InsertSort();
                            void ShellSort();
                            void BubbleSort();
                            void QuickSort();
                            void SelectSort();
                            void MergeSort();
                            void HeapSort();
            }            ;

            template            <class T>
            void SortWizard<T>:: InsertSort()//直接插入排序,時間復雜度為O(n^2)
            {

                            int i,j;
                T temp;
                            for(i=1;i<n;i++)
                            {

                    temp            =a[i];
                                for(j=i-1;j>=0;j--)
                                {
                                    if(temp<a[j])
                            a[j            +1]=a[j];
                                    else
                                        break;
                    }
                    a[j            +1]=temp;
                    
                }
            }



            template            <class T>
            void SortWizard<T>::ShellSort()//希爾排序,時間復雜度為O(n^1.5)
            { 
                            int i,j,d;
                T temp;
                d            =n>>1;
                            while(d>=1)
                            {
                                for(i=d;i<n;i++)
                                { 
                        temp            =a[i];
                                    for(j=i-d;j>=0;j-=d)
                                    {
                                        if(a[j]>temp) 
                                a[j            +d]=a[j];
                                        else 
                                            break;
                        }
                        a[j            +d]=temp;
                    }            //這個while實際上是直接插入排序

                    d            >>=1;//即d右移一位，d除以2；
                }
            }            //ShellSort



            template            <class T>
            void SortWizard<T>::BubbleSort()//冒泡排序,時間復雜度為O(n^2)
            {
                            int i,j;
                T temp;
                            for(i=n-1;i>0;i--)
                            {
                                for(j=0;j<i;j++)
                                {
                                    if(a[j]>a[j+1])
                                    {

                            temp            =a[j];
                            a[j]            =a[j+1];
                            a[j            +1]=temp;
                        }
                    }
                }
            }


            /////////////////////快速排序,時間復雜度為O(nlog2n)///////////////////////
            template<class T>
            int Partion(T a[],int i,int j)//劃分函數
            {  
                T temp;
                temp            =a[i];
                            while(i<j)
                            {  
                                while(i<j && temp<=a[j])  
                            j            --;
                                if(i<j)
                                { 
                        a[i]            =a[j]; 
                        i            ++; 
                    }
                                while(i<j && a[i]<=temp) 
                        i            ++;
                                if(i<j)
                                { 
                        a[j]            =a[i]; 
                        j            --; 
                    }
                }
                a[i]            =temp;
                            return i;
            }


            template             <class T>
            void qsort(T a[],int l,int h)
            {
                            int m;
                            if(l<h) 
                            { 
                    m            =Partion(a,l,h);
                    qsort(a,l,m            -1);
                    qsort(a,m            +1,h); 
                }
            }

            template            <class T>
            void SortWizard<T>::QuickSort()
            {
                qsort(a,            0,n-1);
            }

            ////////////////////QuickSort_O(nlog2n)////////////////////////



            template             <class T>
            void SortWizard<T>::SelectSort()//選擇排序，時間復雜度為O(n^2)
            {
                            int i,j,k;
                T temp;
                            for(i=0;i<n-1;i++)
                            {   
                    k            =i;
                                for(j=i+1;j<n;j++)
                                {
                                    if(a[j]<a[k])
                            k            =j;
                    }
                        temp            =a[k];
                        a[k]            =a[i];
                        a[i]            =temp;
                }
            }

            ///////////////////////堆排序////////////////////////////
            template <class T>
            void Sift(T a[],int k,int m)//k篩選標號，m篩選范圍
            {
                            int i,j;
                T temp;
                i            =k;
                j            =2*i+1;//j指向左兒子;
                temp=a[i];//暫存a[i];
                while(j<=m)
                            { 
                                if(j<m &&a[j]<a[j+1])
                            j            ++;
                                if(temp<a[j])
                                { 
                        a[i]            =a[j];
                        i            =j;
                        (j            <<=1)++;//j*2+1
                    }
                                else 
                                    break;
                }
                a[i]            =temp; 
            }                    


            template             <class T>
            void SortWizard<T>::HeapSort()//堆排序，建堆時間復雜度O(n)，篩選O(nlog2n);

            {
                            int i;
                T temp;
                            for(i=(n>>1)-1;i>=0;i--)
                    Sift(a,i,n            -1);

                            for(i=n-1;i>=1;i--)
                            {  
                    temp            =a[0];
                    a[            0]=a[i];
                    a[i]            =temp;
                    Sift(a,            0,i-1);
                }
            }
            /////////////////////HeapSort_O(nlog2n)///////////////////////////




            ///////////////////////歸并排序,時間復雜度O(nlog2n)/////////////////////////////

            template             <class T>
            void Merge(T sr[],T tr[],int l,int m,int n)
            {
                            int i,j,k;
                i            =l;
                j            =m+1;
                k            =l-1;
                            while(i<=m && j<=n)
                            {
                                if(sr[i]<sr[j]) 
                        tr[            ++k]=sr[i++];
                                else 
                        tr[            ++k]=sr[j++];
                }
                                while(i<=m)
                        tr[            ++k]=sr[i++];
                                while(j<=n)
                        tr[            ++k]=sr[j++];
                                for(i=l;i<=n;i++) 
                        sr[i]            =tr[i];
            }

            template             <class T>
            void Msort(T a[],T st[],int s,int t)
            {
                            int m;
                            if(s<t) 
                            { 
                    m            =(s+t)>>1;
                    Msort(a,st,s,m);
                    Msort(a,st,m            +1,t);
                    Merge(a,st,s,m,t);
                }
            }

            template             <class T>
            void SortWizard<T>::MergeSort()
            { 
                T             *st=new T[n];
                Msort(a,st,            0,n-1);  
                delete  [ ]st;
            }
            //////////////////////MergeSort_O(nlog2n)///////////////////////////////


            /////////////////////////END_TEMPLATE_BY_ABILITYTAO_ACM//////////////////////////////////////





            int main ()
            {
                SortWizard            <double>test;
                            double test1[]={10.4,9.1,8.4,7,6,5,4,3,2,1};
                test.Set(test1,            sizeof(test1)/sizeof(double));
                test.InsertSort();
                            double test2[]={10.4,9.1,8.4,7,6,5,4,3,2,1};
                test.Set(test2,            sizeof(test2)/sizeof(double));
                test.ShellSort();
                            double test3[]={10.4,9.1,8.4,7,6,5,4,3,2,1};
                test.Set(test3,            sizeof(test3)/sizeof(double));
                test.BubbleSort();
                            double test4[]={10.4,9.1,8.4,7,6,5,4,3,2,1};
                test.Set(test4,            sizeof(test4)/sizeof(double));
                test.QuickSort();
                            double test5[]={10.4,9.1,8.4,7,6,5,4,3,2,1};
                test.Set(test5,            sizeof(test5)/sizeof(double));
                test.SelectSort();
                            double test6[]={10.4,9.1,8.4,7,6,5,4,3,2,1};
                test.Set(test6,            sizeof(test6)/sizeof(double));
                test.HeapSort();
                            double test7[]={10.4,9.1,8.4,7,6,5,4,3,2,1};
                test.Set(test7,            sizeof(test7)/sizeof(double));
                test.MergeSort();
                            return 0;
            }






            

            如果您認為還可以改進的話 請留言告訴我:-)

		
            
			posted on 2009-05-07 18:54 abilitytao 閱讀(1863) 評論(14)  編輯 收藏 引用  
		
            
	
            
	
	





            
	    
    


            

            評論
            
	
	
			
            
				# re: SortWizard(排序精靈）——我的排序類
					
						2009-05-07 20:55
					
				adon
			
            
			
            
				我想遞減怎么辦  回復  更多評論
				  
			
            
		
			
            
				# re: SortWizard(排序精靈）——我的排序類
					
						2009-05-07 21:55
					
				zhaoyg
			
            
			
            
				博主可否做成成員函數是模板函數的非模板類，這樣可以用一個對象來處理所有類型的排序  回復  更多評論
				  
			
            
		
			
            
				# re: SortWizard(排序精靈）——我的排序類
					
						2009-05-07 22:41
					
				abilitytao
			
            
			
            
				@adon

            不知道您有什么高見呢 我現在的方法是 重載運算符 不過這個對基本數據類型不管用  回復  更多評論
				  
			
            
		
			
            
				# re: SortWizard(排序精靈）——我的排序類
					
						2009-05-07 22:47
					
				abilitytao
			
            
			
            
				@zhaoyg

            您的意思是不是讓我拿掉私有成員變量？把它作為類里面函數的參數？  回復  更多評論
				  
			
            
		
			
            
				# re: SortWizard(排序精靈）——我的排序類
					
						2009-05-08 12:45
					
				zhaoyg
			
            
			
            
				@abilitytao

            恩,是這樣的.

            不知你意下如何  回復  更多評論
				  
			
            
		
			
            
				# re: SortWizard(排序精靈）——我的排序類
					
						2009-05-08 12:47
					
				zhaoyg
			
            
			
            
				不過感覺像我這樣一弄，好像也就沒必要造這個類了，直接用庫函數就是了。  回復  更多評論
				  
			
            
		
			
            
				# re: SortWizard(排序精靈）——我的排序類[未登錄]
					
						2009-05-08 12:58
					
				Charlie
			
            
			
            
				@abilitytao
            可以使用policy based做比較

            template<typename element_t>
            struct less_than {
              static bool compare(const element_t lhs, const element_t rhs) {
                return lhs<rhs;
              }
            };

            template<typename element_t, typename cmp_policy = less_than<element_t> >
            struct sort_wirzad {
              void easy_sort() {
                ...
                //做比較
                if ( cmp_policy::compare(e1,e2) ) { /* do sth */ }
              }
            };

            用戶可以自定義自己的 compare_policy
            比如定義一個 greater_than 可以這樣傳遞給sort_wizard:

            sort_wizard<int,greater_than> instance;  回復  更多評論
				  
			
            
		
			
            
				# re: SortWizard(排序精靈）——我的排序類
					
						2009-05-08 15:36
					
				abilitytao
			
            
			
            
				@Charlie

            這個就是常用的cmp函數吧 呵呵 我還不是很理解呢   回復  更多評論
				  
			
            
		
			
            
				# re: SortWizard(排序精靈）——我的排序類
					
						2009-05-08 20:07
					
				Chuck
			
            
			
            
				
            @abilitytao
            這招很常用……特別是對使用模版的程序
            假想我做了一個高精度整數類，這個整數在C++里面用字符串來表示字面值，我做一個累加的程序，當然是泛型的~
            這些東西存在一個std::vector里面
            

            template<typename element_t>
            struct accum {
              static element_t accumlate(const std::vector<element_t>& container) {
                std::vector<element_t>::const_iterator i = container.begin();
                std::vector<element_t>::const_iterator end = container.end();
                
                element_t total = 0; /***注意這一行***/
                while ( i != end ) {
                  total += *i;
                  ++i;
                }
              }
            };
            

            前面的total = 0 對于普通數值類型不會出錯，但是如果是對于我的big_int類
            要把big_int初始化為0，應該是：
            

            big_int = "0";
            

            那么這個accum就不管用了
            

            該怎么辦呢？ 利用一個東西來完成……
            

            template<typename element_t>
            struct init_zero {
              static element_t zero() {
                return 0;
              }
            };
            


            // 一個偏特化
            template<>
            struct init_zero<big_int> {
              static big_int zero() {
                return big_int("0");
              }
            };
            

            那么之前的代碼就可以寫成這樣：
            

            template<typename element_t, typename init_zeror = init_zero<element_t> >
            struct accum {
              static element_t accumlate(const std::vector<element_t>& container) {
                std::vector<element_t>::const_iterator i = container.begin();
                std::vector<element_t>::const_iterator end = container.end();
                
                element_t total = init_zeror::zero();
                while ( i != end ) {
                  total += *i;
                  ++i;
                }
              }
            };
            
  回復  更多評論
				  
			
            
		
			
            
				# re: SortWizard(排序精靈）——我的排序類
					
						2009-05-08 20:08
					
				Chuck
			
            
			
            
				
            by the way
            

            我是之前那個charlie
            
  回復  更多評論
				  
			
            
		
			
            
				# re: SortWizard(排序精靈）——我的排序類
					
						2009-05-08 20:10
					
				Chuck
			
            
			
            
				哦~ 我忘記return total了~ 不好意思~ 不傷大雅就OK~  回復  更多評論
				  
			
            
		
			
            
				# re: SortWizard(排序精靈）——我的排序類
					
						2009-05-08 21:41
					
				abilitytao
			
            
			
            
				@Chuck

            多謝呵 講解的很詳細:-) 

            PS:話說BIG_INT我也有一個 不過要是有高精浮點類就好了 呵呵  回復  更多評論
				  
			
            
		
			
            
				# re: SortWizard(排序精靈）——我的排序類
					
						2009-11-20 12:11
					
				tiny
			
            
			
            
				qsort

            實現的太過簡單。。。。。。沒啥實際價值。  回復  更多評論
				  
			
            
		
			
            
				# re: SortWizard(排序精靈）——我的排序類[未登錄]
					
						2009-11-21 19:42
					
				abilitytao
			
            
			
            
				@tiny

            請問您有什么改進的建議嗎 當時寫這個只是為了完成數據結構的作業呢 呵呵  回復  更多評論
				  
			
            
		

            




            






            

				

            


    
    







            
	   
	



久久久久无码精品国产|
亚洲另类欧美综合久久图片区|
一本久久综合亚洲鲁鲁五月天亚洲欧美一区二区|
久久青青草原精品影院|
久久乐国产精品亚洲综合|
久久综合亚洲鲁鲁五月天|
久久99免费视频|
中文字幕久久精品|
久久久久无码精品国产不卡|
Xx性欧美肥妇精品久久久久久|
2020国产成人久久精品|
狠色狠色狠狠色综合久久|
偷窥少妇久久久久久久久|
狠狠狠色丁香婷婷综合久久俺|
狠狠人妻久久久久久综合蜜桃|
亚洲国产欧美国产综合久久|
一本一道久久精品综合|
久久精品亚洲AV久久久无码|
伊人久久综在合线亚洲2019|
久久久久亚洲精品日久生情|
久久久久97国产精华液好用吗|
麻豆成人久久精品二区三区免费|
久久久久亚洲AV无码专区网站|
国产成人久久AV免费|
久久国产劲爆AV内射—百度|
久久久久无码专区亚洲av|
久久综合综合久久狠狠狠97色88|
久久人人爽人人爽人人片AV不|
久久婷婷五月综合97色直播
|
一本久久精品一区二区|
一本一道久久精品综合|
麻豆精品久久精品色综合|
97久久久久人妻精品专区|
久久久老熟女一区二区三区|
久久99热这里只有精品66|
尹人香蕉久久99天天拍|
欧美亚洲日本久久精品|
综合久久给合久久狠狠狠97色
|
精品久久久无码人妻中文字幕豆芽|
精品国产乱码久久久久软件|
久久夜色精品国产亚洲|