（第一、二章）
各位大哥見笑了，小弟水平實在太低，做了做書上的題結果不會的太多，所以就把它們寫了下來，我堅信大哥們一定都會，但是我覺得有點心得就要和大家分享，所以就斗膽貼出來了，如果覺得還是有點用處，希望大家都能給點回應，激勵小弟再接再厲。如果覺得簡直弱智，也望大家說出來，我也就不再現眼了！

[1-2]
水平垂直奇偶校驗，對于1位數據錯，必然使該位數據所在的行和列都發生校驗錯，所以不但能夠發現錯誤，而且可以通過行和列的交叉點來確定出錯的位置。
[1-3]
海明碼一般為偶校驗。
一般來說，以k表示原信息為長度，以n表示經過編碼以后的長度，則r=k/n表示一個糾錯編碼的編碼效率。例如：一個（7，4）循環碼的編碼效率是r=4/7。
[1-10]
分辨率（即一個屏幕上有多少光點）和灰度（即光點亮度的深淺變化）是顯示器的兩個重要技術指標，他們決定了所顯示圖像的質量。
彩色圖形顯示cga（color?graphics?adapter）、增強圖形顯示ega（enhanced?graphics?adapter）、視頻圖形顯示vga（video?graphics?adapter）、單色圖形顯示mga（monochrome?graphics?adapter），cga在字符方式下，每屏可以顯示25x80個字符。
[1-11]
在中斷處理過程中，中斷屏蔽功能可以起改變中斷優先級的作用。
每次中斷發生后，保護現場必須保護少量工作寄存器，同時選擇性保護進程控制塊。
中斷可分為內部中斷（或軟件中斷）和外部中斷（或硬件中斷）。前者包括溢出中斷，越界中斷，中斷指令等；后者包括設備運行結束中斷、時鐘中斷、控制臺中斷等。一般硬件中斷的優先級高于軟件中斷。
[1-25]
存貯器的可尋址單元數n與存儲器的地址寬度a的關系式：n=2^a。
問題：假設某計算機具有1m的內存，并且按字節編址，為使4字節組成的字能從存儲器中一次讀出，要求存放在存儲器中的字邊界對齊，一個字的地址碼應______。
答案：最低兩位為00
原因：
address?:??0?????????1??????????2??????????3???????????4?.....
?????????????byte1??byte2???byte3???byte4
address?總能被4整除
所以address的低兩位為00??(0x....0,4,8,c)
0x0?=?0000
0x4?=?0100
0x8?=?1000
0xc?=?1100
[2-1]
語言的文法分成四種類型，即0型（短語文法）、ⅰ型（上下文有關文法）、ⅱ型（上下文無關）、ⅲ型（正則文法）。與這四類文法對應的自動機分別為圖靈機、線性有限自動機、非確定的下推自動機、有限自動機。在這四類文法中，常用ⅱ型文法來描述程序設計語言的語法，ⅲ型文法來描述程序設計語言的詞法。由定義可知ⅲ型文法必為ⅱ型文法。ⅲ型文法對應的識別裝置為有限自動機，有限自動機分確定的有限自動機和非確定的有限自動機，可證明對任一非確定的有限自動機都存在一個確定的有限自動機與之等價（兩個有限自動機等價是說二者是別的語言相同）。
[2-4]
一些程序設計語言可以子程序遞歸調用，通常使用一個下推棧存放子程序的調用紀錄，調用紀錄包括：
1、全局量存儲區域的開始地址：子程序不僅可用其內部的局部量和臨時變量，也可使用全局量；
2、調用點所在子程序的調用紀錄首地址；
3、調用點的返回地址；
4、形式參數和實在參數的通訊區域；
5、返回值；
6、本子程序的局部量和臨時變量存儲區域等。
[2-5]
語法分析方法大體上可分成自上而下和自下而上兩種。自下而上分析法，是從輸入符號串開始逐步進行歸約，直至歸約成文法的起始符號。自上而下分析法，則是從文法的起始符號開始反復使用產生式進行推導直至推導出輸入符號串。自下而上分析有規范歸約分析法、算符優先分析法等，算符優先分析法是不含ε產生式的算符文法。自上而下分析方法有ll(1)分析法，遞歸子程序法等。自頂而下分析通常要求文法的產生式不含左遞歸，否則會使分析程序死循環。
[2-8]
在程序設計語言中，一般有兩類子程序：過程和函數。一個過程通常有四個要素組成：過程名、一組稱為形式參數的名字、過程體和過程中使用的全局量。
[2-12]
許多編譯程序采用了一種與“3地址指令”近似的四元式作為中間代碼。形式為：
算符???左操作數????右操作數????結果
[2-14]
x+a*(y-b)-z/f的前綴表示為-+x*a-yb/zf，后綴表示為xayb-*+zf/-。
方法：把表達式轉化為二叉樹，因為先加后減所以可以表示為(x+a*(y-b))-z/f，所以減號應為二叉樹的根。在前序遍歷這顆樹就可得到前綴表示，后序遍歷可得后綴表示。
[2-15]
巴克斯范式（dnf）可以用來描述程序設計語言的語法，最早用于算法語言algol60，后進行了擴充。常用符號為：
::=?表示定義為；
<>?表示非終結符；
[]?表示可以出現0或1次；
{}?表示可以出現任意次；
|?表示或者。

