链表的一些基本操作

首先理解

比如一个链表是这样的：let aaa = [1, 2, 3, 4]

那么 aaa.val === 1

aaa.next === [2, 3, 4]; aaa.next.val === 2

将vector里的元素一次遍历放到里，构建链表

//当容器存的是结点的时候
vector<ListNode*>a;
 ListNode *head=v[0];//到时候return的时候是head指针
        ListNode *cur=head;//使用cur进行连接操作

for(int i=1;i<v.size();i++){
            cur->next=v[i];//先让链表的结点指向下一个元素 
            cur=cur->next; //再进行移动
        }

//当容器存的是数字的时候
ListNode* p=new ListNode(v[0]);
       ListNode* cur=p;
       for(int i=1;i<v.size();i++){
           cur->next=new ListNode(v[i]);//new创建这个结点
           cur=cur->next;
       }
       return p;

将链表里的元素放到vector中

 while (pHead) {//当没有遍历完
            v.push_back(pHead);//将链表元素放入vector中,vector里面是（listnode *）的元素
            pHead = pHead->next;//放完链表就往下走
        }

正儿八经的代码

        int i=0;
        vector<int>res;
        ListNode* p=head;
        ListNode* p1=head;
        while(p)
        {
            res.push_back(p->val);//将数据取出保存在res数组中
            p=p->next;

待优化的直接用链表进行冒泡排序

for(int i=0;i<count-1;i++){
            p=head;
            q=p->next;//做了i次，每次从head开始 最后将使得满足条件的 在最后一个
            while(q){
                if(p->val>q->val){
                    temp=q->val;
                    q->val=p->val;
                    p->val=temp;
                    
                }p=q;
                if(q->next) q=q->next;//直到q到末尾前 都进行while实现排序
                else break;
              
            }
        }

        }
        sort(res.begin(),res.end());//将数组从小到大排序
        while(p1)
        {
            p1->val=res[i++];//将排序好的数组里面的数据逐个放回链表的对应结点中
            p1=p1->next;
        }
        return head;

删除链表中重复的元素1

while(cur->next)
if (cur->val == cur->next->val) {
                cur->next = cur->next->next;//cur->next到最后一个，也满足这个式子！！
            }

新建一个哑链结点,用于处理头节点变动的

ListNode* dummy = new ListNode(0, head);//值为0，next为head的结点
return dummy->next;

检查是否回文？

放到vector里 在建立一个vector2 在vector进行reverse 之后return vector==vector2的结果

检查是不是相交 建立两个指针分别指向head a和head b，当当遍历完各自的一条链，再遍历另一条链 因为走的结点都a+b+c，所以最后一定会相交！

合并两个升序链表

//找中点传入头结点 返回第二部分头指针 快慢指针找中点 f走两步 s走一步 
ListNode* cut(ListNode* head){
        ListNode* s=head;
        ListNode* f=head->next;
        while(f&&f->next){//fast走完了或者只有是最后一个
            s=s->next;
            f=f->next->next;       }
        ListNode* second=s->next;
        s->next=nullptr;
        return second;
    }
  //归并 传入两个部分的头指针 按找值 小的先放 放完一部分另部分再放
    ListNode* merge(ListNode* head1,ListNode* head2){
        ListNode* dummy=new ListNode();
        ListNode*cur =dummy;
        while(head1!=nullptr&&head2!=nullptr){
                if(head1->val<head2->val)
                {
                    cur->next=head1;
                    head1=head1->next;
                }
                else {
                    cur->next=head2;
                    head2=head2->next;
                }
                cur=cur->next;

        }
        cur->next=(head1==nullptr)? head2:head1;
        ListNode*ret =dummy->next;
        delete dummy;
        dummy=nullptr;
        return ret;

    }
    //主程序 头和分出俩个头 递归两个部分 然后return 归并后的结果 
    ListNode* sortList(ListNode* head) {
        if(!head||!head->next) return head;//没有结点或只有一个
        ListNode*head1=head;
        ListNode*head2=cut(head);//获得第二段的头
        head1=sortList(head1);
        head2=sortList(head2);//递归调用

        
        //调用完了，到了最后一层，就合并
        return merge(head1,head2);
        //一层一层回去 
    
    }  

排序的循环链表

auto cur = head;
        while(cur->next!=head){//一直走一直走然后回到开头就会退出了
            if(cur->val>cur->next->val){//应该升序的 突然降序了说明来到了边界点                 
   
                if(insertVal<=cur->next->val) break;
                //insert比所有的值都小
                 if(insertVal>=cur->val) break;
                //insert比所有的值都大
            }
            if(cur->val<=insertVal&&cur->next->val>=insertVal) {
              break;
            }//包含了数字全部相等的情况
            cur = cur->next;
        }
        cur->next = new Node(insertVal, cur->next);
        return head;