C++数据结构之链表详解

更新时间：2021年08月16日 11:08:17 作者：caiyec

这篇文章主要介绍了C++数据结构之链表的创建的相关资料,希望通过本文帮助到大家，让大家理解掌握这部分内容，需要的朋友可以参考下

前言

链表类型的习题常用的技巧就是定义指针来代替head的，替head走，要么就是数学问题，环形链表就是利用数学思想取解决的，要么就是定义双指针来操作链表。

一、删除链表中给定值为key的节点

定义两个变量，一个使待删除的节点，一个为待删除节点的前驱节点，最后记得判断头节点是否为要删除的节点，最后返回头节点。

 public ListNode removeElements(ListNode head, int val) {
        if(head==null){
            return null;
        }
        ListNode cur=head.next;
        ListNode prev=head;
        while(cur!=null){
            if(cur.val==val){
                prev.next=cur.next;
            }else{
                prev=cur;
            }
            cur=cur.next;
        }
        if(head.val==val){
            head=head.next;
        }
        return head;
    }

二、反转链表

定义双指针法，类似于头插法，来将链表的节点头插法

cur节点是待反转的节点 curNext是保存下一个节点的地址值

1.先保存待反转节点下一个地址值，之后将头节点的next置空

2.只有用头插法将节点头插即可。

public ListNode reverseList(ListNode head) {
        //三指针法来反转链表
        if(head==null||head.next==null){
            return head;
        }
        ListNode cur=head;//要头插的节点
        ListNode curNext=head.next;//保存下一个节点的地址值
        cur=curNext;
        head.next=null;
        while(cur!=null){
            curNext=curNext.next;
            cur.next=head;
            head=cur;
            cur=curNext;
        }
        return head;
    }

三、返回链表的中间节点

定义快慢指针，注意偶数节点和奇数节点的情况

注意判断条件在偶数情况下如果是判断fast.next.next就会空指针异常，必须把判断条件两个都加上。

public ListNode middleNode(ListNode head) {
        //定义快慢指针 快指针比慢指针多走一步   注意奇数和偶数情况
        if(head==null||head.next==null){
            return head;
        }
        ListNode slow=head;
        ListNode fast=head;
        while(fast!=null&&fast.next!=null){
            fast=fast.next.next;
            slow=slow.next;
        }
        return slow;
    }

四、删除链表的倒数第K个节点

定义快慢指针快指针先走n-1步之后慢指针再走,修改地址值即可

public ListNode removeNthFromEnd(ListNode head, int n) {
        if(head==null){
            return null;
        }
        ListNode fast=head;
        ListNode dummy=new ListNode(0,head);
        ListNode slow=dummy;
        for(int i=1;i<n;i++){
            fast=fast.next;
        }
        while(fast.next!=null){
            fast=fast.next;
            slow=slow.next;
        }
        slow.next=slow.next.next;
        return dummy.next;
    }

五、分割链表

给定X值，分割链表前面链表为小于X的值，后面链表为大于等于X的值
要考虑很多情况

1.第一次插入链表时要将头节点和尾巴节点都指向插入的节点

2.不是第一次插入时，只需要把尾巴节点next值指向插入的节点，之后把尾巴节点往后挪

3.如果前面链表为空，返回后面链表的头

4。还需要将后面节点的next值置空，之后连接两个链表。

 public ListNode partition(ListNode head, int x) {
        //分割链表 将小于x的分为一部分，将大于等于x的分为一部分呢！ 乖乖yy
        if(head==null){
            return null;
        }
        ListNode xh=null;//小于x的头节点
        ListNode xe=null;;//小于x的尾巴节点
        ListNode Xh=null;//大于等于X的头节点
        ListNode Xe=null;//大于等于X的尾节点
        ListNode cur=head;
        while(cur!=null){
            if(cur.val<x){
                //小于X的部分
                if(xh==null){
                    //第一次插入
                    xh=cur;
                    xe=cur;
                }else{
                    //不是第一次插入
                    xe.next=cur;
                    xe=cur;
                }
            }else{
                //>=X 的部分
                if(Xh==null){
                    //第一次插入
                    Xh=cur;
                    Xe=cur;
                }else{
                    //不是第一次插入
                    Xe.next=cur;
                    Xe=cur;
                }
            }
            cur=cur.next;
        }//判断 所有元素都大于x 前面的链表没有数据 要返回后面的链表
         if(xh==null){
            return Xh;
        }
        xe.next=Xh;
        if(Xh!=null){
            //将最后一个元素置为null
            Xe.next=null;
        }
        return xh;
    }

