ListNode* reverseBetween(ListNode* head, int m, int n) { if(head == nullptr ) return head; ListNode dummyHead(0); ListNode* pre = &dummyHead; pre->next = head; for(int i = 1; i < m && pre->next != nullptr; ++i) pre = pre->next; ListNode* cur = pre->next; ListNode* tail = cur; ListNode* beg = pre; for(int i = m; i <=n && cur != nullptr; ++i) { ListNode* pNext = cur->next; cur->next = pre; pre = cur; cur = pNext; } beg->next = pre; tail->next = cur; return dummyHead.next; }
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ ListNode* Solution::partition(ListNode* head, int B) { // Do not write main() function. // Do not read input, instead use the arguments to the function. // Do not print the output, instead return values as specified // Still have a doubt. Checkout www.interviewbit.com/pages/sample_codes/ for more details ListNode dummy(-1); dummy.next = head; // original list ListNode dummyHead(INT_MIN); ListNode *p = &dummyHead; // candidate list ListNode* prev = &dummy; while(head != NULL) { ListNode *next = head->next; if(head->val < B) { // append to the candidate list p->next = head; p = p->next; // remove from the original list prev->next = next; head = next; } else { prev = head; head = next; } } p->next = dummy.next; return dummyHead.next; }
ListNode *reverseKGroup(ListNode *head, int k) { if (head == nullptr || k <= 1) return head; ListNode dummyHead(0); dummyHead.next = head; ListNode *beginK = head; ListNode *endK = head; ListNode *prevNode = &dummyHead; for (;;) { int steps = k; while (endK != nullptr && steps-- > 0) endK = endK->next; if (steps > 0) break; ListNode *pPrev = endK; ListNode *pCurr = beginK; do { ListNode *pDummy = pCurr->next; pCurr->next = pPrev; pPrev = pCurr; pCurr = pDummy; } while (pCurr != endK); beginK->next = endK; prevNode->next = pPrev; prevNode = beginK; beginK = endK; } return dummyHead.next; }
ListNode* reverseList(ListNode* head) { if(!head)return NULL; ListNode dummyHead(0); dummyHead.next = head; ListNode *tail = &dummyHead; ListNode *front = head; while(front->next){ ListNode *tmp = front->next; front->next = tmp->next; tmp->next = tail->next; tail->next = tmp; } return dummyHead.next; }
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { ListNode dummyHead(0); ListNode *head = &dummyHead, *first = l1, *second = l2; while (first && second) { if (first->val <= second->val) { head->next = first; first = first->next; } else { head->next = second; second = second->next; } head = head->next; } head->next = first ? first : second; return dummyHead.next; }
ListNode* removeElements(ListNode* head, int val) { ListNode dummyHead(0); dummyHead.next = head;//虚拟头节点,可以将删除head节点转换成一般情况,无需特殊处理 ListNode *previous = &dummyHead;//前趋 ListNode *current = head; while(current) { if(current->val == val) { deleteNode(previous, current);//删除current节点 current = previous->next; } else { previous = current; current = current->next; } } return dummyHead.next;//返回真正的head }
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) { ListNode dummyHead(0); ListNode *tail = &dummyHead; int c=0; while(l1 || l2){ int tmpValue = (l1?l1->val:0) + (l2?l2->val:0) + c; c = tmpValue/10; tmpValue%=10; ListNode *newNode = new ListNode(tmpValue); tail = tail->next = newNode; if(l1)l1=l1->next; if(l2)l2=l2->next; } if(c){ ListNode *newNode = new ListNode(c); tail = tail->next = newNode; } return dummyHead.next; }
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) { if(l1 == nullptr) return l2; if(l2 == nullptr) return l1; ListNode dummyHead(0); ListNode* pre = &dummyHead; int carry = 0; while(l1 != nullptr && l2 != nullptr) { int sum = l1->val + l2->val + carry; carry = sum / 10; pre->next = new ListNode(sum % 10); l1 = l1->next; l2 = l2->next; pre = pre->next; } while(l1 != nullptr) { int sum = l1->val + carry; carry = sum / 10; pre->next = new ListNode(sum % 10); l1 = l1->next; pre = pre->next; } while(l2 != nullptr) { int sum = l2->val + carry; carry = sum / 10; pre->next = new ListNode(sum % 10); l2 = l2->next; pre = pre->next; } if(carry == 1) pre->next = new ListNode(carry); return dummyHead.next; }
ListNode* reverseBetween(ListNode* head, int m, int n) { if(head == nullptr || m <= 0 || n <= 0 || m >= n) return head; ListNode dummyHead(0); ListNode* pPre = &dummyHead; pPre->next = head; ListNode* pEnd = head; for(int i = 1; i < m && pPre != nullptr; ++i) { pPre = pPre->next; pEnd = pEnd->next; } ListNode* pBeg = pPre; if(pBeg->next != nullptr) pBeg = pBeg->next; else return head; for(int i = m; i <= n && pEnd != nullptr; ++i) pEnd = pEnd->next; auto reverseList = [](ListNode* pBeg, ListNode* pEnd) { ListNode* pPre = pBeg; pBeg = pBeg->next; while(pBeg != pEnd) { ListNode* pNext = pBeg->next; pBeg->next = pPre; pPre = pBeg; pBeg = pNext; } return pPre; }; pPre->next = reverseList(pBeg, pEnd); pBeg->next = pEnd; return dummyHead.next; }
ListNode *deleteDuplicates(ListNode *head) { if(head == NULL) return NULL; if(head->next == NULL) return head; ListNode dummyHead(0); dummyHead.next = NULL; ListNode *p1 = head, *p2 = head->next, *tail = NULL; while(p1 != NULL){ int distance = 0; while(p2 != NULL && p1->val == p2->val){ p2 = p2->next; ++ distance; } if(distance == 0){ if(dummyHead.next == NULL){ dummyHead.next = p1; tail = p1; tail->next = NULL; }else{ tail->next = p1; tail = tail->next; tail->next = NULL; } p1 = p2; if(p2 != NULL) p2 = p2->next; }else{ p1 = p2; if(p2 != NULL) p2 = p2->next; } } return dummyHead.next; }
ListNode* reverseBetween(ListNode* head, int m, int n) { if (m == n) { return head; } ListNode dummyHead(-1); dummyHead.next = head; ListNode *curNode = &dummyHead; int count = 1; while (count < m) { curNode = curNode->next; count++; } ListNode tempHead(-1); for (int curInd = m; curInd <= n; curInd++) { ListNode *tempNode = curNode->next; curNode->next = curNode->next->next; tempNode->next = tempHead.next; tempHead.next = tempNode; } ListNode *curTemp = tempHead.next; while (curTemp->next != NULL) { curTemp = curTemp->next; } curTemp->next = curNode->next; curNode->next = tempHead.next; return dummyHead.next; }