文章目錄

• • • 棧
    • • 單調棧
    • 樹
    • • 樹的深度遍歷和廣度遍歷
      • 樹的前序遍歷和中序遍歷以及后序遍歷的非遞歸實現
      • 二叉樹的查找 插入 刪除
      • AVL樹和紅黑樹
      • B樹和B+樹
    • 圖
    • • 圖的數據存儲方式
      • 圖的深度優先搜索
      • 圖的廣度優先搜索
      • 圖最小生成樹
      • • kruskal算法
        • prim算法
      • 圖拓撲排序
      • 關鍵路徑算法
      • dijkstra 單源最短路徑
      • Bellman-Ford 解決負權邊算法
      • Floyd 多源最短路徑算法
      • 最大流
    • 字符串算法
    • • BF 暴力匹配算法
      • RK 哈希匹配
      • BM算法
      • kmp算法
      • trie樹 （字典樹）
    • 排序算法
    • • 插入排序和希爾排序
      • 冒泡排序和歸并排序
      • 選擇排序和快速排序
      • 堆排序

棧

單調棧

單調棧有單調遞增棧和單調遞減棧，單調棧的原理就是保證棧內元素是有序的，當加入一個棧中的元素破壞這個屬性的時候就pop出棧中元素。單調棧的變體就是棧內存著的是元素的索引，通過索引判斷棧內元素是否有序。

單調棧用來解決溫度遞增 柱狀圖面積等問題

class Solution { public:vector<int> dailyTemperatures(vector<int>& temperatures) {vector<int> res(temperatures.size(),0);stack<int> record;for(int i = 0; i < temperatures.size();i++){if(record.empty()){record.push(i);continue;}else{if(temperatures[i] <= temperatures[record.top()]){record.push(i);continue;}else{while((!record.empty()) && (temperatures[record.top()] < temperatures[i])){int temp = record.top();record.pop();res[temp] = i - temp;}record.push(i);}}}return res;}};

