數據結構（棧--兩個隊列實現）

原創 nigulasi_dawei 2020-02-22 22:08


       當看到用兩個棧實現隊列以後，大家有沒有興趣用兩個隊列實現一個棧呢，呵呵！現在就來介紹用兩個隊列實現一個棧。

      

       如圖

這裏介紹隊列的常用操作：

l 創建棧

l 銷燬棧

l 清空棧

l 壓棧

l 出棧

l 返回棧頂元素

l 返回棧的大小

代碼總分爲三個文件：

QStack.h ： 放置功能函數的聲明，以及表的聲明 

QStack.c ： 放置功能函數的定義，以及表的定義

Main.c   ： 主函數，使用功能函數完成各種需求，一般用作測試

整體結構圖爲：

 

這裏詳細說下壓棧操作，出棧操作和返回棧頂元素操作：

 

壓棧操作：

[cpp] view plain copy


  1. int QStack_Push(QStack* stack, void* item)  
  2. {  
  3.     TQStack* aStack = (TQStack*)stack;  
  4.       
  5.     int ret = (NULL!=aStack) && (NULL!=item);  
  6.       
  7.     if(ret)  
  8.     {  
  9.         if(0 == LinkQueue_Length(aStack->queue_A))  
  10.         {  
  11.             ret = LinkQueue_Append(aStack->queue_B, item);     
  12.         }  
  13.         else  
  14.         {  
  15.             ret = LinkQueue_Append(aStack->queue_A, item);  
  16.         }  
  17.           
  18.     }  
  19.       
  20.     return ret;  
  21. }  


如圖：

  

出棧操作：

[cpp] view plain copy


  1. void* QStack_Pop(QStack* stack)  
  2. {  
  3.     TQStack* aStack = (TQStack*)stack;  
  4.       
  5.     void* ret = NULL;  
  6.       
  7.     if((NULL!=aStack) && (0<QStack_Length(aStack)))  
  8.     {  
  9.         if(0 == LinkQueue_Length(aStack->queue_B))  
  10.         {  
  11.             while(LinkQueue_Length(aStack->queue_A) > 1)  
  12.             {  
  13.                 LinkQueue_Append(aStack->queue_B, LinkQueue_Retrieve(aStack->queue_A));  
  14.             }  
  15.               
  16.             ret = LinkQueue_Retrieve(aStack->queue_A);  
  17.         }  
  18.         else   
  19.         {  
  20.             while(LinkQueue_Length(aStack->queue_B) > 1)  
  21.             {  
  22.                 LinkQueue_Append(aStack->queue_A, LinkQueue_Retrieve(aStack->queue_B));  
  23.             }  
  24.               
  25.             ret = LinkQueue_Retrieve(aStack->queue_B);  
  26.         }  
  27.     }  
  28.       
  29.     return ret;  
  30. }  


如圖：

返回棧頂元素：

[cpp] view plain copy


  1. void* QStack_Top(QStack* stack)  
  2. {  
  3.     TQStack* aStack = (TQStack*)stack;  
  4.       
  5.     void* ret = NULL;  
  6.       
  7.     if((NULL!=aStack) && (0<QStack_Length(stack)))  
  8.     {  
  9.         if(0 == LinkQueue_Length(aStack->queue_B))  
  10.         {  
  11.             while(LinkQueue_Length(aStack->queue_A) > 1)  
  12.             {  
  13.                 LinkQueue_Append(aStack->queue_B, LinkQueue_Retrieve(aStack->queue_A));  
  14.             }  
  15.               
  16.             ret = LinkQueue_Header(aStack->queue_A);  
  17.             LinkQueue_Append(aStack->queue_B, LinkQueue_Retrieve(aStack->queue_A));  
  18.         }  
  19.         else  
  20.         {  
  21.             while(LinkQueue_Length(aStack->queue_B) > 1)  
  22.             {  
  23.                 LinkQueue_Append(aStack->queue_A, LinkQueue_Retrieve(aStack->queue_B));  
  24.             }  
  25.               
  26.             ret = LinkQueue_Header(aStack->queue_B);  
  27.             LinkQueue_Append(aStack->queue_A, LinkQueue_Retrieve(aStack->queue_B));  
  28.         }  
  29.     }  
  30.       
  31.     return ret;  
  32. }  


