C++有序双向链表

C++有序双向链表

1. 遍历的时候不只用value check, 还会用到address check

2. C++ 生成随机数

 

主要函数

1. 在双向链表插入新节点

2. 计算双向链表中元素的总个数

2. 删除某个值的所有元素

3. 删除某个值的单个元素

4. 统计等于某个值的元素个数

 

此外有一个Output函数用来输出测试结果

头结点是head, 如为NULL则该双向链表为空

 

感悟:

觉得在处理特殊单个节点的情况比较麻烦,要额外考虑出来

此外,用地址检测来确认遍历一圈,而不是用值data来检测

 

代码(包括测试的main函数):

 

[cpp] 
view plain
copy

  1. #include <iostream>  
  2. #include <ctime>  
  3. #include <cstdlib>  
  4. using namespace std;  
  5.   
  6. //Forward Declaration  
  7. template<class Type>  
  8. class DoubleLinkedList;  
  9.   
  10.   
  11. //Node with two pointers *next and *prev  
  12. template<class Type>  
  13. class Node{  
  14.     friend class DoubleLinkedList<Type>;  
  15. private:  
  16.     Type data;  
  17.     Node *next;  
  18.     Node *prev;  
  19. public:  
  20.     Type getData(){  
  21.         return data;  
  22.     }  
  23.     Node(): next(NULL),prev(NULL){}  
  24.     Node(const Type& data){  
  25.         Node::data = data;  
  26.         next = NULL;  
  27.         prev = NULL;  
  28.     }  
  29. };  
  30.   
  31. template<class Type>  
  32. class DoubleLinkedList{  
  33. private:  
  34.     Node<Type> *head;  
  35. public:  
  36.     DoubleLinkedList(): head(NULL){}  
  37.     DoubleLinkedList(Node<Type>* head){  
  38.         DoubleLinkedList::head = head;  
  39.         head->next = head;  
  40.         head->prev = head;  
  41.     }  
  42.     ~DoubleLinkedList();  
  43.     //Insert a new Node into the Double Linked List  
  44.     Node<Type>* Insert(const Type& data);  
  45.   
  46.     //Delete all elements equal @parameter data  
  47.     void DeleteAllElementsEqual(const Type& data);  
  48.   
  49.     //Delete one element equal @parameter data  
  50.     void DeleteOneElementEqual(const Type& data);  
  51.   
  52.     //Get Count Of Element equal @parameter data  
  53.     int GetCountOfElmentsEqual(const Type& data);  
  54.     int getSize();  
  55.     void Clear();  
  56.     void Output();  
  57. };  
  58.   
  59. template<class Type>  
  60. Node<Type>* DoubleLinkedList<Type>::Insert(const Type& data){  
  61.     if(head == NULL){  
  62.         DoubleLinkedList::head = new Node<Type>(data);  
  63.         head->next = head;  
  64.         head->prev = head;  
  65.         return head;  
  66.     }else{  
  67.         Node<Type> *currentNode = head;  
  68.         while(true){  
  69.             /* 
  70.              * if it traverses all the link , and has insert it in the last place 
  71.              * or,  finds the correct place to insert, 
  72.              * then create the new Node(data), 
  73.              * if new data smaller than the head , 
  74.              * then change the head pointer to the new inserted node 
  75.              */  
  76.             if(currentNode->next == head || currentNode->data == data ||  
  77.                     (currentNode->data < data && data < currentNode->next->data)){  
  78.                 Node<Type>* newNode = new Node<Type>(data);  
  79.                 newNode->next = currentNode->next;  
  80.                 currentNode->next = newNode;  
  81.                 //here we insert a new Node, but  
  82.                 //its next pointer has been already modified!  
  83.                 newNode->prev = currentNode;  
  84.                 newNode->next->prev = newNode;  
  85.                 if(newNode->data < head->data)  
  86.                     head = newNode;  
  87.                 return newNode;  
  88.             }  
  89.             currentNode = currentNode->next;  
  90.         }  
  91.     }  
  92. }  
  93.   
  94. template<class Type>  
  95. void DoubleLinkedList<Type>::Output(){  
  96.     cout << endl << “OUTPUT: “ << endl;  
  97.     if(head == NULL){  
  98.         cout << “\nNULL LIST! “ << endl;  
  99.         return;  
  100.     }  
  101.     Node<Type>* currentNode = head;  
  102.     //Sequential Traversal from head  
  103.     cout << “Sequential Traversal from head: “ << endl;  
  104.     for(int i = 0;i < getSize();i++){  
  105.         cout << currentNode->data << “, “;  
  106.         currentNode = currentNode->next;  
  107.     }  
  108.     //Conversal Traversal from head  
  109.     currentNode = head;  
  110.     cout << endl << “Converse Traversal from head: “ << endl;  
  111.     for(int i = 0;i < getSize();i++){  
  112.         cout << currentNode->data << “, “;  
  113.         currentNode = currentNode->prev;  
  114.     }  
  115.     cout << endl;  
  116. }  
  117.   
  118.   
  119. template<class Type>  
  120. int DoubleLinkedList<Type>::getSize(){  
  121.     int size = 0;  
  122.     if(head == NULL)  
  123.         return size;  
  124.     else{  
  125.         Node<Type> *currentNode = head;  
  126.         do{  
  127.             size++;  
  128.         }while((currentNode = currentNode->next) != head);  
  129.     }  
  130.     return size;  
  131. }  
  132.   
  133.   
  134. template<class Type>  
  135. void DoubleLinkedList<Type>::DeleteAllElementsEqual(const Type& data){  
  136.     if(head == NULL)  
  137.         return;  
  138.     Node<Type> *currentNode = head;  
  139.     //First, find the node whose value equal data  
  140.     bool isExisted = false;  
  141.     do{  
  142.         if(currentNode->data == data){  
  143.             isExisted = true;  
  144.             break;  
  145.         }  
  146.     }while((currentNode = currentNode->next) != head);  
  147.   
  148.     if(isExisted){  
  149.         while(currentNode->data == data){  
  150.             //only one node left  
  151.             if(currentNode == currentNode->next){  
  152.                 delete head;  
  153.                 head = NULL;  
  154.                 return;  
  155.             }  
  156.             //more than one node left  
  157.             Node<Type> *tempNode = currentNode;  
  158.             currentNode->prev->next = currentNode->next;  
  159.             currentNode->next->prev = currentNode->prev;  
  160.             currentNode = currentNode->next;  
  161.             delete tempNode;  
  162.         }  
  163.     }  
  164. }  
  165.   
  166.   
  167. template<class Type>  
  168. void DoubleLinkedList<Type>::DeleteOneElementEqual(const Type& data){  
  169.     if(head == NULL)  
  170.         return;  
  171.     Node<Type> *currentNode = head;  
  172.     bool isExisted = false;  
  173.     do{  
  174.         if(currentNode->data == data){  
  175.             isExisted = true;  
  176.             break;  
  177.         }  
  178.     }while((currentNode = currentNode->next) != head);  
  179.     if(isExisted){  
  180.         //only one node left  
  181.         if(currentNode == currentNode->next){  
  182.             delete head;  
  183.             head = NULL;  
  184.         }  
  185.         //More than one node left  
  186.         Node<Type> *tempNode = currentNode;  
  187.         currentNode->prev->next = currentNode->next;  
  188.         currentNode->next->prev = currentNode->prev;  
  189.         delete tempNode;  
  190.     }  
  191. }  
  192.   
  193.   
  194. template<class Type>  
  195. void DoubleLinkedList<Type>::Clear(){  
  196.     if(head == NULL)  
  197.         return;  
  198.     Node<Type> *currentNode = head;  
  199.     do{  
  200.         Node<Type> *tempNode = currentNode;  
  201.         currentNode = currentNode->next;  
  202.         delete tempNode;  
  203.     }while(currentNode != head);  
  204.     head = NULL;  
  205. }  
  206.   
  207.   
  208. template<class Type>  
  209. int DoubleLinkedList<Type>::GetCountOfElmentsEqual(const Type& data){  
  210.     int count = 0;  
  211.     Node<Type> *currentNode = head;  
  212.     do{  
  213.         if(currentNode->data == data)  
  214.             count++;  
  215.     }while((currentNode = currentNode->next) != head);  
  216.     return count;  
  217. }  
  218.   
  219.   
  220. template<class Type>  
  221. DoubleLinkedList<Type>::~DoubleLinkedList(){  
  222.     if(head == NULL)  
  223.         return;  
  224.     Node<Type> *currentNode = head->next;  
  225.     while(currentNode != head){  
  226.         Node<Type> *tempNode = currentNode;  
  227.         currentNode = currentNode->next;  
  228.         delete tempNode;  
  229.         tempNode = NULL;  
  230.     }  
  231.     delete head;  
  232.     head = NULL;  
  233. }  
  234.   
  235.   
  236.   
  237. //Test Main  
  238. int main() {  
  239.     DoubleLinkedList<int> *dList = new DoubleLinkedList<int>();  
  240.     cout << “RANDOM INPUT: “ << endl;  
  241.     srand(unsigned(time(0)));  
  242.     for(int i = 0;i < 20;i++){  
  243.         int newNumber = rand() % 10;  
  244.         cout << dList->Insert(newNumber % 6)->getData() << ” , “;  
  245.     }  
  246.     cout << “\nlist size: “ << dList->getSize();  
  247.     dList->Output();  
  248.   
  249.     cout << endl << “Count Elements equal 1: “;  
  250.     cout << endl << “Number of All Elements equal 1: “  
  251.                     << dList->GetCountOfElmentsEqual(1) << endl;  
  252.   
  253.     cout << endl << “Delete One Elements equal 2: “;  
  254.     dList->DeleteOneElementEqual(2);  
  255.     cout << endl << “list size after Delete One Element: “ << dList->getSize();  
  256.     dList->Output();  
  257.   
  258.     cout << endl << “Delete All Elements equal 3: “;  
  259.     dList->DeleteAllElementsEqual(3);  
  260.     cout << endl << “list size after Delete: “ << dList->getSize();  
  261.     dList->Output();  
  262.   
  263.     cout << endl << “Clear List: “;  
  264.     dList->Clear();  
  265.     cout << endl << “list size after Clear: “ << dList->getSize();  
  266.   
  267.     return 0;  
  268. }  

 

 

 

