《C/C++函數與算法（算法獨立篇）》

版本	作者	參與者	完成日期	備註
YanlzCC++_Algorithm_V01_1.0	嚴立鑽		2020.01.17

##《C/C++函數與算法（算法獨立篇）》發佈說明：

++++“C/C++函數與算法（算法獨立篇）”：是對“C++C鑄就生存利器”的綜合探索；C/C++作爲萬能語言，可以開發嵌入式、物聯網，也可以開發遊戲（Cocos2dx、UE4）；

++++“C/C++函數與算法（算法獨立篇）”：定位在一個科普類知識，瞭解C/C++相關庫和算法！

++++Tips：“算法獨立篇”：是《C/C++函數與算法》的姊妹篇，“算法獨立篇”將以C/C++算法爲核心；算法是程序員設計的靈魂；

++++姊妹篇推薦：

++++【C/C++函數與算法（C庫獨立篇）】：https://blog.csdn.net/VRunSoftYanlz/article/details/104026090

++++【C/C++函數與算法（C++庫獨立篇）】：https://blog.csdn.net/VRunSoftYanlz/article/details/104062275

++++【C/C++函數與算法（Linux C獨立篇）】：https://blog.csdn.net/VRunSoftYanlz/article/details/104076473

++++【C++C鑄就生存利器】分類：https://blog.csdn.net/vrunsoftyanlz/category_9325802.html

@@提示：有些博客可能只是開了頭，如果感興趣的同學，可以“點贊”或“評論區留言”，只要關注的同學多了，那就會繼續完善喲！（“++==”，表示沒有寫完的，如果關注度不高就不完善了；“++ok++”，表示此篇博客已經完成，是階段性完整的！）

++++VR雲遊戲=Unity+SteamVR+雲技術+5G+AI；（*說明：AI人工智能不是我們的主要研究技術，只是瞭解一下，領略一下有風的感覺！**但是，*VR是我們的研究重點）

##《C/C++函數與算法》目錄

#第一篇：C語言函數

#第二篇：C++輸入/輸出

#第三篇：標準容器

#第四篇：算法

#第五篇：立鑽哥哥帶您C/C++編程

#第一篇：C語言函數

++++立鑽哥哥：C語言和C++語言的類庫豐富，利用這些函數可以實現各種功能，這就需要我們掌握C和C++最爲常用的函數；在第四篇還會介紹常用的算法，算法是程序員設計的靈魂；

++++A1、ctype.h

++++A2、stdio.h

++++A3、string.h

++++A4、stdlib.h

++++A5、math.h

++++A6、conio.h

++++A7、graphics.h

++++A8、stdarg.h

++++A9、time.h

++++A10、dir.h

++++A11、立鑽哥哥帶您瞭解其他C函數庫

++++【C/C++函數與算法（C庫獨立篇）】：https://blog.csdn.net/VRunSoftYanlz/article/details/104026090

#第二篇：C++輸入/輸出

++++【C/C++函數與算法（C++庫獨立篇）】：https://blog.csdn.net/VRunSoftYanlz/article/details/104062275

#第四篇：算法

++++立鑽哥哥：算法（Algorithm）是程序設計的靈魂，它是用系統的方法描述解決問題的策略機制；一個正確的算法滿足的性質：輸入、輸出、確定性、有限性等；

++++[輸入]：有零個或多個輸入；

++++[輸出]：至少有一個輸出；

++++[確定性]：組成算法的每條指令清晰，無歧義；

++++[有限性]：一個算法在執行有限步驟後必須結束，即計算步驟是有限的；

++++描述算法可以由多種方式，如自然語言、流程圖、僞代碼、程序設計語言；算法設計就是針對具體的問題，設計出良好的算法，使計算機能夠解決該問題；同一個問題可以採用不同的算法實現，不同的算法可能時間、空間並不相同，一個算法的優劣可以用空間複雜度與時間複雜度來衡量；

++++算法設計中經常採用的排序算法、查找算法、迭代算法、遞推算法、遞歸算法、枚舉算法、貪心算法、回溯算法、矩陣算法等；

++++D23、排序算法

++++D24、查找算法

++++D25、遞推算法

++++D26、迭代算法

++++D27、遞歸算法

++++D28、枚舉算法

++++D29、貪心算法

++++D30、回溯算法

++++D31、矩陣算法

++D23、排序算法

++++立鑽哥哥：排序算法是程序設計中最爲常用的算法；常用的排序算法包括：插入類排序算法、交換類排序算法、選擇類排序算法、歸併排序算法和基數排序算法等；