（第三章）
[3-4]
內、外存之間交換信息的基本單位有兩種：一種是以作業為單位，一個作業在內存中運行一個時間片后，處理機就去運行另一個作業，如果那個作業不在內存，就將它整個調入內存，內存沒空，則將內存中的某個作業整個調出，這種技術叫做SWAPPING技術，它要求作業的地址空間要小于等于內存的可用空間。另一種交換技術是在作業內部做部分信息的調入調出，通常將作業地址空間分頁（或段），交換以頁（段）為單位，我們稱這種交換技術為虛擬存儲技術。虛擬存儲技術有請求頁式、段式、段頁式等實現方法。虛擬存儲技術允許用戶運行比實際內存大得多的程序。
虛擬存儲技術中采用的淘汰策略的理論基礎是程序的局部性原理，據此，操作系統可以根據工作集來改善系統的性能，它是一個進程在定長的執行時間區間內涉及到的頁面集合。
[3-7]
在操作系統中，處理機管理部分由作業管理和進程管理兩部分組成。作業管理是把作業流分成提交、后備、運行、完成4個狀態。進程管理是把進程分成就緒、運行、阻塞3個基本狀態。作業由提交狀態到后備狀態由假脫機（spooling）處理程序完成，由后備狀態到運行狀態由作業調度程序完成，進程由就緒狀態到執行狀態由進程調度程序完成，由執行狀態到阻塞狀態或就緒狀態由進程調度程序完成，由運行狀態到完成狀態由作業調度程序完成。用戶進程的祖先進程是由作業調度程序建立的。
[3-11][3-16]
操作系統中，對付死鎖有兩種策略，一種是在死鎖發成前采用的預防和避免策略，另一種是在死鎖發成后采用的檢查與恢復策略。前者付出的代價大于后者。
產生死鎖的基本原因是系統資源不足和進程推進順序非法。
產生死鎖的4個必要條件是互斥條件、請求和保持條件、不剝奪條件，環路等待條件。
[3-14]
存儲分配解決多道作業主存的劃分問題。為了實現靜態和動態存儲分配，需要采用地址重定位，即把邏輯地址變換為物理地址。靜態重定位由連接裝入程序實現，動態重定位由硬件地址變換機構實現。
[3-17]
有結構的記錄文件可分為：順序文件、索引文件、直接文件、索引順序文件。