如圖：

            

OK! 上代碼：

QStack.h ： 

[cpp] view plain copy


  1. #ifndef _QSTACK_H_  
  2. #define _QSTACK_H_  
  3.   
  4. typedef void QStack;  
  5.   
  6. QStack* QStack_Create();  
  7.   
  8. void QStack_Destroy(QStack* stack);  
  9.   
  10. void QStack_Clear(QStack* stack);  
  11.   
  12. int QStack_Push(QStack* stack, void* item);  
  13.   
  14. void* QStack_Pop(QStack* stack);  
  15.   
  16. void* QStack_Top(QStack* stack);  
  17.   
  18. int QStack_Length(QStack* stack);  
  19.   
  20. #endif  


 

QStack.c ：

 

[cpp] view plain copy


  1. #include <malloc.h>  
  2. #include “LinkQueue.h”  
  3. #include “QStack.h”  
  4.   
  5. typedef struct _tag_QStack  
  6. {  
  7.     LinkQueue* queue_A;  
  8.     LinkQueue* queue_B;  
  9. }TQStack;  
  10.   
  11. QStack* QStack_Create()  
  12. {  
  13.     TQStack* ret = (TQStack*)malloc(sizeof(TQStack));  
  14.       
  15.     if(NULL != ret)  
  16.     {  
  17.         ret->queue_A = LinkQueue_Create();  
  18.         ret->queue_B = LinkQueue_Create();  
  19.           
  20.         if((NULL==ret->queue_A) || (NULL==ret->queue_B))  
  21.         {  
  22.             LinkQueue_Destroy(ret->queue_A);  
  23.             LinkQueue_Destroy(ret->queue_B);  
  24.               
  25.             free(ret);  
  26.             ret = NULL;  
  27.         }  
  28.     }  
  29.       
  30.     return ret;  
  31. }  
  32.   
  33. void QStack_Destroy(QStack* stack)  
  34. {  
  35.     QStack_Clear(stack);  
  36.       
  37.     free(stack);      
  38. }  
  39.   
  40. void QStack_Clear(QStack* stack)  
  41. {  
  42.     while(QStack_Length(stack) > 0)  
  43.     {  
  44.         QStack_Pop(stack);  
  45.     }  
  46. }  
  47.   
  48. int QStack_Push(QStack* stack, void* item)  
  49. {  
  50.     TQStack* aStack = (TQStack*)stack;  
  51.       
  52.     int ret = (NULL!=aStack) && (NULL!=item);  
  53.       
  54.     if(ret)  
  55.     {  
  56.         if(0 == LinkQueue_Length(aStack->queue_A))  
  57.         {  
  58.             ret = LinkQueue_Append(aStack->queue_B, item);     
  59.         }  
  60.         else  
  61.         {  
  62.             ret = LinkQueue_Append(aStack->queue_A, item);  
  63.         }  
  64.           
  65.     }  
  66.       
  67.     return ret;  
  68. }  
  69.   
  70. void* QStack_Pop(QStack* stack)  
  71. {  
  72.     TQStack* aStack = (TQStack*)stack;  
  73.       
  74.     void* ret = NULL;  
  75.       
  76.     if((NULL!=aStack) && (0<QStack_Length(aStack)))  
  77.     {  
  78.         if(0 == LinkQueue_Length(aStack->queue_B))  
  79.         {  
  80.             while(LinkQueue_Length(aStack->queue_A) > 1)  
  81.             {  
  82.                 LinkQueue_Append(aStack->queue_B, LinkQueue_Retrieve(aStack->queue_A));  
  83.             }  
  84.               
  85.             ret = LinkQueue_Retrieve(aStack->queue_A);  
  86.         }  
  87.         else   
  88.         {  
  89.             while(LinkQueue_Length(aStack->queue_B) > 1)  
  90.             {  
  91.                 LinkQueue_Append(aStack->queue_A, LinkQueue_Retrieve(aStack->queue_B));  
  92.             }  
  93.               
  94.             ret = LinkQueue_Retrieve(aStack->queue_B);  
  95.         }  
  96.     }  
  97.       
  98.     return ret;  
  99. }  
  100.   
  101. void* QStack_Top(QStack* stack)  
  102. {  
  103.     TQStack* aStack = (TQStack*)stack;  
  104.       
  105.     void* ret = NULL;  
  106.       
  107.     if((NULL!=aStack) && (0<QStack_Length(stack)))  
  108.     {  
  109.         if(0 == LinkQueue_Length(aStack->queue_B))  
  110.         {  
  111.             while(LinkQueue_Length(aStack->queue_A) > 1)  
  112.             {  
  113.                 LinkQueue_Append(aStack->queue_B, LinkQueue_Retrieve(aStack->queue_A));  
  114.             }  
  115.               
  116.             ret = LinkQueue_Header(aStack->queue_A);  
  117.             LinkQueue_Append(aStack->queue_B, LinkQueue_Retrieve(aStack->queue_A));  
  118.         }  
  119.         else  
  120.         {  
  121.             while(LinkQueue_Length(aStack->queue_B) > 1)  
  122.             {  
  123.                 LinkQueue_Append(aStack->queue_A, LinkQueue_Retrieve(aStack->queue_B));  
  124.             }  
  125.               
  126.             ret = LinkQueue_Header(aStack->queue_B);  
  127.             LinkQueue_Append(aStack->queue_A, LinkQueue_Retrieve(aStack->queue_B));  
  128.         }  
  129.     }  
  130.       
  131.     return ret;  
  132. }  
  133.   
  134. int QStack_Length(QStack* stack)  
  135. {  
  136.     TQStack* aStack = (TQStack*)stack;  
  137.       
  138.     int ret = -1;  
  139.       
  140.     if(NULL != aStack)  
  141.     {  
  142.         ret = LinkQueue_Length(aStack->queue_B) +  
  143.               LinkQueue_Length(aStack->queue_A);  
  144.     }  
  145.       
  146.     return ret;  
  147. }  


 

