LeetCode-C++-链表简单题

链表简单题

LeetCode链表的简单题：21、83、141、160、203、206、234、237、876、1290。
题目来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problemset/all/?difficulty=%E7%AE%80%E5%8D%95&topicSlugs=linked-list
程序来源：自己编写

/**
* Definition for singly-linked list.
* struct ListNode {
*     int val;
*     ListNode *next;
*     ListNode() : val(0), next(nullptr) {}
*     ListNode(int x) : val(x), next(nullptr) {}
*     ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/

21.合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4；

class Solution {
public:
   ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) 
   {
       ListNode q=ListNode(-1);
       ListNode *p=&q;
       while(l1&&l2)
       {
           if(l1->val<l2->val)
           {
               p->next=l1;
               l1=l1->next;  
           }
           else
           {
               p->next=l2;
               l2=l2->next;
           }
           p=p->next;  
       }
       p->next=l1?l1:l2;
       return q.next;
   }
};

83.删除排序链表中的重复元素

给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。
输入: 1->1->2
输出: 1->2

class Solution {
public:
   ListNode* deleteDuplicates(ListNode* head) {
       ListNode *p=NULL,*q=NULL;
       if(head==NULL)
           return head;
       p=head;
       while(p->next!=NULL)
       {
           q=p->next;
           if(p->val==q->val)
           {
               p->next=q->next;
           }
           else
               p=p->next;
       }
       return head;
   }
};

141. 环形链表

给定一个链表，判断链表中是否有环。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

class Solution {
public:
   bool hasCycle(ListNode *head) {
       if(head==NULL)
           return false;
       ListNode *slow=head;
       ListNode *fast=head->next;
       while(slow!=fast)
       {
           if(fast==NULL || fast->next==NULL)
               return false;
           slow=slow->next;
           fast=fast->next->next;
       }
       return true;
   }
};

160. 相交链表

编写一个程序，找到两个单链表相交的起始节点。
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 8
输入解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

class Solution {
public:
   ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
       ListNode *pa=headA,*pb=headB;
       while(pa!=pb)
       {
           pa=pa?pa->next:headB;
           pb=pb?pb->next:headA;
       }
       return pa;
   }
};

203. 移除链表元素

删除链表中等于给定值 val 的所有节点。
输入: 1->2->6->3->4->5->6, val = 6
输出: 1->2->3->4->5

class Solution {
public:
   ListNode* removeElements(ListNode* head, int val) {
       ListNode *list=new ListNode(0);
       list->next=head;
       ListNode*p= head,*q=list,*t=NULL;
       while(p!=NULL){
           if(p->val==val){
               t=p;
               p=p->next;
               delete t;
               t=NULL;
           }
           else{
              q->next=p;
              q=q->next;
              p=p->next;
           }
       }
       q->next=NULL;
       return list->next;
   }
};

206. 反转链表

反转一个单链表。
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

class Solution {
public:
   ListNode* reverseList(ListNode* head) {
       ListNode *list = NULL;
       ListNode *p=head;
       ListNode *q=NULL;
       while(p!=NULL)
       {
           q=p->next;
           p->next=list;
           list=p;
           p=q;
           
       }
       return list;
   }
};

234. 回文链表

请判断一个链表是否为回文链表。
输入: 1->2 1->2->2->1
输出: false true

class Solution {
public:
   bool isPalindrome(ListNode* head) {
       vector<int> v;
       ListNode *p = head;
       while(p!=NULL)
       {
           v.push_back(p->val);
           p=p->next;
       }
       for(int i=0;i<v.size()/2;i++)
       {
           if(v[i]!=v[v.size()-1-i])
               return false;
       }
       return true;
   }
};

237. 删除链表中的节点

请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点。传入函数的唯一参数为 要被删除的节点 。
输入：head = [4,5,1,9], node = 5
输出：[4,1,9]
解释：给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.

class Solution {
public:
   void deleteNode(ListNode* node) {
       node->val=node->next->val;
       node->next=node->next->next;
   }
};

876. 链表的中间结点

给定一个带有头结点 head 的非空单链表，返回链表的中间结点。
如果有两个中间结点，则返回第二个中间结点。
输入：[1,2,3,4,5]
输出：此列表中的结点 3 (序列化形式：[3,4,5])

class Solution {
public:
   ListNode* middleNode(ListNode* head) {
       ListNode*p=head;
       ListNode*q=head;
       int t=0;
       while(p!=NULL)
       {
           t++;
           if(t%2==0)
           {
               q=q->next;
           }
           p=p->next;
       }
       return q;
   }
};

1290. 二进制链表转整数

给你一个单链表的引用结点 head。链表中每个结点的值不是 0 就是 1。已知此链表是一个整数数字的二进制表示形式。
请你返回该链表所表示数字的 十进制值 。
输入：head = [1,0,1]
输出：5

class Solution {
public:
   int getDecimalValue(ListNode* head) {
       ListNode*p=head;
       int sum =0;
       while(p->next!=NULL)
       {
           sum =(p->val+sum)*2;
           p=p->next;
       }
       sum+=p->val;
       return sum;
   }
};