（第四章）
[4-1]
關系代數的最基本操作有并、差、笛卡爾積、選擇、投影。
視圖是從一個或幾個基本表（或視圖）導出的表。視圖所對應的數據不是實際存儲在數據庫中，在數據庫中只存放視圖的定義。
在關系模型中，一般有實體完整性規則和引用完整性規則。實體完整性規則是主鍵值不能是空值。引用完整性規則要求“不允許引用不存在的實體”，若關系R的屬性A為外關鍵字（設為關系S的主關鍵字），則對于R中每個元組在A上的值或均取空值，或等于S的某個元組的主關鍵字值。
SQL語言時高度非過程化語言，用戶不必了解存取路徑，存取路徑的選擇和SQL語言的操作過程由系統自動完成。
嵌入式的數據庫語言構成的應用程序環境包括主語言（如程序設計語言C）和數據子語言（如SQL），后者只能處理表，前者能處理記錄和域，游標機制起這兩種語言的橋梁作用。
事務（Transaction）是數據庫運行的基本工作單位。如果一個事務執行成功，則全部更新提交；如果一個事務執行失敗，則所做過的全部更新被恢復原狀。這樣保持了數據庫處于一致性狀態。在數據庫中，把未提交的隨后又被撤消的更新數據稱為“臟數據”，用戶對“臟數據”的讀出是由于并發控制未做好，由操作異常造成的。
在數據庫中由于為了實現快速檢索某些數據，允許數據有一定的冗余。實際進行數據庫設計時，不可能完全消除數據冗余，只能盡量減少數據的冗余度。
[4-2]
規范理論中，分解關系模式主要是消除關系模式中多余的數據相關性。
[4-3]
數據庫系統中，數據獨立性分為物理數據獨立性和邏輯數據獨立性。
“封鎖“機制是解決并發操作的，“授權”是數據庫系統采用的安全措施。
[4-4]
在關系模型中，一個數據庫模式是關系模式的集合，對于同一個應用問題，可以選用不同的關系模式集做為數據庫模式。為了區分優劣，把關系模式分成不同等級的范式，滿足不同范式的關系模式在減少數據冗余度和消除存儲異常等方面性能相差很大。
第一范式（1NF）：關系模式R的每個關系r的屬性值是不可分解的，則稱R是1NF模式。
第二范式（2NF）：若R是1NF模式，且每個非主屬性完全函數依賴于各個鍵，則稱R是2NF模式。
第三范式（3NF）：若R是2NF模式，且每個非主屬性傳遞都不依賴于任何鍵，則稱R是3NF模式。
通常，1NF和2NF未消除部分函數依賴和傳遞依賴關系，其數據冗余度較大，存儲異常較多。
[4-6]
網狀模型用有向圖來表示實體類型及實體間聯系，搜索數據時，可以從任意節點開始沿任何路徑搜索。
層次模型用樹來表示實體類型及實體間聯系。
關系模型用二維表來表示實體類型及實體間聯系。
[4-8][4-11]
關系型數據庫語言SQL基本的使用方式有兩種。單獨使用，稱為交互式語言，供交互環境下的終端用戶使用。SQL語句還可用在應用程序中，SQL語句可直接嵌入在程序中使用，這就是嵌入式SQL，這時，相應的高級語言稱為宿主語言。
從SQL數據庫的體系結構角度來看，用戶可以用SQL語言的語句，對視圖和基本表進行查詢等操作。
關系數據庫的數據操作語言主要包括檢索和更新操作。檢索又稱查詢，是用SELECT語句；更新包括插入、刪除和修改，使用INSERT、DELETE、UPDATE等。
數據庫全新組織只是移動或組合而已。因此對數據庫重新組織的方法基本上是復制、排序和連接3種。
[4-13]來表示實體類型及實體間聯系。
數據庫恢復的基本原則就是冗余。實現方法：
1、定期將數據庫做備份；
2、在進行事務處理時，對數據更新（插入、刪除、修改）的全部有關內容寫入日志文件；
3、在系統正常運行時，按一定的時間間隔，設立檢查點文件。把內存緩沖區內容還未寫入到磁盤中去的有關狀態記錄到檢查點文件中；
4、發生故障時，根據現場數據內容、日志文件的故障前映像和檢查點文件來恢復系統的狀態。
[4-14]
關系模式是一個關系的屬性名序列，也就是一個關系的型。
一個關系數據庫系統的邏輯結構是所有有關關系模式的集合。關系數據庫模式是數據的型的表示，關系數據庫則是數據的值的表示。
[4-15]
數據庫系統通常包括數據庫、硬件、軟件、人員組成。