输出:

C++有序双向链表

 

 

转载于:https://www.cnblogs.com/hktk/archive/2012/09/22/2698365.html

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/110316.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)
blank

相关推荐

  • ajax 常用写法「建议收藏」

    ajax 常用写法「建议收藏」$.ajax({type:”POST”,url:”/aa/bb”,data:{},success:function(data){},error:function(jqXHR){}});——————————————$.ajax({.

  • 思维导图整理大厂面试高频数组26: 合并区间中详解lambada表达式和toArray()用法, 力扣56

    思维导图整理大厂面试高频数组26: 合并区间中详解lambada表达式和toArray()用法, 力扣56此专栏文章是对力扣上算法题目各种方法的总结和归纳,整理出最重要的思路和知识重点并以思维导图形式呈现,当然也会加上我对导图的详解.目的是为了更方便快捷的记忆和回忆算法重点(不用每次都重复看题解),毕竟算法不是做了一遍就能完全记住的.所以本文适合已经知道解题思路和方法,想进一步加强理解和记忆的朋友,并不适合第一次接触此题的朋友(可以根据题号先去力扣看看官方题解,然后再看本文内容).关于本专栏所有题目的目录链接,刷算法题目的顺序/注意点/技巧,以及思维导图源文件问题请点击此链接.想进大厂.

  • 用javascript去掉字符串空格的办法

    今天遇到了以关于JavaScript中怎么去掉字符串中前后两段的空格,我只好向就得js中也后Trim()函数,后来试试了不行,就网上找了下解决方法,其中用到了正则表达式,整理了下:12

    2021年12月21日
  • 激活pycharm方法(采用激活码激活)

    激活pycharm方法(采用激活码激活)1.在C:\Windows\System32\drivers\etc目录下hosts文件中最后一行加入:0.0.0.0account.jetbrains.com2.打开PyCharm选择Activationcode激活,然后复制下面的激活码点击激活。K71U8DBPNE-eyJsaWNlbnNlSWQiOiJLNzFVOERCUE5FIiwibGljZW5zZWVOYW1lIjoi…

    2022年10月22日
  • 程序员进外包后不好找工作吗_程序员去外包是不是就废了

    程序员进外包后不好找工作吗_程序员去外包是不是就废了在职场中选择公司非常重要,有些人为了贪图大公司名气,选择去干大公司的外包,但要知道外包跟正式员工,不管是收入还是从职业地位来说相差非常大,所以建议想去外包公司上班的请慎重。最近在职业论坛看到这样一个热门的帖子,“二本毕业,在华为外包工作3年,考虑跳槽却不收外包背景,怎么办”。到底怎么回事?请往下看。原来一位网友说,自己是二本毕业,到现在已经三年了,一直在华为外包,工作时间和华为正式工一样,每…

  • stl文件格式特点_常见文件格式

    stl文件格式特点_常见文件格式一、介绍STL文件格式(stereolithography,光固化立体造型术的缩写)是由3DSYSTEMS公司于1988年制定的一个接口协议,是一种为快速原型制造技术服务的三维图形文件格式。S

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号