class Solution { public:int largestRectangleArea(vector<int>& heights) {stack<int> boundStack;vector<int> leftBound(heights.size(),0);vector<int> rightBound(heights.size(),0);//確定左邊界for(int i = 0; i < heights.size();i++){while(!boundStack.empty() && (heights[boundStack.top()] >= heights[i])){boundStack.pop();}if(boundStack.empty()){leftBound[i] = -1;}else{leftBound[i] = boundStack.top();}boundStack.push(i);}boundStack= stack<int>(); //把棧中內存清空//確定右邊界for(int i = heights.size()-1;i >= 0;i--){while(!boundStack.empty() && (heights[boundStack.top()] >= heights[i])){boundStack.pop();}if(boundStack.empty()){rightBound[i] = heights.size();}else{rightBound[i] = boundStack.top();}boundStack.push(i);}int maxSize = 0;for(int i = 0;i < heights.size();i++){int curSize = (rightBound[i] - leftBound[i]-1) * heights[i];if(curSize > maxSize){maxSize = curSize;}}return maxSize;} };

樹

樹的深度遍歷和廣度遍歷

廣度遍歷可以用隊列，深度遍歷可以遞歸或者用棧來實現非遞歸。

樹的前序遍歷和中序遍歷以及后序遍歷的非遞歸實現

struct tree {int value;tree* leftChild;tree* rightChild; };tree* getTree() {tree* res = new tree{ 1,nullptr };tree* res1 = new tree{ 2,nullptr };tree* res2 = new tree{ 3,nullptr };tree* res3 = new tree{ 4,nullptr };tree* res4 = new tree{ 5,nullptr };tree* res5 = new tree{ 16,nullptr };res->leftChild = res1;res->rightChild = res2;res1->leftChild = res3;res1->rightChild = res4;res2->leftChild = res5;return res; }void forwardTravese() //前序遍歷 {tree* head = getTree();stack<tree*> stkTree;stkTree.push(head);while (!stkTree.empty()){tree* cur = stkTree.top();stkTree.pop();cout << cur->value << " " << endl; //這一行就是打印當前遍歷點if (cur->rightChild != nullptr){stkTree.push(cur->rightChild);}if (cur->leftChild != nullptr){stkTree.push(cur->leftChild);}} }void midTraverse() //中序遍歷，中序遍歷比較復雜，首先是只考慮父節點的一個右節點，然后等遍歷到了這個右節點，又以這個右節點為根節點繼續 {tree* p = getTree();stack<tree*> stkTree;while (p != nullptr){while (p != nullptr){if (p->rightChild != nullptr){stkTree.push(p->rightChild);}stkTree.push(p);p = p->leftChild;}//先打印一下最左邊的左節點p = stkTree.top();stkTree.pop();while ((p->rightChild == nullptr) && (!stkTree.empty())) //這一塊的代碼很靈性{cout << p->value << " " << endl; //單邊樹p = stkTree.top();stkTree.pop();}cout << p->value << " " << endl; //如果有右子樹，把父節點打印出來if (!stkTree.empty()){p = stkTree.top(); //像一個新子樹一樣中序遍歷stkTree.pop();}else{p = nullptr;}} }

二叉樹的查找 插入 刪除

二叉樹的刪除除了分三種情況考慮如何移動元素，對于空間的刪除也要搞清楚，刪除的是移動的指針空間內容，這個個空間內容已經被分配給了之前指向刪除空間的指針。

tree* searchTree(int value, tree* &root)//查找 {if (root == nullptr){return nullptr;}tree* res = root;while (res != nullptr){if (res->value == value){return res;}else if (res->value > value){res = res->leftChild;}else {res = res->rightChild;}if (res == nullptr){return nullptr;}}return res; }void insertTree(int value, tree* &root)//插入 {if (root == nullptr){root = new tree{ value,nullptr,nullptr };return;}tree* s = root;while (s != nullptr){tree* old = s;if (s->value == value){return;}else if (s->value > value){s = s->leftChild;if (s == nullptr){old->leftChild = new tree{ value,nullptr,nullptr };}}else{s = s->rightChild;if (s == nullptr){old->rightChild = new tree{ value,nullptr,nullptr };}}} }void deleteTree(int value, tree* &root) //刪除 {tree* dTree = nullptr;dTree = searchTree(value, root);if (dTree == nullptr){return;}//分三種情況處理//dTree沒有右子樹if (dTree->rightChild == nullptr){tree* temp = dTree->leftChild;//這是關鍵***********(*dTree) = (*dTree->leftChild); //不用刪除空間，只需要對內存位置重新賦值就可以了******delete temp; //刪除被移動的空間*********return;}//dTree沒有左子樹if (dTree->leftChild == nullptr){tree* temp = dTree->rightChild;(*dTree) = (*dTree->rightChild);delete temp;return;}//dTree左子樹和右子樹都存在,把當前節點的右子樹嫁接到左子樹的最右tree* temp = dTree->leftChild;while (temp->rightChild != nullptr){temp = temp->rightChild;}temp->rightChild = dTree->rightChild;temp = dTree->leftChild;(*dTree) = (*dTree->leftChild);delete temp;;return;}int main() {tree* root = nullptr;insertTree(9, root);insertTree(6, root);insertTree(15, root);insertTree(5, root);insertTree(7, root);insertTree(11, root);insertTree(3, root);insertTree(8, root);forwardTravese(root);tree* target = searchTree(7,root);if (target != nullptr){cout << &(*target) << " :" << target->value << endl;}else{cout << "no the value " << endl;}deleteTree(6, root);forwardTravese(root); }

AVL樹和紅黑樹

AVL樹和紅黑樹的設計目標都是為了保持樹的平衡的，就是防止樹退化成鏈表，影響算法性能。然后具體都設計了插入和刪除的規則。

B樹和B+樹

B樹是主要用于設計這個磁盤和內存中數據交互用的，因為B樹一個節點可以存儲很多鍵值，節點大小較大，這樣可以節約磁盤IO次數和時間。B樹一個節點最多可以有m個鍵值和m-1個子節點，B樹必須是半滿的這個由插入和刪除的規則來保證。B+樹在B樹的基礎上，B樹每個節點都保存了數據，但是B+樹只有葉子幾點才保存數據，這樣便于遍歷整個樹。

圖

圖的數據存儲方式

二維矩陣存儲，鄰接矩陣，適用于密度較高，比較小的圖。
鏈表存儲，鄰接表，適用于密度較低，比較大的圖，對于一寫比如拓撲排序等也很適合。

圖的深度優先搜索

#include<iostream> #include<array> #include<vector> #include<algorithm> #include<string> #include<deque>using namespace::std; const int arraySize = 6; const int self = 0; const int unreach = 1000; int graph[arraySize][arraySize] = { {self,7,3,unreach,unreach,unreach},{unreach,self,unreach,unreach,5,unreach},{unreach,unreach,self,2,2,unreach},{unreach,unreach,unreach,self,unreach,6},{unreach,unreach,unreach,unreach,self,3},{unreach,unreach,unreach,unreach,unreach,self}};vector<int> visited = { 0,0,0,0,0,0 };//DFS 深度優先搜索 找到起點到終點的所有路徑void DFSsearchPath(int start, int target,vector<int>& path,vector<vector<int>> &res) {if (visited[start] == 1) //已經走過return;else{path.push_back(start);//加入路徑visited[start] = 1;//記錄已經走過}for (int j = 0; j < arraySize; j++){if ((graph[start][j] != self) &&( graph[start][j] != unreach))//0表示此路可以走{if (j == target) //到達終點{path.push_back(j);res.push_back(path);path.pop_back();visited[target] = 0;continue;}DFSsearchPath(j, target, path, res); //遞歸調用visited[path.back()] = 0; //記錄是否走過, 回退就是沒有走path.pop_back();//回退}} }

圖的廣度優先搜索

void BFSSearchPath(int start, int target, deque<int>& p,vector<int> &path, vector<vector<int>>& res) //廣度優先搜索算法不適合找到所有路徑，但是可以找到一條最短路徑{p.push_back(start);path.resize(6, 0);int distance[6] = { 0,1000,1000,1000,1000,1000 };//記錄路徑成本while (p.size() != 0){int currentPlace = p.front();p.pop_front();for (int i = 0; i < arraySize; i++){if ((graph[currentPlace][i] != self) && (graph[currentPlace][i] != unreach))//0表示此路可以走{int dis = distance[currentPlace] + graph[currentPlace][i];if ((i != target) && (dis < distance[i])) //這里相當于一個剪枝操作{distance[i] = dis;path[i] = currentPlace;p.push_back(i);}else if((i == target) && (dis < distance[target])){distance[target] = dis;path[i] = currentPlace;}}}}cout << distance[target] << endl;cout << target;while (path[target] != 0){cout << path[target];target = path[target];}cout << path[target] << endl;}

圖最小生成樹

kruskal算法

對于一個圖，將其中存在的所有邊按照從大到小排序，然后依次取出最小的邊，并將邊中的頂點加入到最小生成樹中，但是不允許形成閉環，也就是加入一個邊的時候需要判斷邊中的兩個頂點是否都已經在生成樹中了，生成樹的記錄需要一個頂點集合和一個邊集合。

prim算法

首先從圖中任意選擇一個頂點，找到與此頂點中相連的最小邊，將邊上的另一個頂點加入到最小生成樹，繼續判斷與這個最小生成樹中所有頂點相連的最小邊將其加入到最小生成樹中，（不能形成閉環，也就是邊的另一個頂點不能在最小生成樹中），直到所有頂點都被加入到最小生成樹中。

vector<int> getMinTreePrim(){vector<int> res;res.resize(6, 0);int alreadInVertex[6] = { 1,0,0,0,0,0 };int countAddVertex = 1;while (true){//在已經存在的生成樹的列表里找到一個最近的頂點int minDistance = unreach;int vertex = 0;int father = 0;for (int i =0; i < arraySize;i++){if (alreadInVertex[i] != 1){continue;}for (int j = 1; j < arraySize; j++){if (((graph[i][j] < minDistance) && (alreadInVertex[j] != 1))) //判斷j不能已經在生成樹中{minDistance = graph[i][j];vertex = j;father = i;}}}res[vertex] = father;//加入最小生成樹alreadInVertex[vertex] = 1; //加入最小生成樹，做好邊標記countAddVertex++;if (countAddVertex == arraySize) //打印出來{for (int i = 0; i < arraySize; i++){cout << i <<" : " <<res[i] << endl;}break;}}return res;}

圖拓撲排序

拓撲排序主要是用在工期活動圖中，工程任務之間有先后關系，工程任務必須在其先導任務都完成后，才能開工。
這個問題適用于鄰接表的數據結構，對每一個頂點記錄它的入度和出度，都這個工程完成時，把以其作為先導的任務的入度減一，當一個工程的入度等于0之后，就可以將其加入拓撲隊列中（表示可以開工了），拓撲隊列不唯一。

關鍵路徑算法

首先初始化每個頂點的最早開始為0，然后對AOE網進行拓撲排序，在排序的過程中獲取每個頂點的最早開始時間；
獲取拓撲排序后，初始化每個頂點的最晚開始時間為匯點的最早開始時間，并從AOE網的匯點開始，從后往前，對每個頂點找到求其最晚開始時間；
遍歷圖中的每條邊（方法是遍歷圖中每個頂點的邊表），求其最早開始時間和最晚開始時間，如果二者相等，則這是個關鍵活動，將其加入關鍵路徑中。

dijkstra 單源最短路徑

主要是計算圖中各頂點到起始點的最短路徑。首先創建一個大小位頂點數目的數組dis，記錄各頂點到起始點的距離，不能直達的頂點記為大數。然后維護一個數組book記錄哪些頂點已經被計算過最短路徑，初始只有頂點自己在這個數組中。然后對于所有未計算最短距離的頂點e，找出距離起點最近的頂點,在dis中，然后將這個頂點加入到record中，同時判斷dis中各頂點中與頂點e相連的頂點經過e點到達起點的距離是否更近，如果是更新dsi數組中的值（松弛更新）。直到所有頂點都被計算一邊。

void dijisktra() //記錄所有頂點到最后一個頂點的距離{int distance[6] = { graph[0][5],graph[1][5],graph[2][5],graph[3][5],graph[4][5],graph[5][5] }; int record[6] = { 0,0,0,0,0,1 };// 記錄是否被計算過最短距離int countNum = 1; // 記錄加入過的頂點數目while (true){int minDistance = unreach;int addNum = 0;for (int i = 0; i < arraySize; i++) //尋找一個最近的頂點{if ((record[i] == 0) && (distance[i] < minDistance)){addNum = i;minDistance = distance[i];}}//將最近的頂點加入到已處理頂點記錄中，并且對其他頂點松弛（就是看經過這個頂點是否更快到達目標）record[addNum] = 1;countNum++;for (int i = 0; i < arraySize; i++){if ((distance[addNum] + graph[i][addNum]) < distance[i]) //對頂點距離松弛判斷{distance[i] = (distance[addNum] + graph[i][addNum]);}}if (countNum == arraySize){for (int i = 0; i < arraySize; i++){cout << i << " : " << distance[i] << endl;}break;}}}

Bellman-Ford 解決負權邊算法

dijkstra算法不能解決負權邊的問題，dijkstra是基于貪心策略，每次都找一個距源點最近的點，然后將該距離定為這個點到源點的最短路徑；但如果存在負權邊，那就有可能先通過并不是距源點最近的一個次優點，再通過這個負權邊，使得路徑之和更小，這樣就出現了錯誤。
BFD算法的思想是從邊入手，每次考慮以某個邊作為中轉路徑，是否能夠縮短兩點的距離，最多經過（n-1）調邊中轉。

Floyd 多源最短路徑算法

Folyd算法的核心就是對于任意兩點之間的距離，選擇一個中間頂點過度，看是否能夠縮短距離。實際代碼執行是按照，選擇一個頂點作為中間點，更新所有能夠通過此中間點而縮短距離的頂點間距離。畫個圖試驗一下就知道算法的正確定。算法的復雜度未o(N3),三層循環。

最大流

網絡圖中從源點到目標點的最大流量。這個問題可以轉化為最小割最大流，就是將網絡圖中所有頂點分為兩個集合一個集合包含起點，一個包含源點，然后計算這兩個集合間的最大流。所有割中最小的最大流就是網絡中的最大流。
實際計算最大流的方法有增廣路徑法，就是找出從起點到目標點的路徑，并且計算這個路徑的最大流，然后將所有路徑中的所有邊減去這個最大流，同時增加一個反向流。路徑的尋找可以用DFS或者BFS算法，直到找不到路徑為止。邊的容量為0表示邊不通。

字符串算法

BF 暴力匹配算法

就是最簡單的暴力匹配，算法復雜度O（mn）,是大部分標準庫的算法，因為一般字符串比較小，這個算法簡單可靠。

RK 哈希匹配

計算字符串的哈希值進行匹配,對于哈希值的計算要有合理利用主串中的重復字符的哈希值。哈希算法的復雜度O(n);

BM算法

BM算法的核心就是倒著匹配字符串，當遇到不匹配的字符是，就直接移動字串直到子串中的字符與當前主串中字符匹配。

#include<string> #include<iostream>using namespace::std;int BM(string s, string p) {int pos = p.size() - 1;int sSize = s.size() - 1;int pSize = p.size() - 1;int cursor = 0;int bias = 0; //pos指針需要的偏移量while ((cursor <= pSize) && (pos <= sSize)){if (p[pSize - cursor] == s[pos - cursor]){cursor++;continue;}else{while ((pSize - cursor - bias) >= 0 &&(p[pSize - cursor -bias] != s[pos - cursor]))//壞字符{bias++;}pos = pos + bias; //主串偏移bias = 0;cursor = 0;}}if (cursor == (pSize+1)){return (pos - pSize );}return -1; }int main() {string s = "gg good boyoyagh g";string p = "boyoya";cout << BM(s, p) << endl; }

kmp算法

kmp算法的核心是next數組，每次遇到不匹配的字符的時候就去next數組找到當前主串中的字符應該匹配模式串中的位置。

next[B] = C 也就是說 next[5] = 2;
所以構建next函數是KMP算法的最核心。

vector<int> getNext(string sp) {vector<int> resNext;resNext.resize(sp.size());resNext[0] = -1;int j = 0; //遍歷給next數組賦值int k = -1;while (j < (sp.size()-1)){if ((k == -1) || sp[j] == sp[k]){j++;k++;resNext[j] = k; //如果是重復子串，這里面包含的意思就是sp[0] ...sp[k-1] == sp[t-k]...sp[t-1];}else{k = resNext[k];//如果不重復，就去next[k]中記錄的還是重復子串，直到k == -1;}}return std::move(resNext); }int KMP(string t, string p) {int posT = 0;int posP = 0;vector<int> next = getNext(p);int pSize = p.size();int tSize = t.size();while ((posP < pSize) && (posT < tSize)){if (p[posP] == t[posT]){posP++;posT++;continue;}else if(posP >= 0){posP = next[posP];}if(posP == -1){posP = 0;posT++;continue;}}if (posP == p.size() ){return (posT - p.size()+1);}return -1; }

trie樹 （字典樹）

#include<string> #include<iostream> #include <vector> using namespace::std; struct trieTree {char value;trieTree* child;trieTree* next; };class trie { public:trieTree* tree = nullptr; public:trie() {};~trie(){deleteTrie(tree);};public:void insert(string s){int start = 0;if (s.size() == 0){return;}trieTree* t = this->tree;trieTree* tail = this->tree;trieTree* fathert = t;if (this->tree == nullptr)//第一次初始化{this->tree = new trieTree{ s[0],nullptr,nullptr };trieTree* temp = this->tree;for (int j = 1; j < s.size(); j++){temp->child = new trieTree{ s[j],nullptr,nullptr };temp = temp->child;}return ;}int sSize = s.size();for (int i = 0; i < sSize; i++){if (findCharInTheLevel(s[i], t, tail) != nullptr){fathert = t;t = fathert->child;continue;}else {tail->next = new trieTree{ s[i],nullptr,nullptr };trieTree* newTree = tail->next;for (int j = i + 1; j < sSize; j++) //后面的字符存儲都需要新的節點{newTree->child = new trieTree{ s[j],nullptr,nullptr };newTree = newTree->child;}return;}if (t == nullptr){for (int j = i + 1; j < sSize; j++){fathert->child = new trieTree{ s[j],nullptr,nullptr };//后面的字符存儲都需要新的節點fathert = fathert;}return;}}}bool findSameString(string s){trieTree* node = this->tree;for (auto ch : s){trieTree* temp = node;node = findCharInTheLevel(ch, node, temp);if (node == nullptr){return false;}else{node = node->child;}}if(node == nullptr)return true;return false;} private:void deleteTrie(trieTree* tree){if (tree != nullptr){deleteTrie(tree->next);deleteTrie(tree->child);delete tree;}};trieTree* findCharInTheLevel(char ch, trieTree* tree,trieTree* &tail ){trieTree* res = nullptr;tail = tree;while (tree != nullptr){if (tree->value == ch){res = tree;return res;}tail = tree;tree = tree->next;}return res;} };int main() {trie tr;tr.insert("iost");tr.insert("immt");tr.insert("momot");cout << tr.findSameString("imm") << endl; }

排序算法

插入排序和希爾排序

插入排序就是一個一個將后面的元素插入到目標位置，這個算法要大量移動元素，算法效率極低。希爾排序是在插入排序的改進，插入排序可以理解為間隔1個元素，而希爾元素一開始選擇間隔較大的序列，讓這一組序列有序，逐漸縮小間隔，直到間隔為1。

//希爾排序//希爾排序的本質是通過構建子序列 利用插入排序,讓子序列有序,然后逐漸縮小子序列的數目//希爾排序的優點在于能夠將靠后的較小數據盡快移動到前面，在較少的移動次數情況下void shellSort(vector<int>& vecInt){int gap = vecInt.size() / 2;while (gap > 0){for (int i = 0; i<gap; i++){for (int j = i; j < vecInt.size(); j += gap){int index = j;while (true){if (index < gap) break;else if (XLessY(vecInt[index], vecInt[index - gap])){int temp = vecInt[index];vecInt[index] = vecInt[index - gap];vecInt[index - gap] = temp;index-= gap;}else{break;}}}}gap /= 2;//增量減小}}

冒泡排序和歸并排序

冒泡排序就是調整兩個相連元素的位置，對整個數組遍歷兩遍。
歸并排序是數組不斷一分為2，對兩個子數組繼續一分為2，直到只有兩個元素的時候，對其排序，然后有序合并子數組。歸并排序空間復雜度為o(n);個人覺得歸并算法的性能最好。

//歸并排序，是冒泡排序的改進，先將整個列表不斷劃分到2個元素的子列表，然后對子列表排序合并void mergeSort(vector<int>& nums, int i, int j){if (j <= i){return;}if ((j - i) == 1){if (XLessY(nums[j], nums[i])){int temp = nums[i];nums[i] = nums[j];nums[j] = temp;return;}}else{//歸并排序mergeSort(nums, i, (i + j) / 2);mergeSort(nums, (i + j) / 2 + 1,j);merge(nums, i, (i + j) / 2, (i + j) / 2 + 1, j);}}void merge(vector<int>& nums, int i, int j, int m, int k){//用臨時空間排序int start = i;vector<int> temp;while ((i <= j) || (m <= k)){if ((i <= j) & ( ((m > k) ||(XLessY(nums[i],nums[m]))) )){temp.push_back(nums[i]);i++;}else if (m <= k) {temp.push_back(nums[m]);m++;}}//歸并for (auto num : temp){nums[start] = num;start++;}}

選擇排序和快速排序

選擇排序是每次從未排序數據中選擇一個最小的到排序的隊尾。快速排序是利用一個軸，將數據分為小于軸的和大與軸的。這個算法的技巧在于如何將數據正確的移動到軸的左右兩側，可以先獲取軸的值，然后將軸移動到最后的位置，然后從頭遍歷軸，將小于軸的元素交換到軸的前面，然后再與軸做一次交換。

//快速排序；應該算是選擇排序的改進，每次選擇一個基準，然后將小于基準的數據分到數字前面，//大于基準的分到后面，遞歸void quickSort(vector<int>& nums,int i,int j){if (j <= i){return;}//將軸移動到一端int kivot = (i + j) / 2;int temp = nums[kivot];nums[kivot] = nums[j];nums[j] = temp;kivot = j;for (int m = i; m < kivot; m++){if (XLessY(nums[kivot] ,nums[m])){//將m和軸前面一個元素交換int temp = nums[kivot - 1];nums[kivot - 1] = nums[m];nums[m] = temp;//將m和軸交換int temp2 = nums[kivot - 1];nums[kivot - 1] = nums[kivot];nums[kivot] = temp2;//重新調整游標kivot--;m--;}}quickSort(nums, i, kivot - 1);quickSort(nums, kivot+1,j);}

堆排序

利用到完全二叉樹的特點，子節點是父節點的2i+ 1 和 2 i+2;堆排序需要分為兩個步驟，第一個步驟構建一個大頂堆，第二個步驟將大頂堆的第一個元素（最大元素）放到堆中最后位置，堆大小減一，并且重新對堆排序。

//堆排序void adjustHeap(vector<int>& nums, int i, int j){for (int k = 2 * i + 1; k < j; k = 2 * k + 1)//一擼到底的檢查{if ((k + 1) < j) {if (XLessY(nums[k], nums[k + 1])){k++;}}if (XLessY(nums[i], nums[k])) //交換父子節點{int temp2 = nums[i];nums[i] = nums[k];nums[k] = temp2;i = k;}else{break;}}}void heapSort(vector<int>& nums){//對堆排序構建一個有序堆//從第一個非葉子結點從下至上，從右至左調整結構for (int i = (nums.size())/2 - 1; i >= 0; i--){adjustHeap(nums, i, nums.size());}//2.調整堆結構+交換堆頂元素與末尾元素for (int j = nums.size() - 1; j > 0; j--){int temp = nums[0];nums[0] = nums[j];nums[j] = temp;adjustHeap(nums, 0, j);}}

總結

以上是生活随笔為你收集整理的数据结构与算法 总结的全部內容，希望文章能夠幫你解決所遇到的問題。

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