所以我们需要的那个数据可能出现在数组的各个

作者: 编程  发布:2019-08-29

 

 

转载自:

【 声明:版权所有,欢迎转载,请勿用于商业用途。  联系信箱:feixiaoxing @163.com】

【 声明:版权所有,欢迎转载,请勿用于商业用途。  联系信箱:feixiaoxing @163.com】

【 声明:版权所有,欢迎转载,请勿用于商业用途。  联系信箱:feixiaoxing @163.com】

 

 

 

 

【 声明:版权所有,欢迎转载,请勿用于商业用途。  联系信箱:feixiaoxing @163.com】

    其实编程的朋友知道,不管学什么语言,循环和递归是两个必须学习的内容。当然,如果循环还好理解一点,那么递归却没有那么简单。我们曾经对递归讳莫如深,但是我想告诉大家的是,递归其实没有那么可怕。所谓的递归就是函数自己调用自己而已,循环本质上也是一种递归。

 

 

    hash表,有时候也被称为散列表。个人认为,hash表是介于链表和二叉树之间的一种中间结构。链表使用十分方便,但是数据查找十分麻烦;二叉树中的 数据严格有序,但是这是以多一个指针作为代价的结果。hash表既满足了数据的查找方便,同时不占用太多的内容空间,使用也十分方便。

    1)求和递归函数

 

 

    打个比方来说,所有的数据就好像许许多多的书本。如果这些书本是一本一本堆起来的,就好像链表或者线性表一样,整个数据会显得非常的无序和凌乱,在你找 到自己需要的书之前,你要经历许多的查询过程;而如果你对所有的书本进行编号,并且把这些书本按次序进行排列的话,那么如果你要寻找的书本编号是n,那么 经过二分查找,你很快就会找到自己需要的书本;但是如果你每一个种类的书本都不是很多,那么你就可以对这些书本进行归类,哪些是文学类,哪些是艺术类,哪 些是工科的,哪些是理科的,你只要对这些书本进行简单的归类,那么寻找一本书也会变得非常简单,比如说如果你要找的书是计算机方面的书,那么你就会到工科 一类当中去寻找,这样查找起来也会显得麻烦。

    我们可以举一个循环的例子,前面我们说过,如果编写一个1到n的求和函数怎么写呢,你可能会这么写:

 

 

    不知道这样举例你清楚了没有,上面提到的归类方法其实就是hash表的本质。下面我们可以写一个简单的hash操作代码。

int calculate(int m) 

    int count = 0; 
    if(m <0) 
        return -1; 
 
    for(int index = 0; index <= m; index ) 
        count = index; 
     
    return count; 

int calculate(int m)
{
 int count = 0;
 if(m <0)
  return -1;

    无论是数据库,还是普通的ERP系统,查找功能数据处理的一个基本功能。数据查找并不复杂,但是如何实现数据又快又好地查找呢?前人在实践中积累的一些方法,值得我们好好学些一下。我们假定查找的数据唯一存在,数组中没有重复的数据存在。

    前面的博客我们介绍了单向链表。那么我们今天介绍的双向链表,顾名思义,就是数据本身具备了左边和右边的双向指针。双向链表相比较单向链表,主要有下面几个特点:

    a)定义hash表和基本数据节点

 for(int index = 0; index <= m; index )
  count = index;
 
 return count;
}    上面只是一个示范。下面我们看看如果是递归应该怎么写呢?

 

 

[cpp] view plaincopy

int calculate(int m) 

    if(m == 0) 
        return 0; 
    else 
        return calculate(m -1) m; 

int calculate(int m)
{
 if(m == 0)
  return 0;
 else
  return calculate(m -1) m;
}    大家看着两段代码有什么不同?

    (1) 普通的数据查找

    (1)在数据结构中具有双向指针

  1. typedef struct _NODE  
  2. {  
  3.     int data;  
  4.     struct _NODE* next;  
  5. }NODE;  
  6.   
  7. typedef struct _HASH_TABLE  
  8. {  
  9.     NODE* value[10];  
  10. }HASH_TABLE;  

    (1)第一段代码从0,开始计算,从0到m逐步计算;第二段代码是从10开始计算,逐步到0之后这回,这样同样可以达到计算的效果

 

 

    b)创建hash表

    (2)第一段代码不需要重复的压栈操作,第二段需要重复的函数操作,当然这也是递归的本质

    设想有一个1M的数据,我们如何在里面找到我们想要的那个数据。此时数据本身没有特征,所以我们需要的那个数据可能出现在数组的各个位置,可能在数据的开头位置,也可能在数据的结束位置。这种性质要求我们必须对数据进行遍历之后才能获取到对应的数据。

    (2)插入数据的时候需要考虑前后的方向的操作

