伸展樹(一)之圖文解析和 C語言的實現

出自：http://www.cnblogs.com/skywang12345/p/3604238.html

概要

本章介紹伸展樹。它和"二叉查找樹"和"AVL樹"一樣，都是特殊的二叉樹。在瞭解了"二叉查找樹"和"AVL樹"之後，學習伸展樹是一件相當容易的事情。和以往一樣，本文會先對伸展樹的理論知識進行簡單介紹，然後給出C語言的實現。後序再分別給出C++和Java版本的實現；這3種實現方式的原理都一樣，選擇其中之一進行了解即可。若文章有錯誤或不足的地方，希望您能不吝指出！

目錄
1. 伸展樹的介紹
2. 伸展樹的C實現
3. 伸展樹的C測試程序

轉載請註明出處：http://www.cnblogs.com/skywang12345/p/3604238.html

更多內容: 數據結構與算法系列目錄

(01) 伸展樹(一)之圖文解析和 C語言的實現
(02) 伸展樹(二)之 C++的實現
(03) 伸展樹(三)之 Java的實現

伸展樹的介紹

伸展樹(Splay Tree)是一種二叉排序樹，它能在O(log n)內完成插入、查找和刪除操作。它由Daniel Sleator和Robert Tarjan創造。
(01) 伸展樹屬於二叉查找樹，即它具有和二叉查找樹一樣的性質：假設x爲樹中的任意一個結點，x節點包含關鍵字key，節點x的key值記爲key[x]。如果y是x的左子樹中的一個結點，則key[y] <= key[x]；如果y是x的右子樹的一個結點，則key[y] >= key[x]。
(02) 除了擁有二叉查找樹的性質之外，伸展樹還具有的一個特點是：當某個節點被訪問時，伸展樹會通過旋轉使該節點成爲樹根。這樣做的好處是，下次要訪問該節點時，能夠迅速的訪問到該節點。

假設想要對一個二叉查找樹執行一系列的查找操作。爲了使整個查找時間更小，被查頻率高的那些條目就應當經常處於靠近樹根的位置。於是想到設計一個簡單方法，在每次查找之後對樹進行重構，把被查找的條目搬移到離樹根近一些的地方。伸展樹應運而生，它是一種自調整形式的二叉查找樹，它會沿着從某個節點到樹根之間的路徑，通過一系列的旋轉把這個節點搬移到樹根去。

相比於"二叉查找樹"和"AVL樹"，學習伸展樹時需要重點關注是"伸展樹的旋轉算法"。

伸展樹的C實現

1. 節點定義

typedef int Type;

typedef struct SplayTreeNode {
    Type key;                        // 關鍵字(鍵值)
    struct SplayTreeNode *left;        // 左孩子
    struct SplayTreeNode *right;    // 右孩子
} Node, *SplayTree;

伸展樹的節點包括的幾個組成元素:
(01) key -- 是關鍵字，是用來對伸展樹的節點進行排序的。
(02) left -- 是左孩子。
(03) right -- 是右孩子。

外部接口

// 前序遍歷"伸展樹"
void preorder_splaytree(SplayTree tree);
// 中序遍歷"伸展樹"
void inorder_splaytree(SplayTree tree);
// 後序遍歷"伸展樹"
void postorder_splaytree(SplayTree tree);

// (遞歸實現)查找"伸展樹x"中鍵值爲key的節點
Node* splaytree_search(SplayTree x, Type key);
// (非遞歸實現)查找"伸展樹x"中鍵值爲key的節點
Node* iterative_splaytree_search(SplayTree x, Type key);

// 查找最小結點：返回tree爲根結點的伸展樹的最小結點。
Node* splaytree_minimum(SplayTree tree);
// 查找最大結點：返回tree爲根結點的伸展樹的最大結點。
Node* splaytree_maximum(SplayTree tree);

// 旋轉key對應的節點爲根節點。
Node* splaytree_splay(SplayTree tree, Type key);

// 將結點插入到伸展樹中，並返回根節點
Node* insert_splaytree(SplayTree tree, Type key);

// 刪除結點(key爲節點的值)，並返回根節點
Node* delete_splaytree(SplayTree tree, Type key);

// 銷燬伸展樹
void destroy_splaytree(SplayTree tree);

// 打印伸展樹
void print_splaytree(SplayTree tree, Type key, int direction);

2. 旋轉

旋轉的代碼

