算法篇之链表操作

目的

主要是积累算法篇关于链表操作，我们都知道链表有单向链表， 双向链表， 环形链表等各种形式。但是这博客主要是积累相关链表操作。
如下说到的ListNode定义如下

typedef struct Node
{
	int val;
	ListNode* next;
	ListNode(int x)
	{
		val = x;
		next = nullptr;
	}
}ListNode;

反向输出链表

常用两种方法：

1. 就地反转法
   在于不通过申请新的链表， 基于原链表实现就地反转， 需要多申请链表指针， 但是空间与时间上都是较优的。

ListNode* reverseListOfHeadNodeInsertMethod(ListNode* head)
{
	ListNode* newHead = new ListNode(-1);
	ListNode* pCur = head;
	while(pCur)
	{
		ListNode* pNext = pCur->next;
		pCur->next = newHead->next;
		newHead->next = pCur;
		pCur = pNext;
	}
	return newHead->next;
}

2. 头结点插入法
   通过申请新的链表头结点， 基于头结点与上一个插入节点之间插入新的节点·。

ListNode* reverseListOfHeadNodeInsertMethod(ListNode* head)
{
	ListNode* newHead = new ListNode(-1);
	ListNode* pCur = head;
	while(pCur)
	{
		ListNode* pNext = pCur->next;
		pCur->next = newHead->next;
		newHead->next = pCur;
		pCur = pNext;
	}
	return newHead->next;
}

参考博客

两两反转 （相邻节点反转）

相邻元素实现反转

ListNode* swapPairs(ListNode* head)
{
     if(NULL ==head || NULL == head->next)
     {
           retrun head;
      }
     ListNode* ret = head->next;
     ListNode* behind = NULL;
     while(head->next)
     {
            ListNode* headNext= head->next;
            if(behind && behind->next)
           { 
               behind->next = headNext;
           }
           ListNode* pNext = head->next->next;
           if(pNext)
           {
                head->next = pNext;
            }
          else{
              head->next = NULL;
           }
          headNext->next = head;
          behind = head;
          if(head->next)
         {
             head = pNext;
         } 
     }
      return ret;
}