[cpp] view plaincopy

    (3)第一段代码比较长,第二段代码较短

 

 

  1. HASH_TABLE* create_hash_table()  
  2. {  
  3.     HASH_TABLE* pHashTbl = (HASH_TABLE*)malloc(sizeof(HASH_TABLE));  
  4.     memset(pHashTbl, 0, sizeof(HASH_TABLE));  
  5.     return pHashTbl;  
  6. }  

 

 

    (3)同样,删除数据的是有也需要考虑前后方向的操作

    c)在hash表当中寻找数据

    2)查找递归函数

view plaincopy to clipboardprint?int find(int array[], int  length, int value) 

 

[cpp] view plaincopy

    大家可能说,这些代码有些特殊。如果是查找类的函数,有没有可能修改成递归函数呢?

    那么,一个非循环的双向链表操作应该是怎么样的呢?我们可以自己尝试一下:

  1. NODE* find_data_in_hash(HASH_TABLE* pHashTbl, int data)  
  2. {  
  3.     NODE* pNode;  
  4.     if(NULL ==  pHashTbl)  
  5.         return NULL;  
  6.   
  7.     if(NULL == (pNode = pHashTbl->value[data % 10]))  
  8.         return NULL;  
  9.   
  10.     while(pNode){  
  11.         if(data == pNode->data)  
  12.             return pNode;  
  13.         pNode = pNode->next;  
  14.     }  
  15.     return NULL;  
  16. }  

int find(int array[], int length, int value) 

    int index = 0; 
    if(NULL == array || 0 == length) 
        return -1; 
 
    for(; index < length; index ) 
    { 
        if(value == array[index]) 
            return index; 
    } 
 
    return -1; 

int find(int array[], int length, int value)
{
 int index = 0;
 if(NULL == array || 0 == length)
  return -1;

    if(NULL == array || 0 == length) 

 

    d)在hash表当中插入数据

 for(; index < length; index )
 {
  if(value == array[index])
   return index;
 }

        return -1; 

    (1)定义双向链表的基本结构

[cpp] view plaincopy

 return -1;
}

 

 

  1. STATUS insert_data_into_hash(HASH_TABLE* pHashTbl, int data)  
  2. {  
  3.     NODE* pNode;  
  4.     if(NULL == pHashTbl)  
  5.         return FALSE;  
  6.   
  7.     if(NULL == pHashTbl->value[data % 10]){  
  8.         pNode = (NODE*)malloc(sizeof(NODE));  
  9.         memset(pNode, 0, sizeof(NODE));  
  10.         pNode->data = data;  
  11.         pHashTbl->value[data % 10] = pNode;  
  12.         return TRUE;  
  13.     }  
  14.   
  15.     if(NULL != find_data_in_hash(pHashTbl, data))  
  16.         return FALSE;  
  17.   
  18.     pNode = pHashTbl->value[data % 10];  
  19.     while(NULL != pNode->next)  
  20.         pNode = pNode->next;  
  21.   
  22.     pNode->next = (NODE*)malloc(sizeof(NODE));  
  23.     memset(pNode->next, 0, sizeof(NODE));  
  24.     pNode->next->data = data;  
  25.     return TRUE;  
  26. }  

    大家可能说,这样的代码可能修改成这样的代码:

    for(int index = 0; index < length; index ){ 

 

    e)从hash表中删除数据

int _find(int index, int array[], int length, int value) 

    if(index == length) 
        return -1; 
 
    if(value == array[index]) 
        return index; 
 
    return _find(index 1,  array, length, value); 

 
int find(int array[], int length, int value) 

    if(NULL == array || length == 0) 
        return -1; 
 
    return _find(0, array, length, value); 