（第五章）
[5-1]
軟件的維護的費用一般占軟件生存周期全部費用的60-80%左右。
軟件的測試的費用已超過軟件開發費用的30%。
[5-2]
軟件的測試過程分為單元測試、組裝測試、確認測試。單元測試也稱模塊測試，在編碼階段完成，多采用白盒測試法，其測試計劃是在詳細設計階段制定的；組裝測試是按照概要設計階段設計的程序結構圖將各個模塊裝配在一起進行測試，一般采用黑盒法，其測試計劃是在概要設計階段制定的；確認測試是依需求規格說明書為依據，檢查軟件的功能、性能及其他特征是否與用戶的需求一致，通常采用黑盒測試法，其測試計劃是在需求分析階段制定的。
[5-3]
軟件測試的目的是盡可能發現軟件中的錯誤，不是證明軟件是正確的。
測試用例的設計方法有兩種：黑盒測試方法和白盒測試方法。黑盒測試常用的有等價類劃分、邊值分析、錯誤猜測、因果圖等技術。白盒測試常用的技術是邏輯覆蓋，主要的覆蓋標準有六種：語句覆蓋、判定覆蓋、條件覆蓋、判定/條件覆蓋、條件組合覆蓋、路徑覆蓋。語句覆蓋是指選擇足夠的測試用例，使得運行這些測試用例時，被測程序的每一個語句至少執行一次，其覆蓋標準無法發現判定中邏輯運算的錯誤；判定覆蓋是指選擇足夠的測試用例，使得運行這些測試用例時，每個判定的所有可能結果至少出現一次，但若程序中的判定是有幾個條件聯合構成時，它未必能發現每個條件的錯誤；條件覆蓋是指選擇足夠的測試用例，使得運行這些測試用例時，判定中每個條件的所有可能結果至少出現一次，但未必能覆蓋全部分支；判定/條件覆蓋是使判定中每個條件的所有可能結果至少出現一次，并且每個判定本身的所有可能結果也至少出現一次；條件組合覆蓋是使每個判定中條件結果的所有可能組合至少出現一次，因此判定本身的所有可能解說也至少出現一次，同時也是每個條件的所有可能結果至少出現一次；路徑覆蓋是每條可能執行到的路徑至少執行一次；其中語句覆蓋是一種最弱的覆蓋，判定覆蓋和條件覆蓋比語句覆蓋強，滿足判定/條件覆蓋標準的測試用例一定也滿足判定覆蓋、條件覆蓋和語句覆蓋，條件組合覆蓋是除路徑覆蓋外最強的，路徑覆蓋也是一種比較強的覆蓋，但未必考慮判定條件結果的組合，并不能代替條件覆蓋和條件組合覆蓋。
[5-4]
在軟件工程的設計階段中，有三種常用的設計方法：結構化設計（SD）、Jackson方法和Parnas方法。SD方法側重于模塊要相對獨立，并且功能單一，使塊間聯系弱，塊內聯系強；Jackson方法則是由數據結構導出模塊結構；Parnas法的主要思想信息隱蔽。
[5-7]
系統定義明確后，應該對系統的可行性進行分析研究。包括：技術可行性、經濟可行性和社會可行性等方面。
[5-8]
軟件工程技術應該遵循分解、一致性、確定行及抽象和信息隱蔽的原則。
軟件工程包括3個要素：方法、工具和過程。
[5-11]
較全面地評價軟件質量，應該從易維護性、可靠性、效率和易理解性方面考慮。
[5-12][5-15]
模塊獨立性要追求低耦合高內聚（耦合是模塊間的關系，內聚是模塊內的關系）。
下面按它們的耦合度從低到高的順序一次介紹。
1、非直接耦合。非直接耦合是指兩個模塊沒有直接的聯系，它們中的任何一個都不依賴于對方而獨立工作。
2、數據耦合。數據耦合是指兩個模塊借助于參數表傳遞簡單數據。
3、標記耦合。當一個數據結構的一部分（如記錄的一部分）借助于模塊接口被傳遞時就發生標記耦合。
4、控制耦合。控制耦合指兩個模塊間傳遞的信息中包含用于控制模塊命令邏輯的控制信息。
5、外部耦合。當模塊與軟件以外的環境有關時就發生外部耦合。
6、公共耦合。多個模塊引用同一全局數據區的模式稱公共耦合。
7、內容耦合。內容耦合指兩個模塊之間出現的三種之一：一個模塊之際訪問另一個模塊的內部數據；一個模塊不通過正常入口轉到另一個模塊的內部；一個模塊有多個入口。
模塊的內聚種類通常分為七種，按內聚度從低到高的次序依次為：偶然內聚、邏輯內聚、瞬時內聚、過程內聚、通信內聚、順序內聚、功能內聚。
[5-16]
OMT是一種對象建模技術，它定義了三種模型，它們分別是對象模型、動態（ER）模型和功能模塊。對象模型描述系統中對象的靜態結構、對象間的關系、對象的屬性和操作；動態模型描述系統中于時間和操作順序有關的系統特征，表示瞬時的行為上的系統的“控制”特征，通常用狀態圖表示；功能模型描述與值的變換有關的系統特征----功能、映射、約束和函數依賴，通常用數據流圖表示。
[5-17]
DFD就是面向數據流分析方法的描述工具。在畫分層DFD時，應該注意保持父圖與其子圖之間的平衡。DFD中從系統的輸入流到系統的輸出流的一連串連續變換