六、合并两个有序链表

和合并有序数组是一样的，链表复杂一些要将后面节点地址先保存，之后定义傀儡节点，按照值小的顺序连接起来

public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
    //1.思路就是先定傀儡节点，将链表穿起来 定义两个变量将后面地址保存起来 之后串糖葫芦一样串起来
    ListNode dummy=new ListNode(-1);
    ListNode head=dummy;//保存傀儡节点
    ListNode cur1=l1;//保存节点后面的地址值
    ListNode cur2=l2;
    while(l1!=null&&l2!=null){
        cur1=l1.next;
        cur2=l2.next;
        if(l1.val<=l2.val){
            dummy.next=l1;
            l1=cur1;
        }else{
            dummy.next=l2;
            l2=cur2;
        }
        dummy=dummy.next;
    }
    if(l1!=null){
        dummy.next=l1;
    }
    if(l2!=null){
        dummy.next=l2;
    }
    return head.next;
    }

七、删除有序链表中重复节点

双指针遇到相等的就跳过，最后要将最后一个节点置为空。

 public ListNode deleteDuplicates(ListNode head) {
        if(head==null){
            return null;
        }
        ListNode prev=head;
        ListNode cur=head.next;
        while(cur!=null){
            if(prev.val==cur.val){
                cur=cur.next;
            }else{
                prev.next=cur;
                prev=cur;
                cur=cur.next;
            }
        }
        prev.next=cur;
        return head;
    }

八、环形链表

先用set判断是否存在空间复杂度为O（N），不太符合题目要求

public boolean hasCycle(ListNode head) {
       HashSet<ListNode> set=new HashSet<>();
       while(head!=null){
           set.add(head);
           head=head.next;
           if(set.contains(head)){
               return true;
           }
       }
       return false;
    }

2.快慢指针数学问题，快指针走两步，慢指针走一步，有环一定相遇，没有环就不会相遇空间复杂度为O(1)

 public boolean hasCycle(ListNode head) {
      //快慢指针还是数学问题
      if(head==null||head.next==null){
          return false;
      }  
      ListNode slow=head;
      ListNode fast=head.next;
      while(slow!=fast){
          if(fast==null||fast.next==null){
              return false;
          }
          fast=fast.next.next;
          slow=slow.next;
      }
      return true;
    }

九、相交链表

1.先利用set存储节点之后循环判断，空间复杂度为O（N）时间复杂度为O（N），比较慢

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        HashSet<ListNode>set=new HashSet<>();
        while(headA!=null){
            set.add(headA);
            headA=headA.next;
        }
        while(headB!=null){
            if(set.contains(headB)){
                return headB;
            }
            headB=headB.next;
        }
        return null;
    }

2.双指针，确实没想出来，看了题解才知道是两个链表相连接，遍历是否有想交的节点

 public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
      ListNode cur1=headA;
      ListNode cur2=headB;
      while(cur1!=cur2){
        cur1=cur1==null?headB:cur1.next;
        cur2=cur2==null?headA:cur2.next;
      }
       return cur1;
    }

十、两数相加

这道题没什么技巧，就是注意很多特殊情况，加完要判断进位，我第一次敲的时候能执行但是不能过，没有考虑到特殊情况。
最后看评论解答就是用一个进位标志数来解决，学到了。

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode list=new ListNode(-1);
        ListNode head=list;
        int t=0;
        while(l1!=null||l2!=null||t!=0){
            if(l1!=null){
                t+=l1.val;
                l1=l1.next;
            }
            if(l2!=null){
                t+=l2.val;
                l2=l2.next;
            }
            list.next=new ListNode(t%10);
            list=list.next;
            t/=10;
        }
        return head.next;
    }