/* 
 * 旋轉key對應的節點爲根節點，並返回根節點。
 *
 * 注意：
 *   (a)：伸展樹中存在"鍵值爲key的節點"。
 *          將"鍵值爲key的節點"旋轉爲根節點。
 *   (b)：伸展樹中不存在"鍵值爲key的節點"，並且key < tree->key。
 *      b-1 "鍵值爲key的節點"的前驅節點存在的話，將"鍵值爲key的節點"的前驅節點旋轉爲根節點。
 *      b-2 "鍵值爲key的節點"的前驅節點存在的話，則意味着，key比樹中任何鍵值都小，那麼此時，將最小節點旋轉爲根節點。
 *   (c)：伸展樹中不存在"鍵值爲key的節點"，並且key > tree->key。
 *      c-1 "鍵值爲key的節點"的後繼節點存在的話，將"鍵值爲key的節點"的後繼節點旋轉爲根節點。
 *      c-2 "鍵值爲key的節點"的後繼節點不存在的話，則意味着，key比樹中任何鍵值都大，那麼此時，將最大節點旋轉爲根節點。
 */
Node* splaytree_splay(SplayTree tree, Type key)
{
    Node N, *l, *r, *c;

    if (tree == NULL) 
        return tree;

    N.left = N.right = NULL;
    l = r = &N;

    for (;;)
    {
        if (key < tree->key)
        {
            if (tree->left == NULL)
                break;
            if (key < tree->left->key)
            {
                c = tree->left;                           /* 01, rotate right */
                tree->left = c->right;
                c->right = tree;
                tree = c;
                if (tree->left == NULL) 
                    break;
            }
            r->left = tree;                               /* 02, link right */
            r = tree;
            tree = tree->left;
        }
        else if (key > tree->key)
        {
            if (tree->right == NULL) 
                break;
            if (key > tree->right->key) 
            {
                c = tree->right;                          /* 03, rotate left */
                tree->right = c->left;
                c->left = tree;
                tree = c;
                if (tree->right == NULL) 
                    break;
            }
            l->right = tree;                              /* 04, link left */
            l = tree;
            tree = tree->right;
        }
        else
        {
            break;
        }
    }

    l->right = tree->left;                                /* 05, assemble */
    r->left = tree->right;
    tree->left = N.right;
    tree->right = N.left;

    return tree;
}

上面的代碼的作用：將"鍵值爲key的節點"旋轉爲根節點，並返回根節點。它的處理情況共包括：
(a)：伸展樹中存在"鍵值爲key的節點"。
將"鍵值爲key的節點"旋轉爲根節點。
(b)：伸展樹中不存在"鍵值爲key的節點"，並且key < tree->key。
b-1) "鍵值爲key的節點"的前驅節點存在的話，將"鍵值爲key的節點"的前驅節點旋轉爲根節點。
b-2) "鍵值爲key的節點"的前驅節點存在的話，則意味着，key比樹中任何鍵值都小，那麼此時，將最小節點旋轉爲根節點。
(c)：伸展樹中不存在"鍵值爲key的節點"，並且key > tree->key。
c-1) "鍵值爲key的節點"的後繼節點存在的話，將"鍵值爲key的節點"的後繼節點旋轉爲根節點。
c-2) "鍵值爲key的節點"的後繼節點不存在的話，則意味着，key比樹中任何鍵值都大，那麼此時，將最大節點旋轉爲根節點。

下面列舉個例子分別對a進行說明。

在下面的伸展樹中查找10，共包括"右旋" --> "右鏈接" --> "組合"這3步。

第一步：右旋
對應代碼中的"rotate right"部分

第二步：右鏈接
對應代碼中的"link right"部分

第三步：組合
對應代碼中的"assemble"部分

提示：如果在上面的伸展樹中查找"70"，則正好與"示例1"對稱，而對應的操作則分別是"rotate left", "link left"和"assemble"。
其它的情況，例如"查找15是b-1的情況，查找5是b-2的情況"等等，這些都比較簡單，大家可以自己分析。

3. 插入

/* 
 * 將結點插入到伸展樹中(不旋轉)
 *
 * 參數說明：
 *     tree 伸展樹的根結點
 *     z 插入的結點
 * 返回值：
 *     根節點
 */
static Node* splaytree_insert(SplayTree tree, Node *z)
{
    Node *y = NULL;
    Node *x = tree;

    // 查找z的插入位置
    while (x != NULL)
    {
        y = x;
        if (z->key < x->key)
            x = x->left;
        else if (z->key > x->key)
            x = x->right;
        else
        {
            printf("不允許插入相同節點(%d)!\n", z->key);
            // 釋放申請的節點，並返回tree。
            free(z);
            return tree;
        }
    }

    if (y==NULL)
        tree = z;
    else if (z->key < y->key)
        y->left = z;
    else
        y->right = z;

    return tree;
}