Main.c     ：

            

[cpp] view plain copy


  1. #include <stdio.h>  
  2. #include “QStack.h”  
  3.   
  4. int main(void)  
  5. {  
  6.     QStack* stack = QStack_Create();  
  7.       
  8.     int a[10];  
  9.     int i = 0;  
  10.   
  11.     for(i=0; i<10; i++)  
  12.     {  
  13.         a[i] = i;  
  14.           
  15.         QStack_Push(stack, a+i);  
  16.     }  
  17.       
  18.     printf(”Header:   %d\n”, *(int*)QStack_Top(stack));  
  19.     printf(”Length:   %d\n\n”, QStack_Length(stack));  
  20.       
  21.     while(QStack_Length(stack) > 0)  
  22.     {  
  23.         printf(”Pop:  %d\n”, *(int*)QStack_Pop(stack));  
  24.     }  
  25.     printf(”\n”);  
  26.       
  27.     for(i=0; i<6; i++)  
  28.     {  
  29.         a[i] = i+10;  
  30.           
  31.         QStack_Push(stack, a+i);  
  32.     }  
  33.       
  34.     while(QStack_Length(stack) > 0)  
  35.     {  
  36.         printf(”Pop:  %d\n”, *(int*)QStack_Pop(stack));  
  37.     }  
  38.       
  39.     QStack_Destroy(stack);  
  40.       
  41.     return 0;  
  42. }  

       當看到用兩個棧實現隊列以後，大家有沒有興趣用兩個隊列實現一個棧呢，呵呵！現在就來介紹用兩個隊列實現一個棧。

      

       如圖

這裏介紹隊列的常用操作：

l 創建棧

l 銷燬棧

l 清空棧

l 壓棧

l 出棧

l 返回棧頂元素

l 返回棧的大小

代碼總分爲三個文件：

QStack.h ： 放置功能函數的聲明，以及表的聲明 

QStack.c ： 放置功能函數的定義，以及表的定義

Main.c   ： 主函數，使用功能函數完成各種需求，一般用作測試

整體結構圖爲：

 