int _find(int index, int array[], int length, int value)
{
 if(index == length)
  return -1;

        if(value == array[index]) 

typedef struct _DOUBLE_LINK_NODE 

[cpp] view plaincopy

 if(value == array[index])
  return index;

            return index; 

  1. STATUS delete_data_from_hash(HASH_TABLE* pHashTbl, int data)  
  2. {  
  3.     NODE* pHead;  
  4. 9159.com,    NODE* pNode;  
  5.     if(NULL == pHashTbl || NULL == pHashTbl->value[data % 10])  
  6.         return FALSE;  
  7.   
  8.     if(NULL == (pNode = find_data_in_hash(pHashTbl, data)))  
  9.         return FALSE;  
  10.   
  11.     if(pNode == pHashTbl->value[data % 10]){  
  12.         pHashTbl->value[data % 10] = pNode->next;  
  13.         goto final;  
  14.     }  
  15.   
  16.     pHead = pHashTbl->value[data % 10];  
  17.     while(pNode != pHead ->next)  
  18.         pHead = pHead->next;  
  19.     pHead->next = pNode->next;  
  20.   
  21. final:  
  22.     free(pNode);  
  23.     return TRUE;  
  24. }  

 return _find(index 1,  array, length, value);
}

        } 

    int data; 

总结:

int find(int array[], int length, int value)
{
 if(NULL == array || length == 0)
  return -1;

    return -1; 

    struct _DOUBLE_LINK_NODE* prev; 

    1、hash表不复杂,我们在开发中也经常使用,建议朋友们好好掌握;

 return _find(0, array, length, value);
}

    struct _DOUBLE_LINK_NODE* next; 

    2、hash表可以和二叉树形成复合结构,至于为什么,建议朋友们好好思考一下?

    3) 指针变量遍历

int find(int array[], int  length, int value)

}DOUBLE_LINK_NODE; 

    结构指针是我们喜欢的遍历结构,试想如果有下面定义的数据结构:

{

typedef struct _DOUBLE_LINK_NODE

typedef struct _NODE 

    int data; 
    struct _NODE* next; 
}NODE; 
typedef struct _NODE
{
 int data;
 struct _NODE* next;
}NODE;    那么,此时我们需要对一个节点链接中的所有数据进行打印,应该怎么办呢?大家可以自己先想想,然后看看我们写的代码对不对。

       if(NULL == array || 0 == length)

{

void print(const NODE* pNode) 

    if(NULL == pNode) 
        return; 
 
    while(pNode){ 
        printf("%dn", pNode->data); 
        pNode = pNode->next; 
    } 

void print(const NODE* pNode)
{
 if(NULL == pNode)
  return;

              return -1;

       int data;

 while(pNode){
  printf("%dn", pNode->data);
  pNode = pNode->next;
 }
}
    那么此时如果改成递归,那就更简单了:

 

       struct _DOUBLE_LINK_NODE* prev;

void print(const NODE* pNode) 

    if(NULL == pNode) 
        return; 
    else 
        printf("%dn", pNode->data); 
     
    print(pNode->next); 

void print(const NODE* pNode)
{
 if(NULL == pNode)
  return;
 else
     printf("%dn", pNode->data);
 
 print(pNode->next);
}
    其实,写这么多,就是想和大家分享一下我个人的观点:循环是一种特殊的递归,只有递归和堆栈是等价的。所有的递归代码都可以写成堆栈的形式,下面的一片博客我们就讨论一下堆栈和递归的关系。要想写好,必须熟练掌握堆栈。

       for(int index = 0; index < length; index ){

       struct _DOUBLE_LINK_NODE* next;

声明:版权所有,欢迎转载,请勿用于商业用途。 联系信箱:feixiaoxing @163.com】 其实编程的朋友知道,不管学什么语言,循环和递归是...

              if(value == array[index])

}DOUBLE_LINK_NODE;    (2)创建双向链表节点DOUBLE_LINK_NODE* create_double_link_node(int value) 

                     return index;

        }

    DOUBLE_LINK_NODE* pDLinkNode = NULL; 

       return -1;

    pDLinkNode = (DOUBLE_LINK_NODE*)malloc(sizeof(DOUBLE_LINK_NODE)); 

}分析:

    assert(NULL != pDLinkNode); 

 

 

    由于我们不清楚这个数据判断究竟需要多少次。但是,我们知道,这样一个数据查找最少需要1次,那么最多需要n次,平均下来可以看成是(1 n)/2,差不多是n的一半。我们把这种比较次数和n成正比的算法复杂度记为o(n)。

    memset(pDLinkNode, 0, sizeof(DOUBLE_LINK_NODE)); 

 

    pDLinkNode->data = value; 

    

    return pDLinkNode; 

 

    (2)上面的数据没有任何特征,这导致我们的数据排列地杂乱无章。试想一下,如果数据排列地非常整齐,那结果会是什么样的呢?就像在生活中,如果平时不注意收拾整齐,那么找东西的时候非常麻烦,效率很低;但是一旦东西放的位置固定下来,所有东西都归类放好,那么结果就不一样了,我们就会形成思维定势,这样查找东西的效率就会非常高。那么,对一个有序的数组,我们应该怎么查找呢?二分法就是最好的方法。