/*
 * 創建並返回伸展樹結點。
 *
 * 參數說明：
 *     key 是鍵值。
 *     parent 是父結點。
 *     left 是左孩子。
 *     right 是右孩子。
 */
static Node* create_splaytree_node(Type key, Node *left, Node* right)
{
    Node* p;

    if ((p = (Node *)malloc(sizeof(Node))) == NULL)
        return NULL;
    p->key = key;
    p->left = left;
    p->right = right;

    return p;
}

/* 
 * 新建結點(key)，然後將其插入到伸展樹中，並將插入節點旋轉爲根節點
 *
 * 參數說明：
 *     tree 伸展樹的根結點
 *     key 插入結點的鍵值
 * 返回值：
 *     根節點
 */
Node* insert_splaytree(SplayTree tree, Type key)
{
    Node *z;    // 新建結點

    // 如果新建結點失敗，則返回。
    if ((z=create_splaytree_node(key, NULL, NULL)) == NULL)
        return tree;

    // 插入節點
    tree = splaytree_insert(tree, z);
    // 將節點(key)旋轉爲根節點
    tree = splaytree_splay(tree, key);
}

外部接口: insert_splaytree(tree, key)是提供給外部的接口，它的作用是新建節點(節點的鍵值爲key)，並將節點插入到伸展樹中；然後，將該節點旋轉爲根節點。

內部接口: splaytree_insert(tree, z)是內部接口，它的作用是將節點z插入到tree中。splaytree_insert(tree, z)在將z插入到tree中時，僅僅只將tree當作是一棵二叉查找樹，而且不允許插入相同節點。

4. 刪除

刪除接口

/* 
 * 刪除結點(key爲節點的鍵值)，並返回根節點。
 *
 * 參數說明：
 *     tree 伸展樹的根結點
 *     z 刪除的結點
 * 返回值：
 *     根節點(根節點是被刪除節點的前驅節點)
 *
 */
Node* delete_splaytree(SplayTree tree, Type key)
{
    Node *x;

    if (tree == NULL) 
        return NULL;

    // 查找鍵值爲key的節點，找不到的話直接返回。
    if (splaytree_search(tree, key) == NULL)
        return tree;

    // 將key對應的節點旋轉爲根節點。
    tree = splaytree_splay(tree, key);

    if (tree->left != NULL)
    {
        // 將"tree的前驅節點"旋轉爲根節點
        x = splaytree_splay(tree->left, key);
        // 移除tree節點
        x->right = tree->right;
    }
    else
        x = tree->right;

    free(tree);

    return x;
}

delete_splaytree(tree, key)的作用是：刪除伸展樹中鍵值爲key的節點。
它會先在伸展樹中查找鍵值爲key的節點。若沒有找到的話，則直接返回。若找到的話，則將該節點旋轉爲根節點，然後再刪除該節點。

注意：關於伸展樹的"前序遍歷"、"中序遍歷"、"後序遍歷"、"最大值"、"最小值"、"查找"、"打印"、"銷燬"等接口與"二叉查找樹"基本一樣，這些操作在"二叉查找樹"中已經介紹過了，這裏就不再單獨介紹了。當然，後文給出的伸展樹的完整源碼中，有給出這些API的實現代碼。這些接口很簡單，Please RTFSC(Read The Fucking Source Code)！

伸展樹的C實現(完整源碼)

伸展樹的頭文件(splay_tree.h)

#ifndef _SPLAY_TREE_H_
#define _SPLAY_TREE_H_

typedef int Type;

typedef struct SplayTreeNode {
   Type key;                        // 關鍵字(鍵值)
   struct SplayTreeNode *left;        // 左孩子
   struct SplayTreeNode *right;    // 右孩子
} Node, *SplayTree; 

// 前序遍歷"伸展樹"
void preorder_splaytree(SplayTree tree);
// 中序遍歷"伸展樹"
void inorder_splaytree(SplayTree tree);
// 後序遍歷"伸展樹"
void postorder_splaytree(SplayTree tree);

// (遞歸實現)查找"伸展樹x"中鍵值爲key的節點
Node* splaytree_search(SplayTree x, Type key);
// (非遞歸實現)查找"伸展樹x"中鍵值爲key的節點
Node* iterative_splaytree_search(SplayTree x, Type key);