這裏詳細說下壓棧操作，出棧操作和返回棧頂元素操作：

 

壓棧操作：

[cpp] view plain copy


  1. int QStack_Push(QStack* stack, void* item)  
  2. {  
  3.     TQStack* aStack = (TQStack*)stack;  
  4.       
  5.     int ret = (NULL!=aStack) && (NULL!=item);  
  6.       
  7.     if(ret)  
  8.     {  
  9.         if(0 == LinkQueue_Length(aStack->queue_A))  
  10.         {  
  11.             ret = LinkQueue_Append(aStack->queue_B, item);     
  12.         }  
  13.         else  
  14.         {  
  15.             ret = LinkQueue_Append(aStack->queue_A, item);  
  16.         }  
  17.           
  18.     }  
  19.       
  20.     return ret;  
  21. }  


如圖：

  

出棧操作：

[cpp] view plain copy


  1. void* QStack_Pop(QStack* stack)  
  2. {  
  3.     TQStack* aStack = (TQStack*)stack;  
  4.       
  5.     void* ret = NULL;  
  6.       
  7.     if((NULL!=aStack) && (0<QStack_Length(aStack)))  
  8.     {  
  9.         if(0 == LinkQueue_Length(aStack->queue_B))  
  10.         {  
  11.             while(LinkQueue_Length(aStack->queue_A) > 1)  
  12.             {  
  13.                 LinkQueue_Append(aStack->queue_B, LinkQueue_Retrieve(aStack->queue_A));  
  14.             }  
  15.               
  16.             ret = LinkQueue_Retrieve(aStack->queue_A);  
  17.         }  
  18.         else   
  19.         {  
  20.             while(LinkQueue_Length(aStack->queue_B) > 1)  
  21.             {  
  22.                 LinkQueue_Append(aStack->queue_A, LinkQueue_Retrieve(aStack->queue_B));  
  23.             }  
  24.               
  25.             ret = LinkQueue_Retrieve(aStack->queue_B);  
  26.         }  
  27.     }  
  28.       
  29.     return ret;  
  30. }  


如圖：

返回棧頂元素：

[cpp] view plain copy


  1. void* QStack_Top(QStack* stack)  
  2. {  
  3.     TQStack* aStack = (TQStack*)stack;  
  4.       
  5.     void* ret = NULL;  
  6.       
  7.     if((NULL!=aStack) && (0<QStack_Length(stack)))  
  8.     {  
  9.         if(0 == LinkQueue_Length(aStack->queue_B))  
  10.         {  
  11.             while(LinkQueue_Length(aStack->queue_A) > 1)  
  12.             {  
  13.                 LinkQueue_Append(aStack->queue_B, LinkQueue_Retrieve(aStack->queue_A));  
  14.             }  
  15.               
  16.             ret = LinkQueue_Header(aStack->queue_A);  
  17.             LinkQueue_Append(aStack->queue_B, LinkQueue_Retrieve(aStack->queue_A));  
  18.         }  
  19.         else  
  20.         {  
  21.             while(LinkQueue_Length(aStack->queue_B) > 1)  
  22.             {  
  23.                 LinkQueue_Append(aStack->queue_A, LinkQueue_Retrieve(aStack->queue_B));  
  24.             }  
  25.               
  26.             ret = LinkQueue_Header(aStack->queue_B);  
  27.             LinkQueue_Append(aStack->queue_A, LinkQueue_Retrieve(aStack->queue_B));  
  28.         }  
  29.     }  
  30.       
  31.     return ret;  
  32. }  


如圖：

            

OK! 上代碼：

QStack.h ： 

[cpp] view plain copy


  1. #ifndef _QSTACK_H_  
  2. #define _QSTACK_H_  
  3.   
  4. typedef void QStack;  
  5.   
  6. QStack* QStack_Create();  
  7.   
  8. void QStack_Destroy(QStack* stack);  
  9.   
  10. void QStack_Clear(QStack* stack);  
  11.   
  12. int QStack_Push(QStack* stack, void* item);  
  13.   
  14. void* QStack_Pop(QStack* stack);  
  15.   
  16. void* QStack_Top(QStack* stack);  
  17.   
  18. int QStack_Length(QStack* stack);  
  19.   
  20. #endif  


 