形成一種信息流，這種信息流可分為變換流和事務流。

（第六、七章）
[6-3]
Ethernet與Internet連接時要用到地址轉化協議ARP。
[6-4]
中繼器、集線器（主要用于星型拓撲）屬于OSI物理層；
網橋、交換機屬于OSI數據鏈路層；
路由器屬于OSI網絡層；
網關屬于OSI應用層。
[6-6]
計算機網絡具有良好的安全性，應當由真實性、可靠性、完整性、實用性和占有性、保密性指標組成。
[6-7]
把若干臺計算機合成一個現代計算機網絡機，可以實現下列3個基本功能：
1、計算機之間和計算機用戶之間的互相通信與交往；
2、共享資源，包括硬件資源、軟件資源和數據；
3、計算機之間或計算機用戶之間的協同合作。
[6-10]
局域網特征，也就是硬件特性、資源分配策略和用戶特性的特征。
[6-12]
在兩個實體間控制數據交換的規則的集合稱為協議或規程。協議的關鍵成分是：語法（Syntax），包括數據格式、編碼及信號電平等；語義（Semantics），包括用于協調和差錯處理的控制信息；定時（Timing），包括速度匹配和排序。
[7-2]
WAV文件的字節數/每秒 = 采樣頻率（HZ）* 量化位數（位）* 聲道數 / 8
MIDI是一種樂器數字接口，它是該領域國際上的一個通信標準。
[7-3]
色彩光是由亮度、對比度和飽和度這3個特征的綜合效果，通常把色調和飽和度通稱為色度。
顏色光都是可以由紅、綠、藍3種顏色光按照不同比例相配而成。
[7-6]
無閃爍顯示動畫需要每秒25幀以上，如果640x480的有2^24種彩色的圖像占用大約7.4MB，要無閃爍顯示10s，需要大概：
7.4 x 25 x 10 = 1850MB的存儲空間，還需要有極高通道數據傳送率。所以數據壓縮技術是多媒體計算機的關鍵技術之一。
目前公認的關于壓縮編碼的國際標準是：用于多灰度靜止圖像的JPEG標準；用于電視電話/會議電視的Px64KB/s標準；用于數字存儲媒體運動圖像的MPEG標準。
[7-10]
交互式點是最常用的是節目間的交互，即點播電視技術（VOD）系統，典型的VOD系統主要由視頻服務器、編碼器/路由器、計算機和機頂盒組成。

續（排序）

小弟愚笨，對排序、查找和算法等程序題，不能一眼看穿，不得不敲出來，調試著程序才看的懂，慚愧慚愧，下面是我寫的排序程序總結，如果有哪位和小弟水平相當，偏偏又想知道這究竟，下面的程序可供大家調試用。環境：win2000中文+VC++6.0。
如果有不對的地方，還請哥哥們指出，以免貽笑大方。

　

//?store.cpp?:?Defines?the?entry?point?for?the?console?application.
//

#include?"stdafx.h"