// 查找最小結點：返回tree爲根結點的伸展樹的最小結點。
Node* splaytree_minimum(SplayTree tree);
// 查找最大結點：返回tree爲根結點的伸展樹的最大結點。
Node* splaytree_maximum(SplayTree tree);

// 旋轉key對應的節點爲根節點。
Node* splaytree_splay(SplayTree tree, Type key);

// 將結點插入到伸展樹中，並返回根節點
Node* insert_splaytree(SplayTree tree, Type key);

// 刪除結點(key爲節點的值)，並返回根節點
Node* delete_splaytree(SplayTree tree, Type key);

// 銷燬伸展樹
void destroy_splaytree(SplayTree tree);

// 打印伸展樹
void print_splaytree(SplayTree tree, Type key, int direction);

#endif

伸展樹的實現文件(splay_tree.c)

/**
* SplayTree伸展樹(C語言): C語言實現的伸展樹。
*
* @author skywang
* @date 2014/02/03
*/

#include <stdio.h>
#include <stdlib.h>
#include "splay_tree.h"

/*
* 前序遍歷"伸展樹"
*/
void preorder_splaytree(SplayTree tree)
{
   if(tree != NULL)
   {
       printf("%d ", tree->key);
       preorder_splaytree(tree->left);
       preorder_splaytree(tree->right);
   }
}

/*
* 中序遍歷"伸展樹"
*/
void inorder_splaytree(SplayTree tree)
{
   if(tree != NULL)
   {
       inorder_splaytree(tree->left);
       printf("%d ", tree->key);
       inorder_splaytree(tree->right);
   }
}

/*
* 後序遍歷"伸展樹"
*/
void postorder_splaytree(SplayTree tree)
{
   if(tree != NULL)
   {
       postorder_splaytree(tree->left);
       postorder_splaytree(tree->right);
       printf("%d ", tree->key);
   }
}

/*
* (遞歸實現)查找"伸展樹x"中鍵值爲key的節點
*/
Node* splaytree_search(SplayTree x, Type key)
{
   if (x==NULL || x->key==key)
       return x;

   if (key < x->key)
       return splaytree_search(x->left, key);
   else
       return splaytree_search(x->right, key);
}

/*
* (非遞歸實現)查找"伸展樹x"中鍵值爲key的節點
*/
Node* iterative_splaytree_search(SplayTree x, Type key)
{
   while ((x!=NULL) && (x->key!=key))
   {
       if (key < x->key)
           x = x->left;
       else
           x = x->right;
   }

   return x;
}

/* 
* 查找最小結點：返回tree爲根結點的伸展樹的最小結點。
*/
Node* splaytree_minimum(SplayTree tree)
{
   if (tree == NULL)
       return NULL;

   while(tree->left != NULL)
       tree = tree->left;
   return tree;
}

/* 
* 查找最大結點：返回tree爲根結點的伸展樹的最大結點。
*/
Node* splaytree_maximum(SplayTree tree)
{
   if (tree == NULL)
       return NULL;

   while(tree->right != NULL)
       tree = tree->right;
   return tree;
}

/* 
* 旋轉key對應的節點爲根節點，並返回根節點。
*
* 注意：
*   (a)：伸展樹中存在"鍵值爲key的節點"。
*          將"鍵值爲key的節點"旋轉爲根節點。
*   (b)：伸展樹中不存在"鍵值爲key的節點"，並且key < tree->key。
*      b-1 "鍵值爲key的節點"的前驅節點存在的話，將"鍵值爲key的節點"的前驅節點旋轉爲根節點。
*      b-2 "鍵值爲key的節點"的前驅節點存在的話，則意味着，key比樹中任何鍵值都小，那麼此時，將最小節點旋轉爲根節點。
*   (c)：伸展樹中不存在"鍵值爲key的節點"，並且key > tree->key。
*      c-1 "鍵值爲key的節點"的後繼節點存在的話，將"鍵值爲key的節點"的後繼節點旋轉爲根節點。
*      c-2 "鍵值爲key的節點"的後繼節點不存在的話，則意味着，key比樹中任何鍵值都大，那麼此時，將最大節點旋轉爲根節點。
*/
Node* splaytree_splay(SplayTree tree, Type key)
{
   Node N, *l, *r, *c;

   if (tree == NULL) 
       return tree;

   N.left = N.right = NULL;
   l = r = &N;

   for (;;)
   {
       if (key < tree->key)
       {
           if (tree->left == NULL)
               break;
           if (key < tree->left->key)
           {
               c = tree->left;                           /* 01, rotate right */
               tree->left = c->right;
               c->right = tree;
               tree = c;
               if (tree->left == NULL) 
                   break;
           }
           r->left = tree;                               /* 02, link right */
           r = tree;
           tree = tree->left;
       }
       else if (key > tree->key)
       {
           if (tree->right == NULL) 
               break;
           if (key > tree->right->key) 
           {
               c = tree->right;                          /* 03, rotate left */
               tree->right = c->left;
               c->left = tree;
               tree = c;
               if (tree->right == NULL) 
                   break;
           }
           l->right = tree;                              /* 04, link left */
           l = tree;
           tree = tree->right;
       }
       else
       {
           break;
       }
   }

   l->right = tree->left;                                /* 05, assemble */
   r->left = tree->right;
   tree->left = N.right;
   tree->right = N.left;

   return tree;
}

