程序師世界是廣大編程愛好者互助、分享、學習的平台，程序師世界有你更精彩！
設為首頁 加入收藏
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> C語言 >> C++ >> 關於C++ >> 深刻解析C++的輪回鏈表與雙向鏈表設計的API完成

深刻解析C++的輪回鏈表與雙向鏈表設計的API完成

編輯：關於C++

深刻解析C++的輪回鏈表與雙向鏈表設計的API完成。本站提示廣大學習愛好者：（深刻解析C++的輪回鏈表與雙向鏈表設計的API完成）文章只能為提供參考，不一定能成為您想要的結果。以下是深刻解析C++的輪回鏈表與雙向鏈表設計的API完成正文

輪回鏈表設計與API完成
根本概念
輪回鏈表的界說：將單鏈表中最初一個數據元素的next指針指向第一個元素

輪回鏈表具有單鏈表的一切操作

  • 創立鏈表
  • 燒毀鏈表
  • 獲得鏈表長度
  • 清空鏈表
  • 獲得第pos個元素操作
  • 拔出元素到地位pos
  • 刪除地位pos處的元素

新增功效：游標的界說

在輪回鏈表中可以界說一個“以後”指針，這個指針平日稱為游標，可以經由過程這個游標來遍歷鏈表中的一切元素。

輪回鏈表新操作
將游標重置指向鏈表中的第一個數據元素

CircleListNode* CircleList_Reset(CircleList* list);

獲得以後游標指向的數據元素

CircleListNode* CircleList_Current(CircleList* list);

將游標挪動指向到鏈表中的下一個數據元素

CircleListNode* CircleList_Next(CircleList* list);

直接指定刪除鏈表中的某個數據元素 

CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node); 
// 依據元素的值 刪除 元素 pk依據元素的地位 刪除 元素

最初加了一個輪回鏈表的運用：求解約瑟夫成績
約瑟夫成績-輪回鏈表典范運用
n 小我圍成一個圓圈，起首第 1 小我從 1 開端一小我一小我順時針報數，報到第 m 小我，令其出列。然後再從下一 小我開端從 1 順時針報數，報到第 m 小我，再令其出列，…，如斯下去，求出列次序。

代碼：

// circlelist.h 
// 輪回鏈表API聲明 
 
#ifndef _CIRCLELIST_H_ 
#define _CIRCLELIST_H_ 
 
typedef void CircleList; 
 
typedef struct _tag_CircleListNode 
{ 
  struct _tag_CircleListNode *next; 
}CircleListNode; 
 
// 創立鏈表 
CircleList* CircleList_Create(); 
 
// 燒毀鏈表 
void CircleList_Destroy(CircleList* list); 
 
// 清空鏈表 
void CircleList_Clear(CircleList* list); 
 
// 獲得鏈表的長度 
int CircleList_Length(CircleList* list); 
 
// 在pos地位拔出結點node 
int CircleList_Insert(CircleList* list,CircleListNode* node, int pos); 
 
// 獲得pos地位的結點 
CircleListNode* CircleList_Get(CircleList* list, int pos); 
 
// 刪除pos地位的結點 
CircleListNode* CircleList_Delete(CircleList* list, int pos); 
 
// 依據結點的值停止數據刪除 
CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node); 
 
// 重置游標 
CircleListNode* CircleList_Reset(CircleList* list); 
 
// 獲得以後游標所指結點 
CircleListNode* CircleList_Current(CircleList* list); 
 
// 將原始游標所指結點前往給下層，然後讓游標移到下一個結點 
CircleListNode* CircleList_Next(CircleList* list); 
 
#endif 


// circlelist.cpp 
// 輪回鏈表API完成 
 
#include <iostream> 
#include <cstdio> 
#include "circlelist.h" 
 
typedef struct _tag_CircleList 
{ 
  CircleListNode header; 
  CircleListNode *silder; 
  int length; 
}TCircleList; 
 