void?InsertSort(int?*store);?//直接插入排序函數
void?ShellSort(int?*store);??//希爾排序函數
void?PopSort(int?*store);??//冒泡排序函數
void?CallQuickRecursion(int?*store);??//調用遞歸快速排序函數
void?QuickRecursion(int?*store,?int?low,?int?high);?//快速排序函數----遞歸
void?CallQuickNoRecursion(int?*store);?//調用非遞歸快速排序函數
void?QuickNoRecursion(int?*current,?int?n);??//快速排序函數----非遞歸
void?SelectSort(int?*store);?//簡單選擇排序函數
void?HeapSort(int?*store);??//堆排序函數
void?HeapAdjust(int?*current,?int?s,?int?m);

#define?N?40

int?main(int?argc,?char*?argv[])
{
?int?store[11]?=?{0,?49,?38,?65,?97,?76,?13,?27,?49,?50,?77};//待排數列

?//打印待排數列
?printf("從小到大排序\n");
?printf("未排序數列為：\n");
?for?(int?i=1;?i<=10;?i++)
??printf("?%d?",?store[i]);
?printf("\n");
?//排序方法
?InsertSort(store);?//直接插入排序
?ShellSort(store);?//希爾排序
?PopSort(store);??//冒泡排序
?CallQuickRecursion(store);//調用遞歸快速排序
?CallQuickNoRecursion(store);//調用非遞歸快速排序
?SelectSort(store);?//簡單選擇排序
?HeapSort(store);?//堆排序
?return?0;
}

void?InsertSort(int?*store)
{
?int?i=0,?j=0;?
?//復制數組
?int?current[11];
?for(i=0;?i<=10;?i++)
??current[i]?=?store[i];
?printf("直接插入排序:\n");
?//開始排序
?for(i=2;?i<=10;?i++)
?{
??if(current[i-1]?>?current[i])
??{
???current[0]?=?current[i];
???for(j=i-1;?current[j]>current[0];?j--)
????current[j+1]?=?current[j];
???current[j+1]?=?current[0];
??}
?}
?//打印數組
?for(i=1;?i<=10;?i++)
??printf("?%d?",?current[i]);
?printf("\n");
}

void?ShellSort(int?*store)
{
?int?i=0,?j=0,?k=0;
?//復制數組
?int?current[11];
?for(i=0;?i<=10;?i++)
??current[i]?=?store[i];
?printf("希爾排序:\n");
?//定義排序增量數組
?int?increase[4]?=?{0,?1,?3,?5};
?//開始排序
?for(k=3;?k>=1;?k--)
?{
??int?count=increase[k];
??i=0,?j=0;
??for(i=count+1;?i<=10;?i++)
??{
???if(current[i-count]?>?current[i])
???{
????current[0]?=?current[i];
????for(j=i-count;?j>0&&(current[j]>current[0]);?j-=count)
?????current[j+count]?=?current[j];
????current[j+count]?=?current[0];
???}
??}
?}
?//打印數組
?for(i=1;?i<=10;?i++)
??printf("?%d?",?current[i]);
?printf("\n");
}

void?PopSort(int?*store)
{
?int?i=0;
?//復制數組
?int?current[11];
?for(i=0;?i<=10;?i++)
??current[i]?=?store[i];
?printf("冒泡排序:\n");
?//開始排序
?int?j,?p,?h;
?for(h=10;?h>1;?h=p)
?{
??for(p=j=1;?j<h;?j++)
???if(current[j]>current[j+1])
???{
????current[0]?=?current[j];
????current[j]?=?current[j+1];
????current[j+1]?=?current[0];
????p?=?j;
???}
?}
?//打印數組
?for(i=1;?i<=10;?i++)
??printf("?%d?",?current[i]);
?printf("\n");
}

void?CallQuickRecursion(int?*store)
{
?//復制數組
?int?current[11];
?for(int?i=0;?i<=10;?i++)
??current[i]?=?store[i];
?printf("快速排序----遞歸:\n");
?QuickRecursion(current,?1,?10);//快速排序----遞歸
?//打印數組
?for(i=1;?i<=10;?i++)
??printf("?%d?",?current[i]);
?printf("\n");
}

void?QuickRecursion(int?*current,?int?low,?int?high)
{
?int?i,j;
?if(low<high)
?{
??i=low;?j=high;?current[0]=current[low];
??while(i<j)
??{
???while(i<j&¤t[j]>current[0])?j--;
???if(i<j)?current[i++]=current[j];
???while(i<j&¤t[i]<=current[0])?i++;
???if(i<j)?current[j--]=current[i];
??}
??current[i]=current[0];
??QuickRecursion(current,?low,?i-1);
??QuickRecursion(current,?i+1,?high);
?}
}