十一、回文链表

1.可以将链表中值存放在顺序表中，之后定义双指针遍历判断

2.快慢指针带反转

3.利用栈实现li

public boolean isPalindrome(ListNode head) {
        //利用栈来实现回文结构
        Stack<Integer> stack=new Stack<>();
        ListNode cur=head;
        while(cur!=null){
            stack.push(cur.val);
            cur=cur.next;
        }
        ListNode cur1=head;
        while(cur1!=null){
            if(cur1.val!=stack.pop()){
                return false;
            }
            cur1=cur1.next;
        }
        return true;
    }

定义快慢指针，之后反转链表来实现

public boolean isPalindrome(ListNode head) {
        //快慢指针来反转链表
        if(head==null||head.next==null){
            return true;
        }
        ListNode fast=head;
        ListNode slow=head;
        while(fast.next!=null&&fast.next.next!=null){
            fast=fast.next.next;
            slow=slow.next;
        }
        //走到中间节点，反转链表
        slow=reverse(slow.next);
        while(slow!=null){
            if(head.val!=slow.val){
                return false;
            }
            head=head.next;
            slow=slow.next;
        }
        return true;
    }
    public ListNode reverse(ListNode head){
        //反转链表
        ListNode cur=head;
        ListNode curNext=head.next;
        cur=curNext;
        head.next=null;
        while(cur!=null){
            curNext=curNext.next;
            cur.next=head;
            head=cur;
            cur=curNext;
        }
        return head;
    }

在这里插入图片描述

总结

本篇文章就到这里了，希望能给你带来帮助，也希望你能给多多关注脚本之家的更多内容！

您可能感兴趣的文章:

OpenCV实现拼图板小游戏
这篇文章主要为大家详细介绍了OpenCV实现拼图板小游戏，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2019-05-05
解析C语言中位字段内存分配的问题
本篇文章是对C语言中位字段内存分配的问题进行了详细的分析介绍，需要的朋友参考下
2013-05-05
C语言操作符#与##使用方法详解
在类函数宏中（带参数的宏），#号作为一个预处理运算符，可以把记号转换成字符串。##相当于连接符，它会将两边的内容连接起来，形成新的标识符，下面请看详细的教程
2022-04-04
Cocos2d-x触摸事件实例
这篇文章主要介绍了Cocos2d-x触摸事件实例,本文代码中包含大量注释来说明Cocos2d-x中的触摸事件使用示例,需要的朋友可以参考下
2014-09-09
解析C++中派生的概念以及派生类成员的访问属性
这篇文章主要介绍了解析C++中派生的概念以及派生类成员的访问属性,是C++入门学习中的基础知识,需要的朋友可以参考下
2015-09-09
C++实现寻找最低公共父节点的方法
这篇文章主要介绍了C++实现寻找最低公共父节点的方法,是数据结构中二叉树的一个经典算法,有一定的借鉴价值,需要的朋友可以参考下
2014-09-09
浅谈带缓冲I/O 和不带缓冲I/O的区别与联系
下面小编就为大家带来一篇浅谈带缓冲I/O 和不带缓冲I/O的区别与联系。小编觉得挺不错的现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2017-01-01
C++中const的用法详细总结
以下是对C++中const的用法进行了详细的总结分析，需要的朋友可以过来参考下，希望对大家有所帮助
2013-09-09
C++命名空间域的实现示例
命名空间域就是一个独立的空间外面不能直接调用该空间域只能用访问限定符指定访问该空间域,本文主要介绍了C++命名空间域的实现示例,具有一定的参考价值,感兴趣的可以了解一下
2024-01-01
C++基础知识实例解析（一）
这篇文章主要对C++基础知识实例解析，通过四个简短的案例，巩固大家的基础知识，需要的朋友可以参考下
2015-08-08