/* 
* 將結點插入到伸展樹中(不旋轉)
*
* 參數說明：
*     tree 伸展樹的根結點
*     z 插入的結點
* 返回值：
*     根節點
*/
static Node* splaytree_insert(SplayTree tree, Node *z)
{
   Node *y = NULL;
   Node *x = tree;

   // 查找z的插入位置
   while (x != NULL)
   {
       y = x;
       if (z->key < x->key)
           x = x->left;
       else if (z->key > x->key)
           x = x->right;
       else
       {
           printf("不允許插入相同節點(%d)!\n", z->key);
           // 釋放申請的節點，並返回tree。
           free(z);
           return tree;
       }
   }

   if (y==NULL)
       tree = z;
   else if (z->key < y->key)
       y->left = z;
   else
       y->right = z;

   return tree;
}

/*
* 創建並返回伸展樹結點。
*
* 參數說明：
*     key 是鍵值。
*     parent 是父結點。
*     left 是左孩子。
*     right 是右孩子。
*/
static Node* create_splaytree_node(Type key, Node *left, Node* right)
{
   Node* p;

   if ((p = (Node *)malloc(sizeof(Node))) == NULL)
       return NULL;
   p->key = key;
   p->left = left;
   p->right = right;

   return p;
}

/* 
* 新建結點(key)，然後將其插入到伸展樹中，並將插入節點旋轉爲根節點
*
* 參數說明：
*     tree 伸展樹的根結點
*     key 插入結點的鍵值
* 返回值：
*     根節點
*/
Node* insert_splaytree(SplayTree tree, Type key)
{
   Node *z;    // 新建結點

   // 如果新建結點失敗，則返回。
   if ((z=create_splaytree_node(key, NULL, NULL)) == NULL)
       return tree;

   // 插入節點
   tree = splaytree_insert(tree, z);
   // 將節點(key)旋轉爲根節點
   tree = splaytree_splay(tree, key);
}

/* 
* 刪除結點(key爲節點的鍵值)，並返回根節點。
*
* 參數說明：
*     tree 伸展樹的根結點
*     z 刪除的結點
* 返回值：
*     根節點(根節點是被刪除節點的前驅節點)
*
*/
Node* delete_splaytree(SplayTree tree, Type key)
{
   Node *x;

   if (tree == NULL) 
       return NULL;

   // 查找鍵值爲key的節點，找不到的話直接返回。
   if (splaytree_search(tree, key) == NULL)
       return tree;

   // 將key對應的節點旋轉爲根節點。
   tree = splaytree_splay(tree, key);

   if (tree->left != NULL)
   {
       // 將"tree的前驅節點"旋轉爲根節點
       x = splaytree_splay(tree->left, key);
       // 移除tree節點
       x->right = tree->right;
   }
   else
       x = tree->right;

   free(tree);

   return x;
}

/*
* 銷燬伸展樹
*/
void destroy_splaytree(SplayTree tree)
{
   if (tree==NULL)
       return ;

   if (tree->left != NULL)
       destroy_splaytree(tree->left);
   if (tree->right != NULL)
       destroy_splaytree(tree->right);

   free(tree);
}

/*
* 打印"伸展樹"
*
* tree       -- 伸展樹的節點
* key        -- 節點的鍵值 
* direction  --  0，表示該節點是根節點;
*               -1，表示該節點是它的父結點的左孩子;
*                1，表示該節點是它的父結點的右孩子。
*/
void print_splaytree(SplayTree tree, Type key, int direction)
{
   if(tree != NULL)
   {
       if(direction==0)    // tree是根節點
           printf("%2d is root\n", tree->key);
       else                // tree是分支節點
           printf("%2d is %2d's %6s child\n", tree->key, key, direction==1?"right" : "left");

       print_splaytree(tree->left, tree->key, -1);
       print_splaytree(tree->right,tree->key,  1);
   }
}

