1.链表相加（二）

最直观的思路就是直接走到末尾，然后按照进位规则写，但是走到最后怎么找到前一个？前一个的前一个？

所以先反转，然后按位相加(详见图） 

#include 
class Solution {
public:/**** @param head1 ListNode类* @param head2 ListNode类* @return ListNode类*/ListNode* reverse(ListNode* head) //反转，之前做过{if (!head) return nullptr;ListNode* pre = nullptr, * cur = head, * tmp;while (cur){tmp = cur->next;cur->next = pre;pre = cur;cur = tmp;}return pre;}ListNode* addInList(ListNode* head1, ListNode* head2) {// write code hereListNode* p1 = reverse(head1); //记录反转之后的头结点ListNode* p2 = reverse(head2);//记录反转之后的头结点ListNode* benwei, * jinwei; //本位是指 例如 21 的1，进位是2int add1 = 0, add2 = 0;  //这两个存储每个节点的val，因为可能节点为空，所以用一个值记录一下，空就是0benwei = new ListNode(0);  //首先new一个本位节点，他要和add1，add2加在一起算结果while (p1 || p2)  //两个都为空遍历结束{add1 = p1 != nullptr ? p1->val : 0; //保存第一个链表的每个节点值add2 = p2 != nullptr ? p2->val : 0; //保存第二个链表的每个节点值int result = add1 + add2 + benwei->val; //总结果加和，上面例子对应21benwei->val = result % 10; //本位是21的1（取模）if (result >= 10) //如果总结果比10大于等于，需要进位jinwei = new ListNode(1); //进位肯定进1，因为每个节点的值<10，加在一起<20elsejinwei = new ListNode(0); //不需要进位直接设为0jinwei->next = benwei; //进位的下一个节点是本位，2->1benwei = jinwei; //本位变成链表头，即2，第一次相加后本位2->1if (p1) p1 = p1->next; //如果p1不是空，那么后移if (p2) p2 = p2->next; //如果p2不是空，那么后移;}return benwei->val!=0 ? benwei : benwei->next; //本位是链表头，如果链表头是0，从下一位开始}
};

2.单链表的排序

首先可以把每个节点的值都存到vector，然后对vector排序，最后从头结点往后，每个节点的值改成vector里面的对应数字

ListNode* sortInList(ListNode* head) {// write code hereif(!head || !head->next) return head;ListNode* p=head;vector v;while(p){v.push_back(p->val);p=p->next;}sort(v.begin(),v.end());p=head;for(auto it:v){p->val=it;p=p->next;}return head;}
};

3.判断一个链表是不是回文

简单的，详见图

#include 
#include 
class Solution {
public:/**** @param head ListNode类 the head* @return bool布尔型*/bool isPail(ListNode* head) {// 还是先vector保存数据if (!head || !head->next) return true;vector v;ListNode* p = head;while (p){v.push_back(p->val);p = p->next;}vector::iterator a = v.begin(); //一个头迭代器vector::reverse_iterator r = v.rbegin(); //一个反向迭代器for (; a != v.end() && r != v.rend(); a++, r++) //当两个迭代器都没走到末尾{if (*a != *r) //有不等的就不是回文，回文对称位置一定相等return false;}return true;}
};

4.链表的奇偶重排

其实也可以用上面的思路也是可以做的，vector保存数字，然后从v中遍历，分别走奇数位和偶数位，然后写回链表里

class Solution {
public:/*** 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可*** @param head ListNode类* @return ListNode类*/ListNode* oddEvenList(ListNode* head) {// write code hereif (!head || !head->next) return head;vector v;ListNode* p = head;while (p){v.push_back(p->val);p = p->next;}p = head;vector::iterator it = v.begin();for (; it != v.end(); it += 2){if (p){p->val = *it;p =->next;}}it = v.begin() + 1;for (; it != v.end(); it += 2){if (p){p->val = *it;p = p->next;}}return head;}};

 但是这个方法太慢了

有更简洁的，找到第一个奇数位和第一个偶数位，直接奇数位跳到奇数位，偶数位跳到偶数位

然后把最后一个奇数位的next指向第一个偶数位（head->next）

class Solution {
public:/*** 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可** * @param head ListNode类 * @return ListNode类*/ListNode* oddEvenList(ListNode* head) {// write code hereif(!head || !head->next) return head;ListNode*h1=head->next;ListNode* even=head,*odd=head->next;while(even->next && odd->next){even->next=even->next->next;even=even->next;odd->next=odd->next->next;odd=odd->next;}even->next=h1;return head;
}
};

5.删除有序链表中重复的元素-I

肯定先考虑如果把空链表或者只一个节点，直接返回

否则，从头开始遍历

如果遇到p->val==p->next->val直接换指向 

但是这时候p不要后移，万一有2个以上重复的节点会删不干净

比如111，换指向之后移动就是11，但是结果是1

 ListNode* deleteDuplicates(ListNode* head) {// write code hereif(!head || !head->next) return head;ListNode* p=head;while(p){if(p->next&&p->val==p->next->val){ListNode* tmp=p->next;p->next=p->next->next;delete tmp;}elsep=p->next;}return head;}
};