QStack.c ：

 

[cpp] view plain copy


  1. #include <malloc.h>  
  2. #include “LinkQueue.h”  
  3. #include “QStack.h”  
  4.   
  5. typedef struct _tag_QStack  
  6. {  
  7.     LinkQueue* queue_A;  
  8.     LinkQueue* queue_B;  
  9. }TQStack;  
  10.   
  11. QStack* QStack_Create()  
  12. {  
  13.     TQStack* ret = (TQStack*)malloc(sizeof(TQStack));  
  14.       
  15.     if(NULL != ret)  
  16.     {  
  17.         ret->queue_A = LinkQueue_Create();  
  18.         ret->queue_B = LinkQueue_Create();  
  19.           
  20.         if((NULL==ret->queue_A) || (NULL==ret->queue_B))  
  21.         {  
  22.             LinkQueue_Destroy(ret->queue_A);  
  23.             LinkQueue_Destroy(ret->queue_B);  
  24.               
  25.             free(ret);  
  26.             ret = NULL;  
  27.         }  
  28.     }  
  29.       
  30.     return ret;  
  31. }  
  32.   
  33. void QStack_Destroy(QStack* stack)  
  34. {  
  35.     QStack_Clear(stack);  
  36.       
  37.     free(stack);      
  38. }  
  39.   
  40. void QStack_Clear(QStack* stack)  
  41. {  
  42.     while(QStack_Length(stack) > 0)  
  43.     {  
  44.         QStack_Pop(stack);  
  45.     }  
  46. }  
  47.   
  48. int QStack_Push(QStack* stack, void* item)  
  49. {  
  50.     TQStack* aStack = (TQStack*)stack;  
  51.       
  52.     int ret = (NULL!=aStack) && (NULL!=item);  
  53.       
  54.     if(ret)  
  55.     {  
  56.         if(0 == LinkQueue_Length(aStack->queue_A))  
  57.         {  
  58.             ret = LinkQueue_Append(aStack->queue_B, item);     
  59.         }  
  60.         else  
  61.         {  
  62.             ret = LinkQueue_Append(aStack->queue_A, item);  
  63.         }  
  64.           
  65.     }  
  66.       
  67.     return ret;  
  68. }  
  69.   
  70. void* QStack_Pop(QStack* stack)  
  71. {  
  72.     TQStack* aStack = (TQStack*)stack;  
  73.       
  74.     void* ret = NULL;  
  75.       
  76.     if((NULL!=aStack) && (0<QStack_Length(aStack)))  
  77.     {  
  78.         if(0 == LinkQueue_Length(aStack->queue_B))  
  79.         {  
  80.             while(LinkQueue_Length(aStack->queue_A) > 1)  
  81.             {  
  82.                 LinkQueue_Append(aStack->queue_B, LinkQueue_Retrieve(aStack->queue_A));  
  83.             }  
  84.               
  85.             ret = LinkQueue_Retrieve(aStack->queue_A);  
  86.         }  
  87.         else   
  88.         {  
  89.             while(LinkQueue_Length(aStack->queue_B) > 1)  
  90.             {  
  91.                 LinkQueue_Append(aStack->queue_A, LinkQueue_Retrieve(aStack->queue_B));  
  92.             }  
  93.               
  94.             ret = LinkQueue_Retrieve(aStack->queue_B);  
  95.         }  
  96.     }  
  97.       
  98.     return ret;  
  99. }  
  100.   
  101. void* QStack_Top(QStack* stack)  
  102. {  
  103.     TQStack* aStack = (TQStack*)stack;  
  104.       
  105.     void* ret = NULL;  
  106.       
  107.     if((NULL!=aStack) && (0<QStack_Length(stack)))  
  108.     {  
  109.         if(0 == LinkQueue_Length(aStack->queue_B))  
  110.         {  
  111.             while(LinkQueue_Length(aStack->queue_A) > 1)  
  112.             {  
  113.                 LinkQueue_Append(aStack->queue_B, LinkQueue_Retrieve(aStack->queue_A));  
  114.             }  
  115.               
  116.             ret = LinkQueue_Header(aStack->queue_A);  
  117.             LinkQueue_Append(aStack->queue_B, LinkQueue_Retrieve(aStack->queue_A));  
  118.         }  
  119.         else  
  120.         {  
  121.             while(LinkQueue_Length(aStack->queue_B) > 1)  
  122.             {  
  123.                 LinkQueue_Append(aStack->queue_A, LinkQueue_Retrieve(aStack->queue_B));  
  124.             }  
  125.               
  126.             ret = LinkQueue_Header(aStack->queue_B);  
  127.             LinkQueue_Append(aStack->queue_A, LinkQueue_Retrieve(aStack->queue_B));  
  128.         }  
  129.     }  
  130.       
  131.     return ret;  
  132. }  
  133.   
  134. int QStack_Length(QStack* stack)  
  135. {  
  136.     TQStack* aStack = (TQStack*)stack;  
  137.       
  138.     int ret = -1;  
  139.       
  140.     if(NULL != aStack)  
  141.     {  
  142.         ret = LinkQueue_Length(aStack->queue_B) +  
  143.               LinkQueue_Length(aStack->queue_A);  
  144.     }  
  145.       
  146.     return ret;  
  147. }  


 