// 創立鏈表 
CircleList* CircleList_Create() 
{ 
  TCircleList *ret = (TCircleList *)malloc(sizeof(TCircleList)); 
  if (ret == NULL) { 
    return NULL; 
  } 
 
  // 初始化 
  ret->header.next = NULL; 
  ret->silder = NULL; 
  ret->length = 0; 
 
  return ret; 
} 
 
// 燒毀鏈表 
void CircleList_Destroy(CircleList* list) 
{ 
  if (list == NULL) { 
    return; 
  } 
  free(list); 
  return; 
} 
 
// 清空鏈表 
void CircleList_Clear(CircleList* list) 
{ 
  if (list == NULL) { 
    return; 
  } 
  TCircleList *tList = (TCircleList *)list; 
  tList->header.next = NULL; 
  tList->silder = NULL; 
  tList->length = 0; 
 
  return; 
} 
 
// 獲得鏈表的長度 
int CircleList_Length(CircleList* list) 
{ 
  if (list == NULL) { 
    return -1; 
  } 
  TCircleList *tList = (TCircleList *)list; 
  return tList->length; 
} 
 
// 在pos地位拔出結點node 
int CircleList_Insert(CircleList* list, CircleListNode* node, int pos) 
{ 
  if (list == NULL || node == NULL || pos < 0) { 
    return -1; 
  } 
 
  TCircleList *tList = (TCircleList *)list; 
 
  CircleListNode *cur = (CircleListNode *)tList; 
 
  for (int i = 0; i < pos; ++i) { 
    cur = cur->next; 
  } 
 
  node->next = cur->next; 
  cur->next = node; 
 
  // 假如是第一次拔出 
  if (tList->length == 0) { 
    tList->silder = node; 
  } 
 
  ++tList->length; // 記得長度加1 
 
  // 假如是頭插法 
  if (cur == (CircleListNode *)tList) { 
    // 獲得最初一個元素 
    CircleListNode *last = CircleList_Get(tList, tList->length - 1); 
    last->next = cur->next; 
  } 
 
  return 0; 
} 
 
// 獲得pos地位的結點 
CircleListNode* CircleList_Get(CircleList* list, int pos) 
{ 
  // 由於是輪回鏈表，所以這裡不須要消除pos>length的情形 
  if (list == NULL || pos < 0) { 
    return NULL; 
  } 
 
  TCircleList *tList = (TCircleList *)list; 
  CircleListNode *cur = (CircleListNode *)tList; 
 
  for (int i = 0; i < pos; ++i) { 
    cur = cur->next; 
  } 
 
  return cur->next; 
} 
 
// 刪除pos地位的結點 
CircleListNode* CircleList_Delete(CircleList* list, int pos) 
{ 
  TCircleList *tList = (TCircleList *)list; 
  CircleListNode *ret = NULL; 
 
  if (tList != NULL && pos >= 0 && tList->length > 0) { 
    CircleListNode *cur = (CircleListNode *)tList; 
    for (int i = 0; i < pos; ++i) { 
      cur = cur->next; 
    } 
 
    // 若刪除頭結點，須要求出尾結點 
    CircleListNode *last = NULL; 
    if (cur == (CircleListNode *)tList) { 
      last = CircleList_Get(tList, tList->length - 1); 
    } 
 
    ret = cur->next; 
    cur->next = ret->next; 
 
    --tList->length; 
 
    // 若刪除頭結點 
    if (last != NULL) { 
      tList->header.next = ret->next; 
      last->next = ret->next; 
    } 
 
    // 若刪除的元素為游標所指的元素 
    if (tList->silder == ret) { 
      tList->silder = ret->next; 
    } 
 
    // 若刪除元素後鏈表長度為0 
    if (tList->length == 0) { 
      tList->header.next = NULL; 
      tList->silder = NULL; 
    } 
  } 
 
  return ret; 
} 
 