DOUBLE_LINK_NODE* create_double_link_node(int value)

 

{

 

       DOUBLE_LINK_NODE* pDLinkNode = NULL;

view plaincopy to clipboardprint?int binary_sort(int array[], int length, int value) 

       pDLinkNode = (DOUBLE_LINK_NODE*)malloc(sizeof(DOUBLE_LINK_NODE));

       assert(NULL != pDLinkNode);

    if(NULL == array || 0 == length) 

 

        return -1; 

       memset(pDLinkNode, 0, sizeof(DOUBLE_LINK_NODE));

 

       pDLinkNode->data = value;

    int start = 0; 

       return pDLinkNode;

    int end = length -1; 

}    (3)删除双向链表

 

 

    while(start <= end){ 

 

         

void delete_all_double_link_node(DOUBLE_LINK_NODE** pDLinkNode) 

        int middle = start ((end - start) >> 1); 

        if(value == array[middle]) 

    DOUBLE_LINK_NODE* pNode; 

            return middle; 

    if(NULL == *pDLinkNode) 

        else if(value > array[middle]){ 

        return ; 

            start = middle 1; 

 

        }else{ 

    pNode = *pDLinkNode; 

            end = middle -1; 

    *pDLinkNode = pNode->next; 

        } 

    free(pNode); 

    } 

    delete_all_double_link_node(pDLinkNode); 

 

    return -1; 

void delete_all_double_link_node(DOUBLE_LINK_NODE** pDLinkNode)

{

int binary_sort(int array[], int length, int value)

       DOUBLE_LINK_NODE* pNode;

{

       if(NULL == *pDLinkNode)

       if(NULL == array || 0 == length)

              return ;

              return -1;

 

 

       pNode = *pDLinkNode;

       int start = 0;

       *pDLinkNode = pNode->next;

       int end = length -1;

       free(pNode);

 

       delete_all_double_link_node(pDLinkNode);

       while(start <= end){

}

             

    (4)在双向链表中查找数据

              int middle = start ((end - start) >> 1);

 

              if(value == array[middle])

 

                     return middle;

DOUBLE_LINK_NODE* find_data_in_double_link(const DOUBLE_LINK_NODE* pDLinkNode, int data) 

              else if(value > array[middle]){

                     start = middle 1;

    DOUBLE_LINK_NODE* pNode = NULL; 

              }else{

    if(NULL == pDLinkNode) 

                     end = middle -1;

        return NULL; 

              }

 

       }

    pNode = (DOUBLE_LINK_NODE*)pDLinkNode; 

 

    while(NULL != pNode){ 

       return -1;

        if(data == pNode->data) 

}分析:

            return pNode; 

 

        pNode = pNode ->next; 

    上面我们说到普通的数据查找算法复杂度是o(n)。那么我们可以用上面一样的方法判断一下算法复杂度。这种方法最少是1次,那么最多需要多少次呢?我们发现最多需要log(n 1)/log(2)即可。大家可以找个例子自己算一下,比如说7个数据,我们发现最多3次;如果是15个数据呢,那么最多4次;以此类推,详细的论证方法可以在《算法导论》、《计算机编程艺术》中找到。明显,这种数据查找的效率要比前面的查找方法高很多。

    } 

 

     

 

    return NULL; 

 

 

DOUBLE_LINK_NODE* find_data_in_double_link(const DOUBLE_LINK_NODE* pDLinkNode, int data)

    (3) 上面的查找是建立在连续内存基础之上的,那么如果是指针类型的数据呢?怎么办呢?那么就需要引入排序二叉树了。排序二叉树的定义很简单:(1)非叶子节点至少一遍分支非NULL;(2)叶子节点左右分支都为NULL;(3)每一个节点记录一个数据,同时左分支的数据都小于右分支的数据。可以看看下面的定义:

