NULL改为nullptr

Author: soulmachine

C++/abstract.tex

@@ -12,7 +12,7 @@ \subsubsection{内容简介}
 
 \item Shorter is better。能递归则一定不用栈；能用STL则一定不自己实现。
 
-\item 不提倡防御式编程。不需要检查malloc()/new 返回的指针是否为NULL；不需要检查内部函数入口参数的有效性；使用纯C基于对象编程时，调用对象的成员方法，不需要检查对象自身是否为NULL。
+\item 不提倡防御式编程。不需要检查malloc()/new 返回的指针是否为nullptr；不需要检查内部函数入口参数的有效性。
 \myenddot
 
 本手册假定读者已经学过《数据结构》\footnote{《数据结构》，严蔚敏等著，清华大学出版社，

C++/chapLinearList.tex

@@ -321,7 +321,7 @@ \section{单链表} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 struct ListNode {
     int val;
     ListNode *next;
-    ListNode(int x) : val(x), next(NULL) { }
+    ListNode(int x) : val(x), next(nullptr) { }
 };
 \end{Code}
 
@@ -353,15 +353,15 @@ \subsubsection{代码}
         ListNode* pre = head;
         ListNode *pa = l1, *pb = l2;
         int carry = 0;
-        while (pa != NULL || pb != NULL) {
-            int av = pa == NULL ? 0 : pa->val;
-            int bv = pb == NULL ? 0 : pb->val;
+        while (pa != nullptr || pb != nullptr) {
+            int av = pa == nullptr ? 0 : pa->val;
+            int bv = pb == nullptr ? 0 : pb->val;
             ListNode* node = new ListNode((av + bv + carry) % 10);
             carry = (av + bv + carry) / 10;
             pre->next = node; // 尾插法
             pre = pre->next;
-            pa = pa == NULL ? NULL : pa->next;
-            pb = pb == NULL ? NULL : pb->next;
+            pa = pa == nullptr ? nullptr : pa->next;
+            pb = pb == nullptr ? nullptr : pb->next;
         }
         if (carry > 0)
             pre->next = new ListNode(1);
@@ -388,9 +388,9 @@ \subsubsection{描述}
 Reverse a linked list from position $m$ to $n$. Do it in-place and in one-pass.
 
 For example:
-Given \code{1->2->3->4->5->NULL}, $m$ = 2 and $n$ = 4,
+Given \code{1->2->3->4->5->nullptr}, $m$ = 2 and $n$ = 4,
 
-return \code{1->4->3->2->5->NULL}.
+return \code{1->4->3->2->5->nullptr}.
 
 Note:
 Given m, n satisfy the following condition:
@@ -475,7 +475,7 @@ \subsubsection{代码}
 class Solution {
 public:
     ListNode* partition(ListNode* head, int x) {
-        if (head == NULL) return head;
+        if (head == nullptr) return head;
 
         ListNode left_dummy(0); // 头结点
         ListNode right_dummy(0); // 头结点
@@ -494,7 +494,7 @@ \subsubsection{代码}
         }
 
         left_cur->next = right_dummy.next;
-        right_cur->next = NULL;
+        right_cur->next = nullptr;
 
         return left_dummy.next;
     }
@@ -533,10 +533,10 @@ \subsubsection{代码}
 class Solution {
 public:
     ListNode *deleteDuplicates(ListNode *head) {
-        if (head == NULL) return NULL;
+        if (head == nullptr) return nullptr;
         ListNode * prev = head;
         ListNode *cur = head->next;
-        while (cur != NULL) {
+        while (cur != nullptr) {
             if (prev->val == cur->val) {
                 ListNode* temp = cur;
                 cur = cur->next;
@@ -584,14 +584,14 @@ \subsubsection{代码}
 class Solution {
 public:
     ListNode *deleteDuplicates(ListNode *head) {
-        if (head == NULL) return head;
+        if (head == nullptr) return head;
 
         ListNode dummy(INT_MIN); // 头结点
         dummy.next = head;
         ListNode *prev = &dummy, *cur = head;
-        while (cur != NULL) {
+        while (cur != nullptr) {
             bool duplicated = false;
-            while (cur->next != NULL && cur->val == cur->next->val) {
+            while (cur->next != nullptr && cur->val == cur->next->val) {
                 duplicated = true;
                 ListNode *temp = cur;
                 cur = cur->next;
@@ -629,7 +629,7 @@ \subsubsection{描述}
 Given a list, rotate the list to the right by $k$ places, where $k$ is non-negative.
 
 For example:
-Given \code{1->2->3->4->5->NULL} and \code{k = 2}, return \code{4->5->1->2->3->NULL}.
+Given \code{1->2->3->4->5->nullptr} and \code{k = 2}, return \code{4->5->1->2->3->nullptr}.
 
 
 \subsubsection{分析}
@@ -642,7 +642,7 @@ \subsubsection{代码}
 class Solution {
 public:
     ListNode *rotateRight(ListNode *head, int k) {
-        if (head == NULL || k == 0) return head;
+        if (head == nullptr || k == 0) return head;
 
         int len = 1;
         ListNode* p = head;
@@ -657,7 +657,7 @@ \subsubsection{代码}
             p = p->next;  //接着往后跑
         }
         head = p->next; // 新的首节点
-        p->next = NULL; // 断开环
+        p->next = nullptr; // 断开环
         return head;
     }
 };

C++/chapSorting.tex

@@ -54,23 +54,15 @@ \subsubsection{分析}
 
 \subsubsection{代码}
 \begin{Code}
-struct ListNode {
-    int val;
-    ListNode *next;
-    ListNode(int x) :
-            val(x), next(NULL) {
-    }
-};
- 
 //LeetCode, Merge Two Sorted Lists
 class Solution {
 public:
     ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
         ListNode* head = new ListNode(-1);
         ListNode* p = head;
-        while (l1 != NULL || l2 != NULL) {
-            int val1 = l1 == NULL ? INT_MAX : l1->val;
-            int val2 = l2 == NULL ? INT_MAX : l2->val;
+        while (l1 != nullptr || l2 != nullptr) {
+            int val1 = l1 == nullptr ? INT_MAX : l1->val;
+            int val2 = l2 == nullptr ? INT_MAX : l2->val;
             if (val1 <= val2) {
                 p->next = l1;
                 l1 = l1->next;
@@ -109,20 +101,12 @@ \subsubsection{分析}
 
 \subsubsection{代码}
 \begin{Code}
-struct ListNode {
-    int val;
-    ListNode *next;
-    ListNode(int x) :
-            val(x), next(NULL) {
-    }
-};
- 
 //LeetCode, Merge k Sorted Lists
 class Solution {
 public:
     ListNode *mergeKLists(vector<ListNode *> &lists) {
-        if (lists.size() == 0)
-            return NULL;
+        if (lists.size() == 0) return nullptr;
+
         ListNode *p = lists[0];
         for (int i = 1; i < lists.size(); i++) {
             p = mergeTwoLists(p, lists[i]);
@@ -134,9 +118,9 @@ \subsubsection{代码}
     ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
         ListNode* head = new ListNode(-1);
         ListNode* p = head;
-        while (l1 != NULL || l2 != NULL) {
-            int val1 = l1 == NULL ? INT_MAX : l1->val;
-            int val2 = l2 == NULL ? INT_MAX : l2->val;
+        while (l1 != nullptr || l2 != nullptr) {
+            int val1 = l1 == nullptr ? INT_MAX : l1->val;
+            int val2 = l2 == nullptr ? INT_MAX : l2->val;
             if (val1 <= val2) {
                 p->next = l1;
                 l1 = l1->next;