// 依據結點的值停止數據刪除 
CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node) 
{ 
  TCircleList *tList = (TCircleList *)list; 
  CircleListNode *ret = NULL; 
 
  if (list != NULL && node != NULL) { 
    CircleListNode *cur = (CircleListNode *)tList; 
    int i = 0; 
    for (i = 0; i < tList->length; ++i) { 
      if (cur->next == node) { 
        ret = cur->next; 
        break; 
      } 
 
      cur = cur->next; 
    } 
 
    // 假如找到 
    if (ret != NULL) { 
      CircleList_Delete(tList, i); 
    } 
  } 
 
  return ret; 
} 
 
// 重置游標 
CircleListNode* CircleList_Reset(CircleList* list) 
{ 
  TCircleList *tList = (TCircleList *)list; 
  CircleListNode* ret = NULL; 
 
  if (list != NULL) { 
    tList->silder = tList->header.next; 
    ret = tList->silder; 
  } 
 
  return NULL; 
} 
 
// 獲得以後游標所指結點 
CircleListNode* CircleList_Current(CircleList* list) 
{ 
  TCircleList *tList = (TCircleList *)list; 
  CircleListNode* ret = NULL; 
  if (list != NULL) { 
    ret = tList->silder; 
  } 
 
  return ret; 
} 
 
// 將原始游標所指結點前往給下層，然後讓游標移到下一個結點 
CircleListNode* CircleList_Next(CircleList* list) 
{ 
  TCircleList *tList = (TCircleList *)list; 
  CircleListNode* ret = NULL; 
  if (list != NULL && tList->silder != NULL) { 
    ret = tList->silder; 
    tList->silder = ret->next; 
  } 
  return ret; 
}

joseph.h  

// 用輪回鏈表API求解約瑟夫成績 
 
#include <cstdio> 
#include "circlelist.h" 
 
const int maxp = 8; 
 
struct Person 
{ 
  CircleListNode circlenode; 
  int id; 
}; 
 
void joseph() 
{ 
  Person s[maxp]; 
  for (int i = 0; i < maxp; ++i) { 
    s[i].id = i + 1; 
  } 
 
  CircleList *list = NULL; 
  list = CircleList_Create(); 
 
  // 拔出元素 
  for (int i = 0; i < maxp; ++i) { 
    // 尾插法 
    int ret = CircleList_Insert(list, (CircleListNode *)&s[i], CircleList_Length(list)); 
    if (ret < 0) { 
      printf("function CircleList_Insert err: %d\n", ret); 
    } 
  } 
 
  // 遍歷鏈表 
  for (int i = 0; i < CircleList_Length(list); ++i) { 
    Person *tmp = (Person *)CircleList_Get(list, i); 
    if (tmp == NULL) { 
      printf("function CircleList_Get err.\n"); 
    } 
    printf("age: %d\n", tmp->id); 
  } 
 
  // 求解約瑟夫成績 
  while (CircleList_Length(list) > 0) 
  { 
    Person* pv = NULL; 
    for (int i = 1; i < 3; i++) 
    { 
      CircleList_Next(list); 
    } 
    pv = (Person*)CircleList_Current(list); 
    printf("%d ", pv->id); 
    CircleList_DeleteNode(list, (CircleListNode *)pv); //依據結點的值,停止結點元素的刪除 
  } 
  printf("\n"); 
 
  CircleList_Destroy(list); 
 
}

main.cpp  

// 輪回鏈表測試法式 
 
#include <iostream> 
#include <cstdio> 
#include "circlelist.h" 
#include "joseph.h" 
 
const int maxn = 5; 
 
struct Student 
{ 
  CircleListNode circlenode; 
  char name[32]; 
  int age; 
}; 
 