伸展樹的測試程序(splaytree_test.c)

/**
* C 語言: 伸展樹測試程序
*
* @author skywang
* @date 2014/02/03
*/

#include <stdio.h>
#include "splay_tree.h"

static int arr[]= {10,50,40,30,20,60};
#define TBL_SIZE(a) ( (sizeof(a)) / (sizeof(a[0])) )

void main()
{
   int i, ilen;
   SplayTree root=NULL;

   printf("== 依次添加: ");
   ilen = TBL_SIZE(arr);
   for(i=0; i<ilen; i++)
   {
       printf("%d ", arr[i]);
       root = insert_splaytree(root, arr[i]);
   }

   printf("\n== 前序遍歷: ");
   preorder_splaytree(root);

   printf("\n== 中序遍歷: ");
   inorder_splaytree(root);

   printf("\n== 後序遍歷: ");
   postorder_splaytree(root);
   printf("\n");

   printf("== 最小值: %d\n", splaytree_minimum(root)->key);
   printf("== 最大值: %d\n", splaytree_maximum(root)->key);
   printf("== 樹的詳細信息: \n");
   print_splaytree(root, root->key, 0);

   i = 30;
   printf("\n== 旋轉節點(%d)爲根節點\n", i);
   printf("== 樹的詳細信息: \n");
   root = splaytree_splay(root, i);
   print_splaytree(root, root->key, 0);

   // 銷燬伸展樹
   destroy_splaytree(root);
}

伸展樹的C測試程序

伸展樹的測試程序運行結果如下：

== 依次添加: 10 50 40 30 20 60 
== 前序遍歷: 60 30 20 10 50 40 
== 中序遍歷: 10 20 30 40 50 60 
== 後序遍歷: 10 20 40 50 30 60 
== 最小值: 10
== 最大值: 60
== 樹的詳細信息: 
60 is root
30 is 60's   left child
20 is 30's   left child
10 is 20's   left child
50 is 30's  right child
40 is 50's   left child

== 旋轉節點(30)爲根節點
== 樹的詳細信息: 
30 is root
20 is 30's   left child
10 is 20's   left child
60 is 30's  right child
50 is 60's   left child
40 is 50's   left child

測試程序的主要流程是：新建伸展樹，然後向伸展樹中依次插入10,50,40,30,20,60。插入完畢這些數據之後，伸展樹的節點是60；此時，再旋轉節點，使得30成爲根節點。
依次插入10,50,40,30,20,60示意圖如下：

將30旋轉爲根節點的示意圖如下：

xiedeacc

發佈了26 篇原創文章 · 獲贊 79 · 訪問量 9萬+

私信關注

伸展樹(一)之圖文解析和 C語言的實現

概要

伸展樹的介紹

伸展樹的C實現

伸展樹的C實現(完整源碼)

伸展樹的C測試程序

再談23種設計模式（3）：行爲型模式（學習筆記）

Power Automate Desktop 安裝完，登錄後老是提示one driver 錯誤

微前端學習筆記(4):從微前端到微模塊之EMP與hel-micro方案探索

微前端學習筆記（1）：微前端總體架構概述，從微服務發微

985 碩士程序員，空窗 4 個月沒有 Offer！

一文搞懂 Spring 循環依賴

賽博鬥地主——使用大語言模型扮演Agent智能體玩牌類遊戲。

VScode右鍵打開(添加到右鍵)

記一次 .NET某工控視覺自動化系統卡死分析

WindowsServer--SQL Server搭建主從同步實現讀寫分離 - 事務性分發

位運算二進制大雜燴一勞永逸

最短路徑算法——Dijkstra,Bellman-Ford,Floyd-Warshall,Johnson，無一倖免

棧的圖文解析和對應3種語言的實現(C/C++/Java)

有向強連通和網絡流大講堂——史無前例最大流（最小割）、最小費用最大流

二叉堆(一)之圖文解析和 C語言的實現

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

伸展樹(一)之 圖文解析 和 C語言的實現

概要

伸展樹的介紹

伸展樹的C實現

伸展樹的C實現(完整源碼)

伸展樹的C測試程序

伸展樹(一)之圖文解析和 C語言的實現