{

 

       DOUBLE_LINK_NODE* pNode = NULL;

 

       if(NULL == pDLinkNode)

view plaincopy to clipboardprint?typedef struct _NODE 

              return NULL;

 

    int data; 

       pNode = (DOUBLE_LINK_NODE*)pDLinkNode;

    struct _NODE* left; 

       while(NULL != pNode){

    struct _NODE* right; 

              if(data == pNode->data)

}NODE; 

                     return pNode;

typedef struct _NODE

              pNode = pNode ->next;

{

       }

       int data;

      

       struct _NODE* left;

       return NULL;

       struct _NODE* right;

}    (5)双向链表中插入数据

}NODE;    那么查找呢,那就更简单了。

 

 

 

 

STATUS insert_data_into_double_link(DOUBLE_LINK_NODE** ppDLinkNode, int data) 

view plaincopy to clipboardprint?const NODE* find_data(const NODE* pNode, int data){ 

    if(NULL == pNode) 

    DOUBLE_LINK_NODE* pNode; 

        return NULL; 

    DOUBLE_LINK_NODE* pIndex; 

 

 

    if(data == pNode->data) 

    if(NULL == ppDLinkNode) 

        return pNode; 

        return FALSE; 

    else if(data < pNode->data) 

 

        return find_data(pNode->left, data); 

    if(NULL == *ppDLinkNode){ 

    else 

        pNode = create_double_link_node(data); 

        return find_data(pNode->right, data);         

        assert(NULL != pNode); 

        *ppDLinkNode = pNode; 

const NODE* find_data(const NODE* pNode, int data){

        (*ppDLinkNode)->prev = (*ppDLinkNode)->next = NULL; 

       if(NULL == pNode)

        return TRUE; 

              return NULL;

    } 

 

 

       if(data == pNode->data)

    if(NULL != find_data_in_double_link(*ppDLinkNode, data)) 

              return pNode;

        return FALSE; 

       else if(data < pNode->data)

 

              return find_data(pNode->left, data);

    pNode = create_double_link_node(data); 

       else

    assert(NULL != pNode); 

              return find_data(pNode->right, data);         

 

}

    pIndex = *ppDLinkNode; 

    (4)同样,我们看到(2)、(3)都是建立在完全排序的基础之上,那么有没有建立在折中基础之上的查找呢?有,那就是哈希表。哈希表的定义如下:1)每个数据按照某种聚类运算归到某一大类,然后所有数据链成一个链表;2)所有链表的头指针形成一个指针数组。这种方法因为不需要完整排序,所以在处理中等规模数据的时候很有效。其中节点的定义如下:

    while(NULL != pIndex->next) 

 

        pIndex = pIndex->next; 

 

 

view plaincopy to clipboardprint?typedef struct _LINK_NODE 

    pNode->prev = pIndex; 

    pNode->next = pIndex->next; 

    int data; 

    pIndex->next = pNode; 

    struct _LINK_NODE* next; 

    return TRUE; 

}LINK_NODE; 

typedef struct _LINK_NODE

STATUS insert_data_into_double_link(DOUBLE_LINK_NODE** ppDLinkNode, int data)

{

{

       int data;

       DOUBLE_LINK_NODE* pNode;

       struct _LINK_NODE* next;

       DOUBLE_LINK_NODE* pIndex;

}LINK_NODE;

 

 

       if(NULL == ppDLinkNode)

    那么hash表下面的数据怎么查找呢?

              return FALSE;

 

 

 

       if(NULL == *ppDLinkNode){

view plaincopy to clipboardprint?LINK_NODE* hash_find(LINK_NODE* array[], int mod, int data) 

              pNode = create_double_link_node(data);

           assert(NULL != pNode);

    int index = data % mod; 

              *ppDLinkNode = pNode;

    if(NULL == array[index]) 

              (*ppDLinkNode)->prev = (*ppDLinkNode)->next = NULL;

        return NULL; 

              return TRUE;

 

       }

    LINK_NODE* pLinkNode = array[index]; 

 

    while(pLinkNode){ 

       if(NULL != find_data_in_double_link(*ppDLinkNode, data))

        if(data == pLinkNode->data) 

              return FALSE;

            return pLinkNode; 

 

        pLinkNode = pLinkNode->next; 

       pNode = create_double_link_node(data);

    } 

       assert(NULL != pNode);

 

 

    return pLinkNode; 

       pIndex = *ppDLinkNode;

       while(NULL != pIndex->next)

LINK_NODE* hash_find(LINK_NODE* array[], int mod, int data)

              pIndex = pIndex->next;

{

 

       int index = data % mod;

       pNode->prev = pIndex;

       if(NULL == array[index])

       pNode->next = pIndex->next;

              return NULL;

       pIndex->next = pNode;

 

       return TRUE;

       LINK_NODE* pLinkNode = array[index];

}    (6)双向链表中删除数据

       while(pLinkNode){

 

              if(data == pLinkNode->data)

 

                     return pLinkNode;

STATUS delete_data_from_double_link(DOUBLE_LINK_NODE** ppDLinkNode, int data) 

              pLinkNode = pLinkNode->next;

       }

    DOUBLE_LINK_NODE* pNode; 

 

    if(NULL == ppDLinkNode || NULL == *ppDLinkNode) 

       return pLinkNode;

        return FALSE; 

}分析:

 

 

    pNode = find_data_in_double_link(*ppDLinkNode, data); 

 

    if(NULL == pNode) 

    hash表因为不需要排序,只进行简单的归类,在数据查找的时候特别方便。查找时间的大小取决于mod的大小。mod越小,那么hash查找就越接近于普通查找;那么hash越大呢,那么hash一次查找成功的概率就大大增加。

        return FALSE; 

 

 

 

    if(pNode == *ppDLinkNode){ 

 

        if(NULL == (*ppDLinkNode)->next){ 

【预告: 下一篇博客介绍排序的内容】

            *ppDLinkNode = NULL; 

声明:版权所有,欢迎转载,请勿用于商业用途。 联系信箱:feixiaoxing @163.com】 无论是数据库,还是普通的ERP系统,查找功能数据处理...

        }else{ 

            *ppDLinkNode = pNode->next; 

            (*ppDLinkNode)->prev = NULL; 

        } 

 

    }else{ 

        if(pNode->next) 

            pNode->next->prev = pNode->prev; 

        pNode->prev->next = pNode->next; 

    } 

 

    free(pNode); 

    return TRUE; 