++++D23.1、插入排序

++++D23.2、交換排序

++++D23.3、選擇排序

++++D23.4、歸併排序

++++D23.5、基數排序

++D23.1、插入排序

++++立鑽哥哥：插入排序的算法思想：將待排序元素分爲已排序子集和未排序子集，依次從未排序子集中的一個元素插入到已排序子集中，使已排序子集仍然有序；重複執行以上過程，直到所有元素都有序爲止；

++++D23.1.1、直接插入排序

++++D23.1.2、折半插入排序

++++D23.1.3、希爾排序

++++D23.1.1、直接插入排序

++D23.1.1、直接插入排序

++++立鑽哥哥：直接插入排序是一種最簡單的插入排序算法；直接插入算法實現簡單，適用於待排序元素較少且基本有序的情況；在元素基本有序時，需要比較的次數和移動的次數很少，因此在這種情況下使用直接插入排序最佳；

++++[穩定性與複雜度]：直接插入排序屬於穩定的排序方法，直接插入排序算法的時間複雜度爲O(n^2)，空間複雜度爲O(1)；

//立鑽哥哥：直接插入排序算法

#include <stdio.h>

void PrintMyArray(int a[], int n);

void main(){

int a[] = { 27, 44, 18, 77, 23, 89, 100};

int t, i, j, n;

n = sizeof(a)/sizeof(a[0]);

for(i=1; i<n; i++){

t = a[i];

for(j=i-1; j>=0&&t<a[j]; j--){

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

}

a[j+1] = t;

PrintMyArray(a, n);

}

void PrintMyArray(int a[], int n)

{

... ...

}

++++D23.1.2、折半插入排序

++D23.1.2、折半插入排序

++++立鑽哥哥：折半插入排序算法是直接插入排序的改進；它的主要改進在於，在已經有序的集合中使用折半查找法確定帶排序元素的插入位置；在找到要插入的位置後，將待排序元素插入到相應的位置；

++++[折半插入排序與直接插入排序的區別]：直接插入排序，從右到左按順序查找插入的位置；折半插入排序，折半查找算法在有序集合中查找插入的位置；

++++[主要用途]：折半插入排序算法也直接插入排序一樣，通常也用於待排序元素的個數較少的情況；如果待排序算法基本有序，則最好採用直接插入排序算法；

++++[穩定性與複雜度]：折半插入排序也是一種穩定的排序算法；雖然折半插入排序在查找插入的位置時改進了查找方法，減少了比較次數，比較次數由O(n)變爲O(nlog2n)；但是移動元素的時間複雜度仍然沒有改變，因此折半查找排序算法的整體時間複雜度仍然爲O(n^2)，它的空間複雜度爲O(1)；

//立鑽哥哥：折半插入排序算法

#include <stdio.h>

void PrintMyArray(int a[], int n);

void main(){

int a[] = { 56, 77, 81, 98, 28, 53, 11 };

int t, i, j, low, high, mid, n;

n = sizeof(a)/sizeof(a[0]);

for(i=1; i<n; i++){

t = a[i];

for(low=0, high=i-1; high>=low; ){

mid = (low+high)/2;

if(t < a[mid]){

high = mid-1;

}else{

low = mid+1;

}

for(j=i-1; j>=low; j--){

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

}

a[low] = t;

PrintMyArray(a, n);

}

void PrintMyArray(int a[], int n){

... ...

}

++++D23.1.3、希爾排序

++D23.1.3、希爾排序

++++立鑽哥哥：希爾排序也屬於插入類排序算法；希爾排序通過縮小增量，將待排序元素劃分爲若干個子序列，分別對各個子序列按照直接插入排序算法進行排序；當增量爲1時，待排序元素構成一個子序列，對該序列排序完畢後希爾排序算法結束；

++++[與直接插入排序、折半插入排序的區別]：直接插入排序、折半插入排序；待排序元素構成一個子序列；希爾排序：待排序元素劃分爲若干個子序列，需要分別對每個子序列進行排序；

++++[主要用途]：希爾排序算法可以使值較小的元素很快向前移動，當待排序元素基本有序時，再使用直接插入排序處理，時間效率會高很多；希爾排序主要用在數據量在5000以下且速度要求並不是很重要的場合；

++++[穩定性和複雜度]：希爾排序是一種不穩定的排序算法；由於增量的選擇是隨機的，因此分析希爾排序算法的時間複雜度就變成一件非常複雜的事情；但是經過研究發現，當增量序列delta[k]=2^(t-k+1)時，希爾排序的時間複雜度爲O(n^(3/2))；希爾排序的空間複雜度爲O(1)；

//立鑽哥哥：希爾排序算法

#include <stdio.h>

void MyShellSort(int a[], int length, int delta[], int m);

void MyShellInsert(int a[], int length, int c);

void MyDispArray(int a[], int length);

void main(){

int a[] = { 43, 56, 78, 92, 43, 21, 31 };

int delta[] = { 4, 2, 1 }, m=3, length=sizeof(a)/sizeof(a[0]);

MyShellSort(a, length, delta, m);

MyDispArray(a, length);

}

//對數組中的元素進行一趟希爾排序，c是增量

void MyShellInsert(int a[], int length, int c){

int i, j, t;

//將距離爲c的元素作爲一個子序列進行排序

for(i=c; i<length; i++){

//如果後者小於前者，則需要移動元素

if(a[i] < a[i-c]){

t = a[i];

for(j = i-c; j>=0 && t<a[j]; j=j-c){

a[j+c] = a[j];

}

//依次將元素插入到正確的位置

a[j+c] = t;

}

//希爾排序，每次調用算法ShellInsert，delta是存放增量的數組

void MyShellSort(int a[], int length, int delta[], int m){

int i;

//進行m次希爾插入排序

for(i=0; i<m; i++){

MyShellInsert(a, length, delta[i]);

MyDispArray(a, length);

}

//輸出數組a中的元素

void MyDispArray(int a[], int length){

}

++D23.2、交換排序

++++立鑽哥哥：交換排序的算法思想：通過交換逆序的元素實現交換排序；交換排序主要有兩種：冒泡排序和快速排序；

++++D23.2.1、冒泡排序

++++D23.2.2、快速排序

++++D23.2.1、冒泡排序

++D23.2.1、冒泡排序

++++立鑽哥哥：冒泡排序是一種簡單的交換類排序算法，它是通過交換相鄰的兩個數據元素，逐步將待排序序列變成有序序列；它的基本算法思想描述：假設待排序元素有n個，從第1個元素開始，依次交換相鄰的兩個逆序元素，直到最後一個元素爲止；當第1趟排序結束，機會將最大的元素移動到序列的末尾；然後按照以上方法進行第2趟排序，次大的元素將會被移動到序列的倒數第2個位置；依次類推，經過n-1趟排序後，整個元素序列就成了有序的序列；每趟排序過程中，值小的元素向前移動，值大的元素向後移動，就像氣泡一樣向上升，因此將這種排序方法稱爲冒泡排序；

++++[主要用途]：冒泡算法實現簡單，適用於待排序元素較少且對時間要求不高的場合；

++++[穩定性與複雜度]：冒泡排序是一種穩定的排序方法；假設待排序元素爲n個，則需要進行n-1趟排序，每趟排序需要進行n-i次比較，其中i=1,2,...,n-1；因此，冒泡排序的比較次數爲E(...)=(n(n-1))/2，移動元素的次數爲(3n(n-1)/2)，它的時間複雜度爲O(n^2)，空間複雜度爲O(1)；

//立鑽哥哥：冒泡排序算法

#include <stdio.h>

void MyPrintArray(int a[], int n);

void main(){

int a[] = { 45, 78, 92, 44, 52, 67, 98, 12 };

int i, j, t, n=sizeof(a)/sizeof(a[0]);

for(i=1; i<n; i++){

for(j=0; j<n-i; j++){

if(a[j] > a[j+1]){

t = a[j];

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

a[j+1] = t;

}

MyPrintArray(a, n);

}

void MyPrintArray(int a[], int n){

... ...

}

++++D23.2.2、快速排序

++D23.2.2、快速排序

++++立鑽哥哥：快速排序是冒泡排序算法的改進，也屬於交換類排序算法；快速排序正是將每個部分都以樞軸元素爲中心不斷地劃分元素序列，直到每個序列中的元素只有一個，不能繼續劃分爲止；

++++快速排序算法可以通過遞歸調用實現，排序的過程其實就是不斷地對元素序列進行劃分，直到每一個部分不能劃分時即完成快速排序；

++++[主要用途]：快速算法是冒泡排序算法的改進，實現比較算法，它主要用在需要對大量數據進行排序的情況，它的時間效率要遠高於冒泡排序，在數據量特別大的情況下特別明顯；

++++[穩定性與複雜度]：快速排序是一種不穩定的排序算法；在最好的情況下，每趟排序都是將元素序列正好劃分爲兩個等長的子序列；這樣，快速排序子序列的劃分過程就是創建完全二叉樹的過程，劃分的次數等於樹的深度即log2n，因此，最好的情況下，時間複雜度爲O(n^2)；在最壞的情況下，待排序元素序列已經是有序的，則時間的花費主要集中在元素的比較次數上；每一趟需要比較n-1次，第二趟需要比較n-2次，依次類推，共需要比較n(n-1)/2次，因此時間複雜度爲O(n^2)；在平均情況下，快速排序的時間複雜度爲O(nlog2n)；快速排序的空間複雜度爲O(log2n)；

//立鑽哥哥：快速排序算法

#include <stdio.h>

void MyDispArray(int a[], int n);

void MyDispArray2(int a[], int n, int pivot, int count);

void MyQSort(int a[], int n, int low, int high);

void MyQuickSort(int a[], int n);

void MyPartition(int a[], int low, int high);

//利用快速排序算法對數組a中的元素排序

void MyQSort(int a[], int n, int low, int high){

int pivot;

static count = 1;

//如果元素序列的長度大於1

if(low < high){

//將待排序序列a[low,high]劃分爲兩部分

pivot = MyPartition(a, low, high);

count++;

//對左邊的子表進行遞歸排序，pivot是樞軸位置

MyQSort(a, n, low, pivot-1);

//對右邊的子表進行遞歸排序

MyQSort(a, n, pivot+1, high);

}

//對數組a進行快速排序

void MyQuickSort(int a[], int n){

MyQSort(a, n, 0, n-1);

}

//對數組a[low, high]的元素進行一趟排序，使樞軸前面的元素小於樞軸元素，樞軸後面的元素大於等於樞軸元素，並返回樞軸位置

int MyPartition(int a[], int low, int high){

int t, pivot;

//將表的第一個元素作爲樞軸元素

pivot = a[low];

t = a[low];

//立鑽哥哥：從表的兩端交替地向中間掃描

while(low < high){

//從表的末端向前掃描

while(low<high && a[high]>=pivot){

high--;

}

//將當前high指向的元素保存在low位置

if(low < high){

a[low] = a[high];

low++;

}

//從表的始端向後掃描

while(){

low++;

}

//將當前low指向的元素保存在high位置

if(low < high){

a[high] = a[low];

high--;

}

//將樞軸元素保存在low的位置

a[low] = t;

}

//返回樞軸所在位置

return low;

}

void MyDispArray2(int a[], int n, int pivot, int count){

... ...

}

void MyDispArray(int a[], int n){

... ...

}

void main(){

int a[] = { 33, 66, 77, 88, 43, 23, 14, 58 };

int n = sizeof(a)/sizeof(a[0]);

MyDispArray(a, n);

MyQuickSort(a, n);

MyDispArray(a, n);

}

++++立鑽哥哥：快速算法是冒泡排序算法的改進，實現比較複雜，它主要用在需要對大量數據進行排序的情況，它的時間效率要遠高於冒泡排序，在數據量特別大的情況下特別明顯；

++D23.3、選擇排序

++++立鑽哥哥：選擇排序的算法思想：從待排序的元素序列中選擇最小（最大）的元素，將其放在已排序元素序列的最前（最末），其餘的元素構成新的待排序元素序列，然後從待排序元素序列中選擇最小（最大）的元素，將其放在已排序元素序列的最前（最末）；依次類推，直到待排序元素序列中沒有待排序的元素；選擇排序主要有兩種：簡單選擇排序和堆排序；

++++D23.3.1、簡單選擇排序

++++D23.3.2、堆排序

++++D23.3.1、簡單選擇排序

++D23.3.1、簡單選擇排序

++++立鑽哥哥：簡單選擇排序是一種簡單的選擇類排序算法，它是通過依次找到待排序元素序列中最小的數據元素，並將其放在序列的最前面，從而使待排序元素序列變爲有序序列；它的基本算法思想描述：假設待排序的元素序列有n個，在第一趟排序過程中，從n個元素序列中選擇最小的元素，並將其放在元素序列的最前面即第一個位置；在第二趟排序過程中，從剩餘的n-1個元素中，選擇最小的元素，將其放在第二個位置；依次類推，直到沒有待比較的元素，簡單選擇排序算法結束；

++++[主要用途]：簡單選擇排序算法實現簡單，適用於待排序元素較少且對時間要求不高的場合；