void play01() 
{ 
  Student s[maxn]; 
  for (int i = 0; i < maxn; ++i) { 
    s[i].age = i + 1; 
  } 
 
  CircleList *list = NULL; 
 
  list = CircleList_Create(); // 創立鏈表 
 
  // 拔出元素 
  for (int i = 0; i < maxn; ++i) { 
    // 尾插法 
    int ret = CircleList_Insert(list, (CircleListNode *)&s[i], CircleList_Length(list)); 
    if (ret < 0) { 
      printf("function CircleList_Insert err: %d\n", ret); 
    } 
  } 
 
  // 遍歷鏈表 
  // 這裡遍歷打印雙方，可以證實這是一個輪回鏈表 
  for (int i = 0; i < 2 * CircleList_Length(list); ++i) { 
    Student *tmp = (Student *)CircleList_Get(list, i); 
    if (tmp == NULL) { 
      printf("function CircleList_Get err.\n"); 
    } 
    printf("age: %d\n", tmp->age); 
  } 
 
  // 刪除結點，經由過程結點地位 
  while (CircleList_Length(list)) { 
    Student *tmp = (Student *)CircleList_Delete(list, CircleList_Length(list) - 1); 
    if (tmp == NULL) { 
      printf("function CircleList_Delete err.\n"); 
    } 
    printf("age: %d\n", tmp->age); 
  } 
 
  // 燒毀鏈表 
  CircleList_Destroy(list); 
 
} 
 
int main() 
{ 
  play01(); // 為了測試數據的性命周期，所以另寫一個函數挪用運轉 
  joseph(); 
 
  return 0; 
}


雙向鏈表設計與API完成
為何須要雙向鏈表？

  • 單鏈表的結點都只要一個指向下一個結點的指針
  • 單鏈表的數據元素沒法直接拜訪其先驅元素
  • 逆序拜訪單鏈表中的元素是極端耗時的操作！

雙向鏈表的界說

在單鏈表的結點中增長一個指向其先驅的pre指針

雙向鏈表具有單鏈表的一切操作

  • 創立鏈表
  • 燒毀鏈表
  • 獲得鏈表長度
  • 清空鏈表
  • 獲得第pos個元素操作
  • 拔出元素到地位pos
  • 刪除地位pos處的元素

拔出操作

拔出操作異常處置
拔出第一個元素異常處置
在0號地位處拔出元素；
刪除操作

雙向鏈表的新操作

  • 獲得以後游標指向的數據元素
  • 將游標重置指向鏈表中的第一個數據元素
  • 將游標挪動指向到鏈表中的下一個數據元素
  • 將游標挪動指向到鏈表中的上一個數據元素
  • 直接指定刪除鏈表中的某個數據元素

雙向鏈表主要技巧場景

輪回鏈表拔出結點技巧場景

輪回鏈表刪除結點技巧場景

長處：雙向鏈表在單鏈表的基本上增長了指向先驅的指針
功效上雙向鏈表可以完整代替單鏈表的應用
雙向鏈表的Next，Pre和Current操作可以高效的遍歷鏈表中的一切元素
缺陷：代碼龐雜

代碼示例：
 dlinklist.h  

// 雙向鏈表API聲明 
 
#ifndef _DLINKLIST_H_ 
#define _DLINKLIST_H_ 
 
typedef void DLinkList; 
 
typedef struct _tag_DLinkListNode 
{ 
  _tag_DLinkListNode *next; 
  _tag_DLinkListNode *pre; 
}DLinkListNode; 
 
// 創立鏈表 
DLinkList* DLinkList_Create(); 
 
// 燒毀鏈表 
void DLinkList_Destroy(DLinkList *list); 
 
// 清空鏈表 
void DLinkList_Clear(DLinkList *list); 
 
// 獲得鏈表長度 
int DLinkList_Length(DLinkList *list); 
 
// 在pos地位，拔出結點node 
int DLinkList_Insert(DLinkList *list, DLinkListNode *node, int pos); 
 
// 獲得pos地位的結點，前往給下層 
DLinkListNode* DLinkList_Get(DLinkList *list, int pos); 
 
// 刪除pos地位的結點 
DLinkListNode* DLinkList_Delete(DLinkList *list, int pos); 
 