Main.c     ：

            

[cpp] view plain copy


  1. #include <stdio.h>  
  2. #include “QStack.h”  
  3.   
  4. int main(void)  
  5. {  
  6.     QStack* stack = QStack_Create();  
  7.       
  8.     int a[10];  
  9.     int i = 0;  
  10.   
  11.     for(i=0; i<10; i++)  
  12.     {  
  13.         a[i] = i;  
  14.           
  15.         QStack_Push(stack, a+i);  
  16.     }  
  17.       
  18.     printf(”Header:   %d\n”, *(int*)QStack_Top(stack));  
  19.     printf(”Length:   %d\n\n”, QStack_Length(stack));  
  20.       
  21.     while(QStack_Length(stack) > 0)  
  22.     {  
  23.         printf(”Pop:  %d\n”, *(int*)QStack_Pop(stack));  
  24.     }  
  25.     printf(”\n”);  
  26.       
  27.     for(i=0; i<6; i++)  
  28.     {  
  29.         a[i] = i+10;  
  30.           
  31.         QStack_Push(stack, a+i);  
  32.     }  
  33.       
  34.     while(QStack_Length(stack) > 0)  
  35.     {  
  36.         printf(”Pop:  %d\n”, *(int*)QStack_Pop(stack));  
  37.     }  
  38.       
  39.     QStack_Destroy(stack);  
  40.       
  41.     return 0;  
  42. }  

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

這可能是最簡單的AVL二叉平衡查找樹講解

二叉平衡查找樹AVL詳解 看懂這篇文章所需的知識點 樹、二叉搜索樹、樹高、樹深、層等概念 AVL樹 概念：任意節點的左右子樹的高度差不能大於1的樹即爲AVL樹，是爲了解決在頻繁插入刪除等動態更新下出現的時間複雜度退化的問題，所以平

AD钙12138 2020-07-08 11:54:55

基本數據結構——線性結構（棧）

1.什麼是線性結構 線性結構是一種有序數據項的集合，其中每個數據項都有唯一的前驅和後繼（除了第一個沒有前驅，最後一個沒有後繼）。新的數據項加入到數據集中時，只會加入到原有某個數據項之前或之後。具有這種性質的數據集，就稱爲線性結構。

weixin_38324954 2020-07-08 11:06:52

震驚！Redis 的字符串居然是這樣實現的…

雲棲號資訊：【點擊查看更多行業資訊】在這裏您可以找到不同行業的第一手的上雲資訊，還在等什麼，快來！ 之前本人在找工作面試時在Redis相關問題上可栽了跟頭。在面試前按常規套路準備了一下，比如 Redis 的常用5種數據結構，Redis持久化

雲棲號資訊小哥 2020-08-06 12:10:50

數據結構：AVL樹旋轉原理和簡易實現

