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

            常量段const放在那里比較
            const char *p = "234";
            const char * const p ="123';

            頭大了。

            posted @ 2008-06-18 17:38 micheal's tech 閱讀(82) | 評論 (0)編輯 收藏

            一、Debug 和 Release 編譯方式的本質區別

                Debug 通常稱為調試版本,它包含調試信息,并且不作任何優化,便于程序員調試程序。Release 稱為發布版本,它往往是進行了各種優化,使得程序在代碼大小和運行速度上都是最優的,以便用戶很好地使用。
                Debug 和 Release 的真正秘密,在于一組編譯選項。下面列出了分別針對二者的選項(當然除此之外還有其他一些,如/Fd /Fo,但區別并不重要,通常他們也不會引起 Release 版錯誤,在此不討論)
               
            Debug 版本:
             /MDd /MLd 或 /MTd   使用 Debug runtime library(調試版本的運行時刻函數庫)
             /Od                 關閉優化開關
             /D "_DEBUG"         相當于 #define _DEBUG,打開編譯調試代碼開關(主要針對
                                 assert函數)
             /ZI                 創建 Edit and continue(編輯繼續)數據庫,這樣在調試過
                                 程中如果修改了源代碼不需重新編譯
             /GZ                 可以幫助捕獲內存錯誤
             /Gm                 打開最小化重鏈接開關,減少鏈接時間
                                
            Release 版本:      
             /MD /ML 或 /MT      使用發布版本的運行時刻函數庫
             /O1 或 /O2          優化開關,使程序最小或最快
             /D "NDEBUG"         關閉條件編譯調試代碼開關(即不編譯assert函數)
             /GF                 合并重復的字符串,并將字符串常量放到只讀內存,防止
                                 被修改

                實際上,Debug 和 Release 并沒有本質的界限,他們只是一組編譯選項的集合,編譯器只是按照預定的選項行動。事實上,我們甚至可以修改這些選項,從而得到優化過的調試版本或是帶跟蹤語句的發布版本。
               
            二、哪些情況下 Release 版會出錯

                有了上面的介紹,我們再來逐個對照這些選項看看 Release 版錯誤是怎樣產生的
               
             1. Runtime Library:鏈接哪種運行時刻函數庫通常只對程序的性能產生影響。調試版本的 Runtime Library 包含了調試信息,并采用了一些保護機制以幫助發現錯誤,因此性能不如發布版本。編譯器提供的 Runtime Library 通常很穩定,不會造成 Release 版錯誤;倒是由于 Debug 的 Runtime Library 加強了對錯誤的檢測,如堆內存分配,有時會出現 Debug 有錯但 Release 正常的現象。應當指出的是,如果 Debug 有錯,即使 Release 正常,程序肯定是有 Bug 的,只不過可能是 Release 版的某次運行沒有表現出來而已。
             
             2. 優化:這是造成錯誤的主要原因,因為關閉優化時源程序基本上是直接翻譯的,而打開優化后編譯器會作出一系列假設。這類錯誤主要有以下幾種:
             
                (1) 幀指針(Frame Pointer)省略(簡稱 FPO ):在函數調用過程中,所有調用信息(返回地址、參數)以及自動變量都是放在棧中的。若函數的聲明與實現不同(參數、返回值、調用方式),就會產生錯誤————但 Debug 方式下,棧的訪問通過 EBP 寄存器保存的地址實現,如果沒有發生數組越界之類的錯誤(或是越界“不多”),函數通常能正常執行;Release 方式下,優化會省略 EBP 棧基址指針,這樣通過一個全局指針訪問棧就會造成返回地址錯誤是程序崩潰。C++ 的強類型特性能檢查出大多數這樣的錯誤,但如果用了強制類型轉換,就不行了。你可以在 Release 版本中強制加入 /Oy- 編譯選項來關掉幀指針省略,以確定是否此類錯誤。此類錯誤通常有:
                
                 ● MFC 消息響應函數書寫錯誤。正確的應為
                  afx_msg LRESULT OnMessageOwn(WPARAM wparam, LPARAM lparam);
                  ON_MESSAGE 宏包含強制類型轉換。防止這種錯誤的方法之一是重定義 ON_MESSAGE 宏,把下列代碼加到 stdafx.h 中(在#include "afxwin.h"之后),函數原形錯誤時編譯會報錯
                  #undef ON_MESSAGE
                  #define ON_MESSAGE(message, memberFxn) \
                  { message, 0, 0, 0, AfxSig_lwl, \
                  (AFX_PMSG)(AFX_PMSGW)(static_cast< LRESULT (AFX_MSG_CALL \
                  CWnd::*)(WPARAM, LPARAM) > (&memberFxn) },
                 
                (2) volatile 型變量:volatile 告訴編譯器該變量可能被程序之外的未知方式修改(如系統、其他進程和線程)。優化程序為了使程序性能提高,常把一些變量放在寄存器中(類似于 register 關鍵字),而其他進程只能對該變量所在的內存進行修改,而寄存器中的值沒變。如果你的程序是多線程的,或者你發現某個變量的值與預期的不符而你確信已正確的設置了,則很可能遇到這樣的問題。這種錯誤有時會表現為程序在最快優化出錯而最小優化正常。把你認為可疑的變量加上 volatile 試試。
               
                (3) 變量優化:優化程序會根據變量的使用情況優化變量。例如,函數中有一個未被使用的變量,在 Debug 版中它有可能掩蓋一個數組越界,而在 Release 版中,這個變量很可能被優化調,此時數組越界會破壞棧中有用的數據。當然,實際的情況會比這復雜得多。與此有關的錯誤有:
                 ● 非法訪問,包括數組越界、指針錯誤等。例如
                     void fn(void)
                     {
                       int i;
                       i = 1;
                       int a[4];
                       {
                         int j;
                         j = 1;
                       }
                       a[-1] = 1;//當然錯誤不會這么明顯,例如下標是變量
                       a[4] = 1;
                     }
                   j 雖然在數組越界時已出了作用域,但其空間并未收回,因而 i 和 j 就會掩蓋越界。而 Release 版由于 i、j 并未其很大作用可能會被優化掉,從而使棧被破壞。

            3. _DEBUG 與 NDEBUG :當定義了 _DEBUG 時,assert() 函數會被編譯,而 NDEBUG 時不被編譯。除此之外,VC++中還有一系列斷言宏。這包括:

                ANSI C 斷言         void assert(int expression );
                C Runtime Lib 斷言  _ASSERT( booleanExpression );
                                    _ASSERTE( booleanExpression );
                MFC 斷言            ASSERT( booleanExpression );
                                    VERIFY( booleanExpression );
                                    ASSERT_VALID( pObject );
                                    ASSERT_KINDOF( classname, pobject );
                ATL 斷言            ATLASSERT( booleanExpression );
                此外,TRACE() 宏的編譯也受 _DEBUG 控制。

            所有這些斷言都只在 Debug版中才被編譯,而在 Release 版中被忽略。唯一的例外是 VERIFY() 。事實上,這些宏都是調用了 assert() 函數,只不過附加了一些與庫有關的調試代碼。如果你在這些宏中加入了任何程序代碼,而不只是布爾表達式(例如賦值、能改變變量值的函數調用 等),那么 Release 版都不會執行這些操作,從而造成錯誤。初學者很容易犯這類錯誤,查找的方法也很簡單,因為這些宏都已在上面列出,只要利用 VC++ 的 Find in Files 功能在工程所有文件中找到用這些宏的地方再一一檢查即可。另外,有些高手可能還會加入 #ifdef _DEBUG 之類的條件編譯,也要注意一下。
                順便值得一提的是 VERIFY() 宏,這個宏允許你將程序代碼放在布爾表達式里。這個宏通常用來檢查 Windows API 的返回值。有些人可能為這個原因而濫用 VERIFY() ,事實上這是危險的,因為 VERIFY() 違反了斷言的思想,不能使程序代碼和調試代碼完全分離,最終可能會帶來很多麻煩。因此,專家們建議盡量少用這個宏。

            4. /GZ 選項:這個選項會做以下這些事

                (1) 初始化內存和變量。包括用 0xCC 初始化所有自動變量,0xCD ( Cleared Data ) 初始化堆中分配的內存(即動態分配的內存,例如 new ),0xDD ( Dead Data ) 填充已被釋放的堆內存(例如 delete ),0xFD( deFencde Data ) 初始化受保護的內存(debug 版在動態分配內存的前后加入保護內存以防止越界訪問),其中括號中的詞是微軟建議的助記詞。這樣做的好處是這些值都很大,作為指針是不可能的(而且 32 位系統中指針很少是奇數值,在有些系統中奇數的指針會產生運行時錯誤),作為數值也很少遇到,而且這些值也很容易辨認,因此這很有利于在 Debug 版中發現 Release 版才會遇到的錯誤。要特別注意的是,很多人認為編譯器會用 0 來初始化變量,這是錯誤的(而且這樣很不利于查找錯誤)。
                (2) 通過函數指針調用函數時,會通過檢查棧指針驗證函數調用的匹配性。(防止原形不匹配)
                (3) 函數返回前檢查棧指針,確認未被修改。(防止越界訪問和原形不匹配,與第二項合在一起可大致模擬幀指針省略 FPO )
               
                通常 /GZ 選項會造成 Debug 版出錯而 Release 版正常的現象,因為 Release 版中未初始化的變量是隨機的,這有可能使指針指向一個有效地址而掩蓋了非法訪問。
               
            除此之外,/Gm /GF 等選項造成錯誤的情況比較少,而且他們的效果顯而易見,比較容易發現。

            三、怎樣“調試” Release 版的程序

                遇到 Debug 成功但 Release 失敗,顯然是一件很沮喪的事,而且往往無從下手。如果你看了以上的分析,結合錯誤的具體表現,很快找出了錯誤,固然很好。但如果一時找不出,以下給出了一些在這種情況下的策略。
               
                1. 前面已經提過,Debug 和 Release 只是一組編譯選項的差別,實際上并沒有什么定義能區分二者。我們可以修改 Release 版的編譯選項來縮小錯誤范圍。如上所述,可以把 Release 的選項逐個改為與之相對的 Debug 選項,如 /MD 改為 /MDd、/O1 改為 /Od,或運行時間優化改為程序大小優化。注意,一次只改一個選項,看改哪個選項時錯誤消失,再對應該選項相關的錯誤,針對性地查找。這些選項在 Project\Settings... 中都可以直接通過列表選取,通常不要手動修改。由于以上的分析已相當全面,這個方法是最有效的。

                2. 在編程過程中就要時常注意測試 Release 版本,以免最后代碼太多,時間又很緊。
               
                3. 在 Debug 版中使用 /W4 警告級別,這樣可以從編譯器獲得最大限度的錯誤信息,比如 if( i =0 )就會引起 /W4 警告。不要忽略這些警告,通常這是你程序中的 Bug 引起的。但有時 /W4 會帶來很多冗余信息,如 未使用的函數參數 警告,而很多消息處理函數都會忽略某些參數。我們可以用
                  #progma warning(disable: 4702) //禁止
                  //...
                  #progma warning(default: 4702) //重新允許
            來暫時禁止某個警告,或使用
                  #progma warning(push, 3) //設置警告級別為 /W3
                  //...
                  #progma warning(pop) //重設為 /W4
            來暫時改變警告級別,有時你可以只在認為可疑的那一部分代碼使用 /W4。

                4.你也可以像 Debug 一樣調試你的 Release 版,只要加入調試符號。在 Project/Settings... 中,選中 Settings for "Win32 Release",選中 C/C++ 標簽,Category 選 General,Debug Info 選 Program Database。再在 Link 標簽 Project options  最后加上 "/OPT:REF" (引號不要輸)。這樣調試器就能使用 pdb 文件中的調試符號。但調試時你會發現斷點很難設置,變量也很難找到——這些都被優化過了。不過令人慶幸的是,Call Stack 窗口仍然工作正常,即使幀指針被優化,棧信息(特別是返回地址)仍然能找到。這對定位錯誤很有幫助。

            posted @ 2008-06-18 17:30 micheal's tech 閱讀(231) | 評論 (0)編輯 收藏

            一.在c中分為這幾個存儲區  
              1.棧   -   有編譯器自動分配釋放  
              2.堆   -   一般由程序員分配釋放,若程序員不釋放,程序結束時可能由OS回收  
              3.全局區(靜態區),全局變量和靜態變量的存儲是放在一塊的,初始化的全局變量和靜態變量在一塊區域,未初始化的全局變量和未初始化的靜態變量在相鄰的>另一塊區域。-   程序結束釋放  
              4.另外還有一個專門放常量的地方。   -   程序結束釋放  
              二.在C++中,內存分成5個區,他們分別是堆、棧、自由存儲區、全局/靜態存儲區和常量存儲區。  
              1.棧,就是那些由編譯器在需要的時候分配,在不需要的時候自動清楚的變量的存儲區。里面的變量通常是局部變量、函數參數等。  
             2.堆,就是那些由new分配的內存塊,他們的釋放編譯器不去管,由我們的應用程序去控制,一般一個new就要對應一個delete。如果程序員沒有釋放掉,那么在程>序結束后,操作系統會自動回收。  
              3.自由存儲區,就是那些由malloc等分配的內存塊,他和堆是十分相似的,不過它是用free來結束自己的生命的。  
              4.全局/靜態存儲區,全局變量和靜態變量被分配到同一塊內存中,在以前的C語言中,全局變量又分為初始化的和未初始化的,在C++里面沒有這個區分了,他們共同占用同一塊內存區。  
              5.常量存儲區,這是一塊比較特殊的存儲區,他們里面存放的是常量,不允許修改(當然,你要通過非正當手段也可以修改)  
              所以靜態變量和全局變量放在全局/靜態存儲區,而常量存放在常量存儲區,程序代碼當然放在代碼區了~~

            posted @ 2008-06-18 16:21 micheal's tech 閱讀(286) | 評論 (0)編輯 收藏

            淺談C內存分配(轉自LUPA論壇,infohunter)

            很早之前寫的了,現在發到C版來。

            關于C語言內存方面的話題要真說起來的話那恐怕就沒頭了,所以本文僅僅是一個淺談。
            關于內存問題不同平臺之間有一定的區別。本文所指的平臺是x86的Linux平臺
            用C語言做程序(其實其他語言也一樣),不僅要熟悉語法,其實很多相關的背景知識也很重要。在學習和研究C語言中內存分配的問題前,首先要了解一下Linux分配給進程(運行中的程序)的地址空間是什么樣的。
            總的來說有3個段,即代碼段,數據段和堆棧段(學過匯編的朋友一定很熟悉了)。代碼段就是存儲程序文本的,所以有時候也叫做文本段,指令指針中的指令就是 從這里取得。這個段一般是可以被共享的,比如你在Linux開了2個Vi來編輯文本,那么一般來說這兩個Vi是共享一個代碼段的,但是數據段不同(這點有 點類似C++中類的不同對象共享相同成員函數)。數據段是存儲數據用的,還可以分成初始化為非零的數據區,BSS,和堆(Heap)三個區域。初始化非零 數據區域一般存放靜態非零數據和全局的非零數據。BSS是Block Started by Symbol的縮寫,原本是匯編語言中的術語。該區域主要存放未初始化的全局數據和靜態數據。還有就是堆了,這個區域是給動態分配內存是使用的,也就是用 malloc等函數分配的內存就是在這個區域里的。它的地址是向上增長的。最后一個堆棧段(注意,堆棧是Stack,堆是Heap,不是同一個東西),堆 棧可太重要了,這里存放著局部變量和函數參數等數據。例如遞歸算法就是靠棧實現的。棧的地址是向下增長的。具體如下:
            ========高地址     =======
            程序棧             堆棧段
                     向下增長
            “空洞”           =======
                     向上增長

            ------             數據段
            BSS
            ------
            非零數據
            =========低地址    =======
            =========          =======
            代碼               代碼段
            =========          =======
            需要注意的是,代碼段和數據段之間有明確的分隔,但是數據段和堆棧段之間沒有,而且棧是向下增長,堆是向上增長的,因此理論上來說堆和棧會“增長到一起”,但是操作系統會防止這樣的錯誤發生,所以不用過分擔心。
            有了以上理論做鋪墊,下面就說動態內存的分配。上面說了,動態內存空間是在堆中分配的。實現動態分配的也就是下面幾個函數:
            stdlib.h :
            void *malloc(size_t size);
            void *calloc(size_t nmemb, size_t size);
            void *realloc(void *ptr, size_t size);
            void free(void *ptr);
            一個一個說吧。malloc就是分配一個size大小的內存空間,并且用一個void類型的指針指向這個空間,然后返回這個指針。也就是說,malloc 返回了一個指向size大小的空間的void類型的指針,如果要使用這個空間,還得把void*類型轉換成一個你需要的類型,比如int*之類。 calloc和malloc基本一樣,不同的是有兩點,一是calloc分配的空間大小是由nmemb*size決定的,也就是說nmemb是條目個數, 而size可以看成是條目的大小,計算總空間任務由calloc去做。二是calloc返回的空間都用0填充,而malloc則不確定內存中會有什么東 西。realloc是用來改變已經分配的空間的大小。指針ptr是void類型的,它應該指向一個需要重新分配大小的空間,而size參數則是重新分配之 后的整個空間大小,而不是增加的大小。同樣,返回的是一個指向新空間的指針。free用來釋放由上面3個函數分配的空間,其參數就是指向某空間的指針。
            基本就這些了,這些都是比較基礎的話題,高級話題和細節問題還有很多,這里就不進行說明了,有機會我會繼續總結一番的

            posted @ 2008-06-18 16:13 micheal's tech 閱讀(156) | 評論 (0)編輯 收藏

            二叉樹遍歷算法基本填寫完畢,作為備份的文件。

            posted @ 2008-06-17 17:20 micheal's tech 閱讀(119) | 評論 (0)編輯 收藏

            堆優化的方法:
            1、自頂向下
            template <class Item>
            void fixDown(Item a[],int k,int N)
            {
                Item temp;
                while(2*k <= N)
                {
                    int j = 2*k;
                    if (j<N&&a[j]<a[j+1]) j++;
                    if (!(a[k]<a[j])) break;
                    //cout<<"fixdown"<<j<<endl;
                    exch(a[k],a[j]);
                    k = j;
                }
            }
            根據堆是個完全二叉樹,把除了葉節點以外的從下往上逐步排好。
            2、自底向上
            template <class Item>
            void fixUp(Item a[],int k)
            {
                while(k>1 && a[k/2]<a[k])
                {
                    exch(a[k],a[k/2]);
                    k = k/2;
                }
            }

            堆排排序的步驟,
            1、建立堆。
            可以插入的方法或者采取修正堆的方法。
              for(k=N/2;k>=l;k--)
                {
                    fixDown(pq,k,N);
                }
            2、逐步排序。
               while(N>l)
                {
                    exch(pq[l],pq[N]);
                    fixDown(pq,l,--N);
                }

            總算法:
            template <class Item>
            void heapsort(Item a[],int l,int r)
            {
                int  k = l,N = r-l+1;
                Item *pq = a+l-1;
                for(k=N/2;k>=l;k--)
                {
                    fixDown(pq,k,N);
                }
                while(N>l)
                {
                    exch(pq[l],pq[N]);
                    fixDown(pq,l,--N);
                }

            }



            堆排序引申的題目。
            如果需要找出N個數最大的K個不同的數


            N > K,前K個數中的最大K個數是一個退化的情況,所有K個數就是最大的K個數。如果考慮第K+1個數X呢?如果X比最大的K個數中的最小的數Y小,那么最大的K個數還是保持不變。如果XY大,那么最大的K個數應該去掉Y,而包含X。如果用一個數組來存儲最大的K個數,每新加入一個數X,就掃描一遍數組,得到數組中最小的數Y。用X替代Y,或者保持原數組不變。這樣的方法,所耗費的時間為ON * K)。

            進一步,可以用容量為K的最小堆來存儲最大的K個數。最小堆的堆頂元素就是最大K個數中最小的一個。每次新考慮一個數X,如果X比堆頂的元素Y小,則不需要改變原來的堆,因為這個元素比最大的K個數小。如果X比堆頂元素大,那么用X替換堆頂的元素Y。在X替換堆頂元素Y之后,X可能破壞最小堆的結構(每個結點都比它的父親結點大),需要更新堆來維持堆的性質。更新過程花費的時間復雜度為O(log2K)。

            ImageName

            圖2-1

            圖2-1是一個堆,用一個數組h[]表示。每個元素h[i],它的父親結點是h[i/2],兒子結點是h[2 * i + 1]和h[2 * i + 2]。每新考慮一個數X,需要進行的更新操作偽代碼如下:

            代碼清單2-13

            if(X > h[0])

            {

                h[0] = X;

                p = 0;

                while(p < K)

                {

                    q = 2 * p + 1;

                    if(q >= K)

                        break;

                    if((q < K – 1) && (h[q + 1] < h[q]))

                        q = q + 1;

                    if(h[q] < h[p])

                    {

                        t = h[p];

                        h[p] = h[q];

                        h[q] = t;

                        p = q;

                    }

                    else

                        break;

                }

            }

            因此,算法只需要掃描所有的數據一次,時間復雜度為ON * log2K)。這實際上是部分執行了堆排序的算法。在空間方面,由于這個算法只掃描所有的數據一次,因此我們只需要存儲一個容量為K的堆。大多數情況下,堆可以全部載入內存。如果K仍然很大,我們可以嘗試先找最大的K’個元素,然后找第K’+1個到第2 * K’個元素,如此類推(其中容量K’的堆可以完全載入內存)。不過這樣,我們需要掃描所有數據ceilK/K’)次。



            posted @ 2008-06-16 11:40 micheal's tech 閱讀(767) | 評論 (0)編輯 收藏

            快排分析 ,快排與冒泡排序是相關聯的。
            template<class T>
            bubblesort(T *src,int lne)
            {
                  
            }
            前者是通過相鄰之間交換的方式來。
            而后者是通過一個值得比較來交換的方式。

            template <class T>
            void quicksort(T *src,int low,int high)
            {
                T temp;
                int i = low;
                int k = high;
                if(low >=high) return;
                temp = src[low];

                while(low<high)
                {
                    while(low<high&&src[high]>=temp) high--;
                    src[low] = src[high];
                    while(low<high&&src[low]<=temp) low++;
                    src[high] = src[low];
                }
                src[low] = temp;
                quicksort(src,i,low-1);
                quicksort(src,low+1,k);
            }


            posted @ 2008-06-16 11:40 micheal's tech 閱讀(260) | 評論 (0)編輯 收藏

            B樹原理

            posted @ 2008-06-16 11:39 micheal's tech 閱讀(542) | 評論 (0)編輯 收藏

            二叉搜索樹的隨機化建立方法
            二叉搜索數是一棵二叉樹,其中每一個內部節點都有一個相關的關鍵字,并有負有以下的性質。任意節點的關鍵字大于(或者等于)該節點左子樹的所有關鍵字,并小于(或者等于)該節點右子樹的所有關鍵字。

            #include <stdlib.h>
            #include 
            <iostream.h>
            static int maxKey = 1000;
            typedef 
            int Key;
            class Item{
                
            private:
                    Key keyval;
                    
            float info;
                
            public:
                    Item()
                    {keyvalue 
            = maxKey;}
                    Key key()
                    {
            return keyvalue;}
                    
            int null()
                    {
                        
            return keyvalue  ==maxKey;
                    }
                    
            void rand()
                    {
                        keyval 
            = 1000*::rand()/RAND_MAX;
                    }
                    
            int scan(istream& is=cin)
                    {
                        
            return(is>>keyvalue>>info )!=0);
                    }
                    
            void show(ostream& os=cout)
                    {
                        os
            <<keyvalue<<" "<<info<<endl;
                    }
            };
            ostream
            & operator<<(ostream &os,Item &X)
            {
                X.show(os);
                
            return os;
            }


            template 
            <class Item,class Key>
            class ST
            {
                
            private:
                    
            struct node
                    {
                        Item item;
                        node 
            *l,*r;
                        node(Item x)
                        {
                            item 
            = x;
                            l 
            = 0;
                            r 
            = 0;
                        }
                    };
                    typedef node 
            * link;
                    link head;
                    
            struct node nullitem;

                    
            void insertR(link &h,Item x)
                    {
                        
            if(h == 0)
                        {
                            h 
            = new node(x);
                            
            return;
                        }
                        
            if(x.key()<h->item.key())
                        {
                            insertR(h
            ->l,x);
                        }
                        
            else
                        {
                            insertR(h
            ->r,x);
                        }

                    }
                    Item searchR(link 
            &h,Key v)
                    {
                        
            if(h == 0)
                            
            return nullitem;
                        
            if(h->item.key() == v)
                        {
                            
            return h->Item;
                        }
                        
            else if(h->item.key()<v)
                        {
                            searchR(h
            ->right,v);
                        }
                        
            else
                        {
                            searchR(h
            ->left,v);
                        }

                    }

                    }
                
            public:
                    ST(
            int)
                    {
                    }
                    
            int count();
                    Item search(Key);
                    
            void insert(Item);
                    
            void remove(Item);
                    Item select(
            int);
                    
            void show(ostream &);
            };

            posted @ 2008-06-16 11:26 micheal's tech 閱讀(671) | 評論 (0)編輯 收藏

                 摘要: 轉載比較詳細                                  ...  閱讀全文

            posted @ 2008-06-16 10:57 micheal's tech 閱讀(648) | 評論 (0)編輯 收藏

            僅列出標題
            共8頁: 1 2 3 4 5 6 7 8 
            亚洲国产精品一区二区久久| 久久综合给合久久狠狠狠97色 | 久久九九久精品国产| 久久99精品久久久久久不卡| 日韩va亚洲va欧美va久久| 日韩精品久久久肉伦网站| 99久久人妻无码精品系列| 久久香综合精品久久伊人| 精品久久久久久无码人妻热 | 亚洲精品乱码久久久久久 | 久久无码国产| 精品国产乱码久久久久久浪潮| 久久久久无码专区亚洲av| 亚洲精品国产综合久久一线| 久久91精品国产91久久户| 91麻精品国产91久久久久| 久久精品亚洲中文字幕无码麻豆| 久久久久国产一级毛片高清板 | 精品多毛少妇人妻AV免费久久| 亚洲七七久久精品中文国产| 久久香蕉国产线看观看99| 91麻豆国产精品91久久久| 久久精品国产亚洲精品2020| 久久66热人妻偷产精品9| 无码人妻久久久一区二区三区| 三级三级久久三级久久| 久久影视国产亚洲| 中文字幕热久久久久久久| 久久国产精品99久久久久久老狼 | 久久天天躁狠狠躁夜夜96流白浆 | 亚洲精品无码专区久久久| 亚洲国产成人精品久久久国产成人一区二区三区综 | 91精品国产综合久久久久久| 国产午夜福利精品久久2021| .精品久久久麻豆国产精品| 久久久久久久亚洲Av无码| 久久天天躁狠狠躁夜夜网站| 无码久久精品国产亚洲Av影片| 国产成人精品综合久久久| 九九久久99综合一区二区| 亚洲色大成网站WWW久久九九|