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;
    }

在这里插入图片描述

总结

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

您可能感兴趣的文章:

C++ 约瑟夫环的实例代码
这篇文章主要介绍了C++ 约瑟夫环的实例代码的相关资料,希望通过本文能帮助到大家，实现这样的功能，需要的朋友可以参考下
2017-10-10
基于C++编写一个密码系统
这篇文章主要为大家详细介绍了如何基于C++编写一个简单的密码系统,文中的示例代码讲解详细,具有一定的借鉴价值,感兴趣的小伙伴可以跟随小编一起学习一下
2023-11-11
简单介绍C++编程中派生类的析构函数
这篇文章主要介绍了C++编程中派生类的析构函数,析构函数平时一般使用较少,需要的朋友可以参考下
2015-09-09
VC对自定义资源加密解密(AES)的详解
本篇文章是对VC对自定义资源加密解密(AES)进行了详细的分析介绍，需要的朋友参考下
2013-06-06
浅析C语言调试器GDB和LLDB的使用方法
这篇文章主要介绍了C语言调试器GDB和LLDB的使用方法，本文给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下
2019-12-12
C语言每日练习之选择排序
本篇文章主要介绍了 C语言的选择排序,这里提供代码实例以便大家理解,通过本文,更好的理解排序算法
2021-11-11
C++读取文本文件中的汉字乱码情况原因及解决
本文介绍简体中文Windows操作系统中,C++读取文本文件中的汉字乱码情况原因及解决,文中通过代码和图文给大家介绍的非常详细,具有一定的参考价值,需要的朋友可以参考下
2024-01-01
c++中的内联函数inline用法实例
在本篇文章里小编给大家整理的是关于c++中的内联函数inline用法实例以及相关知识点，有需要的朋友们学习下。
2019-09-09
C++中用new创建二维数组和指针数组实例代码
这篇文章主要介绍了C++中用new创建二维数组和指针数组实例代码，非常不错，具有参考借鉴价值，需要的朋友参考下
2017-03-03
C++超详细讲解标准库
C++强大的功能来源于其丰富的类库及库函数资源。C++标准库（C++ Standard Library, 亦可称作，C++标准程序库）的内容总共在50个标准头文件中定义。在C++开发中，要尽可能地利用标准库完成
2022-06-06