void?CallQuickNoRecursion(int?*store)
{
?//復制數組
?int?current[11];
?for(int?i=0;?i<=10;?i++)
??current[i]?=?store[i];
?printf("快速排序----非遞歸:\n");
?QuickNoRecursion(current,?10);//快速排序----非遞歸
?//打印數組
?for(i=1;?i<=10;?i++)
??printf("?%d?",?current[i]);
?printf("\n");
}

void?QuickNoRecursion(int?*current,?int?n)
{
?int?i,?j,?low,?high;
?int?stack[N][2];
?stack[0][0]?=?1;
?stack[0][1]?=?n;
?int?top?=?1;
?while(top>0)
?{
??top--;
??low?=?i?=?stack[top][0];
??high?=?j?=?stack[top][1];
??current[0]?=?current[low];
??while(i<j)
??{
???while(i<j&¤t[j]>current[0])?j--;
???if(i<j)?current[i++]?=?current[j];
???while(i<j&¤t[i]<current[0])?i++;
???if(i<j)?current[j--]?=?current[i];
??}
??current[i]?=?current[0];
??if(i-1>low)
??{
???stack[top][0]?=?low;
???stack[top][1]?=?i-1;
???top++;
??}
??if(high>i+1)
??{
???stack[top][0]?=?i+1;
???stack[top][1]?=?high;
???top++;
??}
?}
}

void?SelectSort(int?*store)
{
?int?i,?j,?k;
?//復制數組
?int?current[11];
?for(i=0;?i<=10;?i++)
??current[i]?=?store[i];
?printf("簡單選擇排序:\n");
?for(i=1;?i<=10;?i++)
?{
??for(k=i,?j=i+1;?j<=10;?j++)
???if(current[j]<current[k])?k?=?j;
??if(k!=i)
??{
???current[0]?=?current[i];
???current[i]?=?current[k];
???current[k]?=?current[0];
??}
?}
?//打印數組
?for(i=1;?i<=10;?i++)
??printf("?%d?",?current[i]);
?printf("\n");
}

void?HeapSort(int?*store)
{
?int?i;
?//復制數組
?int?current[11];
?for(i=0;?i<=10;?i++)
??current[i]?=?store[i];
?printf("堆排序:\n");

?for(i=5;?i>0;?i--)
??HeapAdjust(current,?i,?10);
?for(i=10;?i>1;?i--)
?{
??current[0]?=?current[1];
??current[1]?=?current[i];
??current[i]?=?current[0];
??HeapAdjust(current,?1,?i-1);
?}
?//打印數組
?for(i=1;?i<=10;?i++)
??printf("?%d?",?current[i]);
?printf("\n");
}

void?HeapAdjust(int?*current,?int?s,?int?m)
{
?int?j;
?int?rc?=?current[s];
?for(j=2*s;?j<=m;?j*=2)
?{
??if(j<m&¤t[j]<current[j+1])?++j;
??if(rc>=current[j])?break;
??current[s]?=?current[j];
??s?=?j;
?}
?current[s]?=?rc;
}

結果如下：

從小到大排序
未排序數列為：
?49??38??65??97??76??13??27??49??50??77
直接插入排序:
?13??27??38??49??49??50??65??76??77??97
希爾排序:
?13??27??38??49??49??50??65??76??77??97
冒泡排序:
?13??27??38??49??49??50??65??76??77??97
快速排序----遞歸:
?13??27??38??49??49??50??65??76??77??97
快速排序----非遞歸:
?13??27??38??49??49??50??65??76??77??97
簡單選擇排序:
?13??27??38??49??49??50??65??76??77??97
堆排序:
?13??27??38??49??49??50??65??76??77??97

http://oldchild.nbc.net.cn/jsjsj/spks/ksjy/rrfxzj.htm

轉載于:https://www.cnblogs.com/ganmk/archive/2008/11/07/1328767.html

總結

以上是生活随笔為你收集整理的一些计算机知识的总结（转）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。