// 刪除值為node的結點 
DLinkListNode* DLinkList_DeleteNode(DLinkList* list, DLinkListNode* node); 
 
// 重置游標 
DLinkListNode* DLinkList_Reset(DLinkList* list); 
 
// 獲得以後游標所指的結點 
DLinkListNode* DLinkList_Current(DLinkList* list); 
 
// 獲得游標以後所指結點，然後讓游標指向下一個結點 
DLinkListNode* DLinkList_Next(DLinkList* list); 
 
// 獲得游標以後所指結點，然後讓游標指向前一個結點 
DLinkListNode* DLinkList_Pre(DLinkList* list); 
 
 
#endif


dlinklist.cpp  

// 輪回鏈表API完成 
 
#include <cstdio> 
#include <malloc.h> 
#include "dlinklist.h" 
 
typedef struct _tag_DLinkList 
{ 
  DLinkListNode header; 
  DLinkListNode *slider; 
  int length; 
}TDLinkList; 
 
// 創立鏈表 
DLinkList* DLinkList_Create() 
{ 
  TDLinkList *ret = (TDLinkList *)malloc(sizeof(TDLinkList)); 
   
  if (ret != NULL) { 
    ret->header.next = NULL; 
    ret->header.pre = NULL; 
    ret->slider = NULL; 
    ret->length = 0; 
  } 
 
  return ret; 
} 
 
// 燒毀鏈表 
void DLinkList_Destroy(DLinkList *list) 
{ 
  if (list != NULL) { 
    free(list); 
  } 
 
  return; 
} 
 
// 清空鏈表 
void DLinkList_Clear(DLinkList *list) 
{ 
  TDLinkList *tList = (TDLinkList *)list; 
 
  if (tList != NULL) { 
    tList->header.next = NULL; 
    tList->header.pre = NULL; 
    tList->slider = NULL; 
    tList->length = 0; 
  } 
   
  return; 
} 
 
// 獲得鏈表長度 
int DLinkList_Length(DLinkList *list) 
{ 
  TDLinkList *tList = (TDLinkList *)list; 
  int ret = -1; 
 
  if (tList != NULL) { 
    ret = tList->length; 
  } 
 
  return ret; 
} 
 
// 在pos地位，拔出結點node 
int DLinkList_Insert(DLinkList *list, DLinkListNode *node, int pos) 
{ 
  TDLinkList *tList = (TDLinkList *)list; 
  int ret = -1, i = 0; 
 
  if (list != NULL && node != NULL && pos >= 0) 
  { 
    ret = 0; 
 
    DLinkListNode *cur = (DLinkListNode *)tList; 
    DLinkListNode *next = NULL; 
 
    for (i = 0; i < pos && cur->next != NULL; ++i) { 
      cur = cur->next; 
    } 
 
    next = cur->next; 
 
    cur->next = node; 
    node->next = next; 
 
    // 當鏈表拔出第一個結點時須要停止特別處置 
    if (next != NULL) { 
      next->pre = node; 
    } 
    node->pre = cur; 
 
    if (tList->length == 0)  { 
      tList->slider = node; // 當鏈表拔出第一個元素處置游標 
    } 
 
    // 若在0地位拔出，須要特別處置，新來的結點next前pre指向NULL 
    if (cur == (DLinkListNode *)tList) { 
      node->pre = NULL; 
    } 
    ++tList->length; 
  } 
 
  return ret; 
} 
 
// 獲得pos地位的結點，前往給下層 
DLinkListNode* DLinkList_Get(DLinkList *list, int pos) 
{ 
  TDLinkList *tList = (TDLinkList *)list; 
  DLinkListNode* ret = NULL; 
  int i = 0; 
   
  if (list != NULL && pos >= 0 && pos < tList->length) { 
    DLinkListNode *cur = (DLinkListNode *)tList; 
 
    for (i = 0; i < pos; ++i) { 
      cur = cur->next; 
    } 
 
    ret = cur->next; 
  } 
 
  return ret; 
} 
 