STATUS delete_data_from_double_link(DOUBLE_LINK_NODE** ppDLinkNode, int data)

{

       DOUBLE_LINK_NODE* pNode;

       if(NULL == ppDLinkNode || NULL == *ppDLinkNode)

              return FALSE;

 

       pNode = find_data_in_double_link(*ppDLinkNode, data);

       if(NULL == pNode)

              return FALSE;

 

       if(pNode == *ppDLinkNode){

              if(NULL == (*ppDLinkNode)->next){

                     *ppDLinkNode = NULL;

              }else{

                     *ppDLinkNode = pNode->next;

                     (*ppDLinkNode)->prev = NULL;

              }

 

       }else{

              if(pNode->next)

                  pNode->next->prev = pNode->prev;

           pNode->prev->next = pNode->next;

       }

 

       free(pNode);

       return TRUE;

}    (7)统计双向链表中数据的个数

 

 

int count_number_in_double_link(const DOUBLE_LINK_NODE* pDLinkNode) 

    int count = 0; 

    DOUBLE_LINK_NODE* pNode = (DOUBLE_LINK_NODE*)pDLinkNode; 

 

    while(NULL != pNode){ 

        count ; 

        pNode = pNode->next; 

    } 

    return count; 

int count_number_in_double_link(const DOUBLE_LINK_NODE* pDLinkNode)

{

       int count = 0;

       DOUBLE_LINK_NODE* pNode = (DOUBLE_LINK_NODE*)pDLinkNode;

 

       while(NULL != pNode){

              count ;

              pNode = pNode->next;

       }

       return count;

}    (8)打印双向链表中数据

 

void print_double_link_node(const DOUBLE_LINK_NODE* pDLinkNode) 

    DOUBLE_LINK_NODE* pNode = (DOUBLE_LINK_NODE*)pDLinkNode; 

 

    while(NULL != pNode){ 

        printf("%dn", pNode->data); 

        pNode = pNode ->next; 

    } 

void print_double_link_node(const DOUBLE_LINK_NODE* pDLinkNode)

{

       DOUBLE_LINK_NODE* pNode = (DOUBLE_LINK_NODE*)pDLinkNode;

 

       while(NULL != pNode){

              printf("%dn", pNode->data);

              pNode = pNode ->next;

       }

}    注意:

 

        今天我们讨论的双向链表是非循环的,大家可以考虑一下如果改成循环双向链表,应该怎么写?如果是有序的循环双向链表,又该怎么写?

声明:版权所有,欢迎转载,请勿用于商业用途。 联系信箱:feixiaoxing @163.com】 前面的博客我们介绍了单向链表。那么我们今天介绍的...

本文由9159.com发布于编程,转载请注明出处:所以我们需要的那个数据可能出现在数组的各个

关键词: 9159.com