AVL樹旋轉原理和簡易實現 二叉搜索樹雖然可以提高搜索效率，但是如果插入的數據有序時很有可能變成單支，如果變成單支樹的時候，那麼查找時效率也不高了。因此引入AVL樹。 AVL樹是當向這棵樹插入節點的時候，要保證每個節點的左右子樹的

ETalien_ 2020-07-08 12:19:01

數據結構：紅黑樹的旋轉原理和模擬實現

紅黑樹的旋轉原理和模擬實現 我們瞭解到AVL樹雖然效率很高，但是它是通過多次的旋轉纔到達一個絕對的平衡，旋轉的消耗其實也很大。因此開始引入近似平衡的一棵樹----紅黑樹（RBTree）。紅黑樹每一個節點不是紅色的就是黑色的，它保證

ETalien_ 2020-07-08 12:19:01

數據結構：大數據處理問題

1.給定100億個整數，設計算法找到只出現一次的整數？ ①方法一 100億個整數就是400億個字節，42億九千萬是4G，那麼1G就是10億字節，所以要存下100億個整數需要40G的內存空間。因此我們採用位圖100億個整數大概就是1

ETalien_ 2020-07-08 12:19:01

數據結構：布隆過濾器

布隆過濾器 假如現在有40億個ip地址（string類型），然後給你一個ip地址，讓你查找這個ip地址在不在這40億個ip地址裏？我們應該怎麼做呢？ 如果用哈希表來處理的話，這裏有40億的數據，數據量太大，因此太佔用空間 如果用

ETalien_ 2020-07-08 12:19:01

樹上剖分

————————————————18.4.18更新有時我們會遇到這樣的問題：在一棵樹上，每次詢問兩點間路徑上的和或者是最值。但我們用搜索時，時間就會到O（n），這樣根本就完不成算法。但樹上剖分就可以縮短修改的時間。樹上剖分的算法簡介我們定

蒟蒻午时已到 2020-07-08 11:59:23

2.7 封裝Request

  request作爲前後臺交換的橋樑，有重要作用。  request常用的方法有讀參數：public String getParameter(String paramName);讀取屬性public Object getAttribut

lws0888 2020-07-08 11:48:30

樹的總結（二）---非空二叉樹的高度和寬度

1.非空二叉樹的高度      1.1非遞歸算法實現求解非空二叉樹的高度  算法思想：採用層次遍歷的算法，設置變量level記錄當前結點所在的層數，設置變量last指向當前層的最右的結點，每次層次遍歷出隊的時候與last指針比較（fron

瞿颖Blog 2020-07-08 11:41:54

樹的總結（一）

考研加油！！！！！！！ 1.1樹的重要概念 1.樹是一種重要的非線性結構；在有n個結點的樹中有n-1條邊； 2.在結點個數爲n(n>1)的各棵樹中，深度最小的樹的深度是多少？它有多少葉子結點？多少分支結點？深度最大的樹的深度是多少？它有多

瞿颖Blog 2020-07-08 11:41:54

【劍指offer】題61：二叉樹序列化、反序列化

使用stringstream http://blog.csdn.net/xw20084898/article/details/21939811 stringstream 是 C++ 提供的另一個字串型的串流(stream)

xiaxzhou 2020-07-08 11:22:52

Trie 前綴樹/字典樹

一、Trie的介紹：     1、主要應用場景：搜索引擎的自動補全功能：Trie樹+詞頻(概率)權重因子                                    IP路由：最長前綴匹配，Trie路由算法          

放羊的大飞 2020-07-08 10:58:58

數據結構——數組（3） 在有序數組中找出重複的次數最多的數

先總結有序數組，無序的後面再總結。。 1.以空間換時間法。 算法思想：目標數組array[length]，是一個有序數組，比如int array[]={1,1,2,2,4,4,4,4,4,5,5,6,10};總共有13個元素，

zhangying_496 2020-07-08 10:38:18

數據結構——數組（1）數組求和&打印二維數組&判斷數組是否遞增

數組求和 方法一：直接一次for循環 int GetSum1(int *a,int n) { int sum=0; for (int i=0; i<n;i++) { sum+=a[i];

zhangying_496 2020-07-08 10:38:18