// 刪除pos地位的結點 
DLinkListNode* DLinkList_Delete(DLinkList *list, int pos) 
{ 
  TDLinkList *tList = (TDLinkList *)list; 
  DLinkListNode* ret = NULL; 
  int i = 0; 
 
  if (tList != NULL && pos >= 0) { 
    DLinkListNode *cur = (DLinkListNode *)tList; 
    DLinkListNode *next = NULL; 
 
    for (i = 0; i < pos && cur->next != NULL; ++i) { 
      cur = cur->next; 
    } 
 
    ret = cur->next; 
    next = ret->next; 
 
    cur->next = next; 
 
    if (next != NULL) { 
      next->pre = cur; 
 
      if (cur == (DLinkListNode *)tList) { // 第0個地位，須要特別處置 
        next->pre = NULL; 
      } 
    } 
 
    if (tList->slider == ret) { 
      tList->slider = next; 
    } 
 
    --tList->length; 
  } 
 
  return ret; 
} 
 
// 刪除值為node的結點 
DLinkListNode* DLinkList_DeleteNode(DLinkList* list, DLinkListNode* node) 
{ 
  TDLinkList *tList = (TDLinkList *)list; 
  DLinkListNode* ret = NULL; 
  int i = 0; 
 
  if (tList != NULL) { 
    DLinkListNode *cur = (DLinkListNode *)tList; 
 
    for (i = 0; i < DLinkList_Length(tList); ++i) { 
      if (cur->next == node) { 
        ret = cur->next; 
        break; 
      } 
 
      cur = cur->next; 
    } 
 
    if (!ret) { 
      DLinkList_Delete(tList, i); 
    } 
  } 
 
  return ret; 
} 
 
// 重置游標 
DLinkListNode* DLinkList_Reset(DLinkList* list) 
{ 
  TDLinkList *tList = (TDLinkList *)list; 
  DLinkListNode* ret = NULL; 
   
  if (tList != NULL) { 
    tList->slider = tList->header.next; 
    ret = tList->slider; 
  } 
 
  return ret; 
} 
 
// 獲得以後游標所指的結點 
DLinkListNode* DLinkList_Current(DLinkList* list) 
{ 
  TDLinkList *tList = (TDLinkList *)list; 
  DLinkListNode* ret = NULL; 
 
  if (tList != NULL) { 
    ret = tList->slider; 
  } 
 
  return ret; 
} 
 
// 獲得游標以後所指結點，然後讓游標指向下一個結點 
DLinkListNode* DLinkList_Next(DLinkList* list) 
{ 
  TDLinkList *tList = (TDLinkList *)list; 
  DLinkListNode* ret = NULL; 
 
  if (tList != NULL && tList->slider != NULL) { 
    ret = tList->slider; 
    tList->slider = ret->next; 
  } 
 
  return ret; 
} 
 
// 獲得游標以後所指結點，然後讓游標指向前一個結點 
DLinkListNode* DLinkList_Pre(DLinkList* list) 
{ 
  TDLinkList *tList = (TDLinkList *)list; 
  DLinkListNode* ret = NULL; 
 
  if (tList != NULL && tList->slider != NULL) { 
    ret = tList->slider; 
    tList->slider = ret->pre; 
  } 
 
  return ret; 
}


main.cpp  

// 輪回線表測試法式 
 
#include <cstdio> 
#include "dlinklist.h" 
 
const int maxn = 5; 
 
struct Student 
{ 
  DLinkListNode node; 
  int age; 
}; 
 
void play() 
{ 
  Student s[maxn]; 
  for (int i = 0; i < maxn; ++i) { 
    s[i].age = i + 21; 
  } 
 
  DLinkList *list = NULL; 
  list = DLinkList_Create(); // 創立鏈表 
 
  // 拔出結點 
  for (int i = 0; i < maxn; ++i) { 
    int ret = DLinkList_Insert(list, (DLinkListNode *)&s[i], DLinkList_Length(list)); 
    if (ret < 0) { 
      return; 
      printf("function DLinkList_Insert err.\n"); 
    } 
  } 
 
  // 遍歷鏈表 
  for (int i = 0; i < DLinkList_Length(list); ++i) { 
    Student *tmp = (Student *)DLinkList_Get(list, i); 
    if (tmp == NULL) { 
      printf("function DLinkList_Get err.\n"); 
      return; 
    } 
    printf("age: %d\n", tmp->age); 
  } 
 
  DLinkList_Delete(list, DLinkList_Length(list) - 1); // 刪除尾結點 
  DLinkList_Delete(list, 0); // 刪除頭結點 
 
  // 用游標遍歷鏈表 
  for (int i = 0; i < DLinkList_Length(list); ++i) { 
    Student *tmp = (Student *)DLinkList_Next(list); 
    if (tmp == NULL) { 
      printf("function DLinkList_Next err.\n"); 
      return; 
    } 
    printf("age: %d\n", tmp->age); 
  } 
 
  printf("\n"); 
 
  DLinkList_Reset(list); 
  DLinkList_Next(list); 
 
  Student *tmp = (Student *)DLinkList_Current(list); 
  if (tmp == NULL) { 
    printf("function DLinkList_Current err.\n"); 
    return; 
  } 
  printf("age: %d\n", tmp->age); 
 
  DLinkList_DeleteNode(list, (DLinkListNode*)tmp); 
  tmp = (Student *)DLinkList_Current(list); 
  if (tmp == NULL) { 
    printf("function DLinkList_Current err.\n"); 
    return; 
  } 
  printf("age: %d\n", tmp->age); 
  printf("length: %d\n", DLinkList_Length(list)); 
 
  DLinkList_Pre(list); 
  tmp = (Student *)DLinkList_Current(list); 
  if (tmp == NULL) { 
    printf("function DLinkList_Current err.\n"); 
    return; 
  } 
  printf("age: %d\n", tmp->age); 
 
  printf("length: %d\n", DLinkList_Length(list)); 
  DLinkList_Destroy(list); 
 
  return; 
} 
 
int main() 
{ 
  play(); 
 
  return 0; 
}

  1. 上一頁:
  2. 下一頁:
關於C++
用C++實現高精度加法運算

先說說高精度運算的概念：是指參與運算的數(加數，減數，因子&
CF 505C(Mr. Kitayuta, the Treasure Hunter

C. Mr. Kitayuta, the Tr
C++學習摘要之九：C++流和文件流

在程序設計中，數據輸入/輸出（I/O）操作是必
C++設計模式之建造者模式解決

C++設計模式之建造者模式 將一個復雜對象的構建與它的表示分
c++中的參數傳遞方式

c++中的參數傳遞有三種：1.傳值默認的傳值，即在函數被調用
leetocde_Binary Tree Right Side View

描述： Given a binary tree,

相關文章
閱讀排行榜
C++：最強大的.NET語言之裝箱 快速解決boost庫鏈接出錯的問題(分享) hdu 5170 5171 淺談int8_t int64_t size_t ssize_t的相關問題(詳解) Windows中控制台程序的全屏模式開關 bzoj3190【JLOI013】賽車 C說話求向量和的兩則成績解答分享 統計字符類型 Winsock API函數大全3 用C++ Builder創建數字簽名 用於計算四則混合運算表達式的遞歸函數第二版
熱門圖文
java多線程之join方法使用教程 php實現Mongodb自定義方式生成自增ID的方法 GdiPlus[15]: IGPLinearGradientBrush 之 GammaCorrection pdo連接數據庫與查詢與保存數據到mysql jq-JQ添加 wmod e屬性問題 Beginner with c# 3 C++中的構造函數和析構函數 程序員最容易犯的五個PHP數據庫問題及解釋
欄目導航
C++基礎知識C++入門知識關於C++
Copyright © 程式師世界 All Rights Reserved