链表及相关常见问题

最新推荐文章于 2022-07-13 17:51:51 发布
最新推荐文章于 2022-07-13 17:51:51 发布
阅读量993 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43478694/article/details/124458303
版权

文章目录

1. 单向链表

1.1 节点定义

package linkedlist;

public class ListNode {
    private int data;
    private ListNode next;
    public int getData() {
        return data;
    }
    public void setData(int data) {
        this.data = data;
    }
    public ListNode getNext() {
        return next;
    }
    public void setNext(ListNode next) {
        this.next = next;
    }
    public ListNode(int data) {
        this.data = data;
    }
    public ListNode() {
       
    }
}

1.2 单向链表操作

package linkedlist;

public class MyLinkedList {

    private ListNode head=null;
    private int sz=0;//节点数量
    public MyLinkedList(){
        head=new ListNode();//添加的头节点（哑节点） 不包含数据 方便操作
    }
   
    //在位置pos上插入节点
    public void insertInLinkedList(ListNode newNode,int pos){
        if(pos>sz+1||pos<1)//合法的插入位置[1,sz+1]
        {
            System.out.println("插入位置错误");
            return;
        }
        ListNode pre=head;
        int cnt=1;
        while(cnt<pos){
            pre=pre.getNext();//找到待插入位置前一个位置
            cnt++;
        }
        //比如pos=1 相当于在头节点位置插入
        ListNode next=pre.getNext();
        pre.setNext(newNode);
        newNode.setNext(next);
        sz++;
        
    }
    //删除pos位置上的节点
    public void deletetInLinkedList(int pos){
        if(pos>sz||pos<1)//合法的删除位置[1,sz]
        {
            System.out.println("删除位置错误");
            return;
        }
        int cnt=1;
        ListNode pre=head;
        while(cnt<pos){
            pre=pre.getNext();//找到待删除位置上一个位置
            cnt++;
        }
        ListNode del=pre.getNext();
        pre.setNext(del.getNext());
        del.setNext(null);
        sz--;

    }
    public void print(){
        if(sz==0){
            System.out.println("链表为空");
            return;
        }
        ListNode cur=head.getNext();
        while(cur!=null){
            System.out.print(cur.getData()+"->");
            cur=cur.getNext();
        }
        System.out.println();
    }
    public int getSize(){
        return sz;
    }
    //清空链表
    public void clear(){
        ListNode cur=head.getNext(),tmp;
        while(cur!=null){
            tmp=cur.getNext();
            cur.setNext(null);
            cur=tmp;
        }
        head.setNext(null);
        sz=0;
    }
    public static void main(String[] args) {
        MyLinkedList list=new MyLinkedList();
        ListNode node1=new ListNode(1);
        ListNode node2=new ListNode(2);
        ListNode node3=new ListNode(3);
        ListNode node4=new ListNode(4);
        list.insertInLinkedList(node1,1);
        list.insertInLinkedList(node2,2);
        list.insertInLinkedList(node3,3);
        list.insertInLinkedList(node4,4);
        list.print();
        list.deletetInLinkedList(2);
        list.print();
        list.deletetInLinkedList(1);
        list.print();
        list.clear();
        list.print();
    }
}

2. 双向链表

2.1 节点定义

package linkedlist;
public class DLLNode{
    private int data;
    private DLLNode pre;
    private DLLNode next;
    public int getData() {
        return data;
    }
    public void setData(int data) {
        this.data = data;
    }
    public DLLNode getPre() {
        return pre;
    }
    public void setPre(DLLNode pre) {
        this.pre = pre;
    }
    public DLLNode getNext() {
        return next;
    }
    public void setNext(DLLNode next) {
        this.next = next;
    }
    public DLLNode(int data) {
        this.data = data;
    }
    public DLLNode() {
    }
}

2.2 双向链表操作

package linkedlist;

public class MyDDLLinkedList {
    private DLLNode head;
    int sz;
    public MyDDLLinkedList(){
        head=new DLLNode();//创建dummy节点
        sz=0;
    }
    //在pos位置上插入一个新节点
    public void insert(DLLNode newNode,int pos){
        if(pos<1||pos>sz+1){
            System.out.println("插入位置不合法");
            return;
        }
        int cnt=1;
        DLLNode pre=head;
        while(cnt<pos){
            cnt++;
            pre=pre.getNext();//找到待插入位置的上一个位置
        }
        DLLNode next=pre.getNext();
        pre.setNext(newNode);
        newNode.setNext(next);
        newNode.setPre(pre);
        if(next!=null)//如果插入的是最后一个位置 pre刚开始就是指向最后一个节点
            next.setPre(newNode);//加入判断 防止next为null出现空指针异常
        sz++;
    }
    //删除pos位置上的节点
    public void delete(int pos){
        if(pos<1||pos>sz){
            System.out.println("删除位置不合法");
            return;
        }
        int cnt=1;
        DLLNode pre=head;
        while(cnt<pos){
            cnt++;
            pre=pre.getNext();//找到待删除位置的上一个位置
        }
        DLLNode cur=pre.getNext();//cur指向待删除节点
        DLLNode next=cur.getNext();//next指向待删除节点的下一个节点
        pre.setNext(next);
        if(next!=null)
            next.setPre(pre);
        cur.setPre(null);
        cur.setNext(null);
        cur=null;
        sz--;

    }
    //顺序打印
    public void print(){
        if(sz==0){
            System.out.println("链表为空");
            return;
        }
        DLLNode cur=head.getNext();
        while(cur!=null){
            System.out.print(cur.getData()+"->");
            cur=cur.getNext();
        }
        System.out.println();
    }
    //逆序打印
    public void printReverse(){
        if(sz==0){
            System.out.println("链表为空");
            return;
        }
        int cnt=1;
        DLLNode cur=head.getNext();
        while(cnt<sz){
            cur=cur.getNext();
            cnt++;
        }
       
        cnt=1;
        while(cur!=head){
            System.out.print(cur.getData()+"->");
            cur=cur.getPre();
           
        }
           
        System.out.println();
    }
    public static void main(String[] args) {
        MyDDLLinkedList list=new MyDDLLinkedList();
        DLLNode node1=new DLLNode(1);
        DLLNode node2=new DLLNode(2);
        DLLNode node3=new DLLNode(3);
        DLLNode node4=new DLLNode(4);
        list.insert(node1,1);
        list.insert(node2,2);
        list.insert(node3,3);
        list.insert(node4,4);
        list.print();
        list.printReverse();
        list.delete(2);
        list.print();
        list.printReverse();
        list.delete(1);
        list.print();
        list.printReverse();
       
       
    }
}

3. 循环链表

在单链表的基础上使得最后一个节点的指向不是null, 而是指向第一个节点

package linkedlist;

public class MyCircualList {
    private ListNode head=null;
    private ListNode tail;//指向尾结点
    private int sz=0;//节点数量
    public MyCircualList(){
        head=new ListNode();//添加的头节点（哑节点） 不包含数据 方便操作
    }
   
    //在位置pos上插入节点
    public void insertInLinkedList(ListNode newNode,int pos){
        if(pos>sz+1||pos<1)//合法的插入位置[1,sz+1]
        {
            System.out.println("插入位置错误");
            return;
        }
        ListNode pre=head;
        int cnt=1;
        while(cnt<pos){
            pre=pre.getNext();//找到待插入位置前一个位置
            cnt++;
        }
        //比如pos=1 相当于在头节点位置插入
        ListNode next=pre.getNext();
        pre.setNext(newNode);
        tail=newNode;
        tail.setNext(head.getNext());//最后一个节点指向头节点
        sz++;
        
    }
    //删除第pos个节点
    public void deletetInLinkedList(int pos){
        if(pos>sz||pos<1)//合法的删除位置[1,sz]
        {
            System.out.println("删除位置错误");
            return;
        }
        int cnt=1;
        ListNode pre=head;
        while(cnt<pos){
            pre=pre.getNext();//找到待删除位置上一个位置
            cnt++;
        }
        ListNode del=pre.getNext();
        pre.setNext(del.getNext());
        if(pos==1&&tail!=del){//删除的是第一个节点 并且链表中不止有1个节点
            tail.setNext(del.getNext());//修改尾结点指向
        }
        if(pos==sz)//删除的是表中的最后一个节点
            tail=null;
        
        del.setNext(null);
        sz--;

    }
    //从链表的第pos个节点开始遍历
    public void print(int pos){
        if(sz==0){
            System.out.println("链表为空");
            return;
        }
        if(pos<1||pos>sz){
            System.out.println("遍历开始位置错误");
            return;
        }
        ListNode cur=head.getNext();
        int cnt=1;
        while(cnt<pos){
            cur=cur.getNext();//找到第pos个节点
            cnt++;
        }
        cnt=1;
        while(cnt<=sz){
            System.out.print(cur.getData()+"->");
            cur=cur.getNext();
            cnt++;
        }
        System.out.println();
    }
    public int getSize(){
        return sz;
    }
    public void clear(){
        ListNode cur=head.getNext(),tmp;
        while(cur!=null){
            tmp=cur.getNext();
            cur.setNext(null);
            cur=tmp;
        }
        head.setNext(null);
        sz=0;
    }
    public static void main(String[] args) {
        MyCircualList list=new MyCircualList();
        ListNode node1=new ListNode(1);
        ListNode node2=new ListNode(2);
        ListNode node3=new ListNode(3);
        ListNode node4=new ListNode(4);
        list.insertInLinkedList(node1,1);
        list.insertInLinkedList(node2,2);
        list.insertInLinkedList(node3,3);
        list.insertInLinkedList(node4,4);
        list.print(1);
        list.print(2);
        list.deletetInLinkedList(2);
        list.print(1);
        list.print(2);
        list.deletetInLinkedList(1);
        list.print(1);
        list.print(2);
        list.clear();
        list.print(2);
    }
}

4. 链表常见问题

4.1 找到链表的倒数第n个节点

快慢指针 快指针先走n步 然后快慢指针一起走 这样当快指针变成null时 慢指针就指向倒数第n个节点

  public ListNode findRevNthNode(int n){
        ListNode slow=head.getNext(),fast=head.getNext();//slow和fast指向头节点
        for(int i=1;i<=n;i++)
            fast=fast.getNext();
        while(fast!=null){
            fast=fast.getNext();
            slow=slow.getNext();
        }
        return slow;
    }

4.2 判断链表是否有环

快慢指针 快指针每次走两步 慢指针每次走一步 如果二者最终相遇说明存在环 否则不存在

 public static boolean hasCircle(ListNode head){
        ListNode slow=head,fast=head;//slow和fast指向头节点
        while(slow!=null&&fast.getNext()!=null){
            slow=slow.getNext();
            fast=fast.getNext().getNext();
            if(slow==null||fast==null)
                return false;
            if(slow==fast)
                return true;
        }
        return false;
    }

4.3 如果链表有环，求出环的入环点

当链表有环时，根据4.2的算法，快慢指针会相遇，相遇之后，使其中一个指针从head头节点重新开始走，此时快慢指针速度一样，二者再次相遇的地方就是入环点

在这里插入图片描述

证明：快指针的速度是慢指针的2倍，当相遇时，假设慢指针走了k步，则快指针走了2k步，由于二者最后位置相同，所以快指针多走的k步实际上就环的长度的整数倍（类似于操场跑步，可能多跑了1圈，也可能多跑了2圈）；假设入环点到相遇点的距离是m,则起点到入环点的距离是k-m, 而从相遇点再走到入环点的距离也是k-m, 因此相遇后，让一个节点从起点开始走，一个节点从相遇点开始走，此时速度一样，则再次相遇时，相遇点就是入环点

public ListNode detectCycle(ListNode head) {
        if(head==null)
            return null;
        ListNode fast=head,slow=head;
        boolean hasCircle=false;
        while(fast!=null&&fast.next!=null){
            fast=fast.next.next;
            slow=slow.next;
            if(fast==null||slow==null){//等于null说明没有环
                return null;
            }
            if(fast==slow){//存在环 退出循环开始后面找环的入口
                hasCircle=true;
                break;
            }
        }
        if(!hasCircle)
            return null;
        fast=head;//一个指向头节点
        while(fast!=slow){//再次相遇的地方就是入环口
            fast=fast.next;
            slow=slow.next;   
        }
        return fast;

4.4 如果有环，求出环的长度

根据4.3中的图，当快慢指针相遇时，慢指针不动（我在原位置等你），然后快指针没次一个步长移动，当快指针再次走到相遇的位置时，运动的步数即是环的长度

 public int getCycleLength(ListNode head) {
        if(head==null)
            return 0;
        ListNode fast=head,slow=head;
        boolean hasCircle=false;
        while(fast!=null&&fast.getNext()!=null){
            fast=fast.getNext().getNext();
            slow=slow.getNext();
            if(fast==null||slow==null){//等于null说明没有环
                break;
            }
            if(fast==slow){//存在环 退出循环开始后面找环的入口
                hasCircle=true;
                break;
            }
        }
        if(!hasCircle)
            return 0;
        int cnt=1;
        fast=fast.getNext();
        while(fast!=slow){
            fast=fast.getNext();
            cnt++;
        }
        return cnt;
    }

4.5 在有序列表中插入一个节点，使得链表依然有序

//升序为例
    public static ListNode insertInSortedList(ListNode head,ListNode newNode){
        if(head==null)
            return newNode;
        ListNode cur=head,pre=null;
        while(cur!=null&&cur.getData()<newNode.getData()){
            pre=cur;
            cur=cur.getNext();
        }
        if(pre==null){//新节点值最小 那么直接在作为新的头节点
            newNode.setNext(head);
            return newNode;
        }
        ListNode next=pre.getNext();
        pre.setNext(newNode);
        newNode.setNext(next);
        return head;
        
    }

4.6 逆置单链表

public static ListNode reverse(ListNode head){
        ListNode pre=null,next=null;
        ListNode cur=head;
        while(cur!=null){
            next=cur.getNext();
            cur.setNext(pre);
            pre=cur;
            cur=next;
        }
        return pre;
    }

4.7 求出两条链表的相交节点

image-20220427105732106

先使用两个指针pA pB分别指向headA headB 当pA!=pB时 如果A链表没有遍历完，pA往后走一步，如果A遍历完了，就让pA指向headB, 从B链表的头部开始移动； 对于headB同理

在这里插入图片描述

证明：

pA走到公共节点时走过的路程： a+(b-c)

pB走到公共节点时走过的路程： b+(a-c)

a+(b-c)= b+(a-c) 因此该距离内就能相遇 当两条链表没有公共部分时，c=0, 即走过的路程为a+b, 也就是pA pB都遍历了两条链表，最后都指向null, 此时pA也等于pB , 没有交点时返回null

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

4.8 找到链表的中间节点

快慢指针 快指针的速度是慢指针的两倍

链表节点数为奇数： 起始：fast=slow=head 当fast到达最后一个节点时(fast.next==null) slow达到中间节点

链表节点数为偶数fast=slow=head 当fast到达倒数第二节点时(fast.next.next==null) slow达到中间节点

为了统一者两种情况，将节点进行0-n-1编号 偶数节点时只移到快指针 奇数节点时两个指针都移到 当快指针达到最好一个节点时 慢指针达到中间节点（奇数是最中间 偶数的中间偏左）

 public static ListNode findMiddle(ListNode head){
        if(head==null)
            return null;
        ListNode fast=head,slow=head;
        int i=0;
        while(fast.getNext()!=null){
            if(i%2==0){
                fast=fast.getNext();
            }else{
                fast=fast.getNext();
                slow=slow.getNext();
            }
            i++;
        }
        return slow;
    }

4.9 逆序打印链表

采用递归做法

 public static void printRev(ListNode head){
        if(head==null)
            return;
        printRev(head.getNext());
        System.out.println(head.getData());
    }

4.10 判断链表长度是奇数还是偶数

一个指针从头节点开始，每次走两步，如果最后指向null,说明偶数，如果最后指向最后一个节点，说明奇数

public static int evenOrOdd(ListNode head){
        ListNode p=head;
        while(p!=null&&p.getNext()!=null){
            p=p.getNext().getNext();
        }
        if(p==null)
            return 0;//偶数个节点
        else
            return 1;//奇数个节点
    }

4.11 将两个有序链表合并为一个有序链表

public ListNode mergeTwoSortedList(ListNode headA,ListNode headB){
        ListNode dummy=new ListNode();//创建一个哑节点 方便操作
        ListNode cur=dummy;
        while(headA!=null&&headB!=null)
        {
            if(headA.getData()<headB.getData()){//找小的
                cur.setNext(headA);
                headA=headA.getNext();
            }
            else{
                cur.setNext(headB);
                headB=headB.getNext();
            }
            cur=cur.getNext();
        }
        if(headA!=null)//链表A还有剩余 直接加上
            cur.setNext(headA);
        if(headB!=null)
            cur.setNext(headB);
        return dummy.getNext();
    }

4.12 逐对交换链表节点

image-20220427175536440

//递归
 public ListNode swapPairs(ListNode head) {
       if(head==null||head.next==null)//链表为空或者只有1个节点
            return head;
        ListNode newHead=head.next;//新的头节点是节点2
        head.next=swapPairs(newHead.next);//节点1指向后面n-2个节点完成反转后的头节点
        newHead.next=head;//新的头节点的连接节点1
        return newHead;
    }

//迭代
 public ListNode swapPairs(ListNode head) {
       if(head==null||head.next==null)//链表为空或者只有1个节点
            return head;
        ListNode dummy=new ListNode();
        dummy.next=head;
        ListNode tmp=dummy;
        while(tmp.next!=null&&tmp.next.next!=null){//有2个节点
            ListNode node1=tmp.next;//指向第1个节点
            ListNode node2=tmp.next.next;//指向第2个节点
            tmp.next=node2;//第2个节点作为头节点
            node1.next=node2.next;//第1个节点指向第3个节点
            node2.next=node1;//第2个节点指向第一个节点
            tmp=node1;//tmp往后移动一个节点
        }
        return dummy.next;
    }

4.13 K个一组逆置链表

k=2 1->2->3->4->5 变成 2->1->4->3->5

k=3 1->2->3->4->5 变成 3->2->1->4->5

不足k个的不反转

public ListNode reverseKGroup(ListNode head, int k) {
         if(k==0||k==1)//0个1组或1个一组相当于不用反转
            return head;
        ListNode cur=head;
        ListNode newHead=null;
        if(hasKNodes(cur,k))//链表长度>=k
            newHead=getKthNode(cur,k);
        else //链表长度<k 相当于不用反转
            return head;
        ListNode pre=null,tmp;
        while(cur!=null&&hasKNodes(cur, k)){
            int i=0;
            ListNode last=cur;//last保存当前组的第一个节点 反转之后last就是最后1个节点
            while(i<k){//逆置某一组  和单链表的反转代码类似
                tmp=cur.next;
                cur.next=pre;
                pre=cur;
                cur=tmp;
                i++;
            }
            last.next=getKthNode(cur,k);//逆置完后该组原来的第一个节点变成最后一个
            //最后一个节点连接下一组的第k个节点（下一组有k个则和第k个连接  不足就跟第一个节点连接）
            
        }
        return newHead;
    }
    //获取从cur开始往后数的第k个节点
    public ListNode getKthNode(ListNode cur,int k){
        if(cur==null)
            return null;
        int i=1;
        ListNode p=cur,pre=p;
        while(p!=null&&i<k){
            pre=p;
            p=p.next;
            i++;
        }
        return p==null?cur:p;//有k个则返回改组第k个节点  不足k个则返回改组第一个节点
    }
    //以cur节点开始是否还有k个节点？
    public boolean hasKNodes(ListNode cur,int k){
        int i=0;
        while(cur!=null){
            i++;
            if(i==k)
                break;
            cur=cur.next;
        }
        return i==k;
    }

4.13 约瑟夫环问题

N个人围成一圈，编号为1-N， 从某个人开始从1报数，报到M的人出局，然后从下一个人开始从1报数，直到只剩下一个人

 public static ListNode getJosephusPosition(int N,int M,ListNode head){
        //head是一个环形链表中的某个节点
        ListNode p=head;
        for(int cnt=N;cnt>1;cnt--){
            for(int i=2;i<=M-1;i++){//找到待删除节点上一个节点  一开始p就指向某个节点（报数1） 因此只需要从2开始报数
                p=p.getNext();
            }
            //前面报数了M-1次 p指向待删除节点的上一个节点
            p.setNext(p.getNext().getNext());
            p=p.getNext();//从待删除的人的下一个人开始报数
        }
        return p;
    }

4.14 复制带随机指针的链表

image-20220427185213891

先根据已有节点的值创建一个具有相同值的节点，建立原有节点和新节点的映射，先不考虑next和random指针

创建完映射之后，对于原始节点X，对应的新创建的节点Y=map.get(X) Y.next就是map.get(X.next) Y.random就是map.get(X.random) X.next和X.random都是指向原有的节点，原有的节点是map中的键，因此都对应一个新创建的节点

	HashMap<Node,Node> map;
    public Node copyRandomList(Node head) {
        map=new HashMap<>();
        Node cur=head;
        while(cur!=null){
            map.put(cur,new Node(cur.val));
            cur=cur.next;
        }
        cur=head;
        while(cur!=null){
            Node cloneNode=map.get(cur);
            cloneNode.next=map.get(cur.next);
            cloneNode.random=map.get(cur.random);
            cur=cur.next;
        }
        return map.get(head);
    }
CodePanda@GPF
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构中链表及常见操作.pdf
04-01
。
Chapter8——链表的常见问题
多反思，多回顾，要坚持。
02-02 1333
写在前面     这一章对于一些有一定算法经验或者一定编程基础的同学来说，是比较容易的。但是，回顾自己当时学这一章的时候，确实是走了不少的弯路，因此自己写这一章的目的，旨在记录链表的一些常见问题以及这些问题的分析思路和解决方案。 一、链表的一些易混淆概念 1.头指针 or 头结点 or 首结点？     初学数据结构时，我对这几个概念也是分不清楚，所以开门见山，首先梳理这三个概
编写链表代码时容易出现的错误
weixin_61333208的博客
07-13 1477
编写链表是在创建链表函数中出现写入访问权限冲突， p 是 nullptr的问题；在输出函数中出现最后个单元未输出的问题的解决方法
链表常见问题总结
qq_39471489的博客
03-08 793
0. 单向链表如何找到倒数n个节点 一种容易想到的方法是，我们首先从头节点开始对链表进行一次遍历，得到链表的长度 LL。随后我们再从头节点开始对链表进行一次遍历，当遍历到第 L-n+1L−n+1 个节点时，它就是我们需要删除的节点。 为了与题目中的 nn 保持一致，节点的编号从 11 开始，头节点为编号 11 的节点。 为了方便删除操作，我们可以从哑节点开始遍历 L-n+1L−n+1 个节点。当遍历到第 L-n+1L−n+1 个节点时，它的下一个节点就是我们需要删除的节点，这样我们只需要修改一次指针，就能
链表相关问题
Tzecto
05-05 169
移除链表元素 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 示例 1： 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5] 示例 2： 输入：head = [], val = 1 输出：[] 示例 3： 输入：head = [7,7,7,7], val = 7 输出：[] /** * Definition for singly-linked list. * .
链表操作中易错的小问题
qinyushuang的专栏
12-18 1482
1、错误之一：没有记住链表的头元素       单向链表的头元素必须自始至终记住，否则链表将会在内存中丢失。这意味着在链表第一个元素之前插入新元素和删除链表的第一个元素时，指向链表头的指针或者引用必须更新。如果在一个函数或者一个方法中改变了链表，那么一定要记得更新链表的头指针。下面的一个例子是不正确的。eg：//新增链表的头元素，没有更新链表的头指针 ,错误的示范!! public void insertInFront(ListElement list,object data) { listEle
数据结构中链表及常见操作.docx
04-01
。
合并两个有序链表是一个常见的编程问题.txt
最新发布
04-26
两个有序链表的合并pta
一个C++新建链表时很容易混淆的经典错误
qq_45512097的博客
10-20 219
** 1.错误： ** 在作者刷题时，遇到了一个情况，需要用到两个链表去完成一个操作：用first指针储存链表p的首元素的地址，用于做return（函数返回链表首地址），在这个过程中，p在不断的扩展，接收新元素。 以下是错误代码： ListNode *mergeTwoLists(ListNode * l1, ListNode * l2) { ListNode *p, *first = new ListNode; int count = 0; do { //此处代码忽略，即p链表扩充的操作，与总结无关
数据结构(C++)--学习单链表时发现的一些小坑
weixin_49687704的博客
10-24 348
基于类的链表类无相应构造函数报错 #include<bits/stdc++.h> using namespace std; const int MaxSize = 10; template <class T> class Seqlist { public: Seqlist() { length = 0;} Seqlist(T [],int); private: int length; T data[MaxSize]; };
#pragma once与 #ifndef的区别
~。~|||
06-27 719
为了避免同一个文件被include多次 1   #ifndef方式 2   #pragma once方式 在能够支持这两种方式的编译器上，二者并没有太大的区别，但是两者仍然还是有一些细微的区别。方式一： #ifndef __SOMEFILE_H__     #define __SOMEFILE_H__     ... ... // 一些声明语句     #endif方式二：#pra
c++链表问题汇总(代码及解析)
祥瑞的技术博客
09-01 1699
目录 一、链表与指针 1.1 单向双向表 1.2 数组指针 1.3 链表的合并 二、链表应用汇总 2.1 链表中的值倒序 2.2 链表的倒数第k个节点 2.3 反转链表 2.4 链表的公共节点 2.5 链表环的入口节点 三、复杂链表的复制 3.1 题干 3.2 思路及注意事项 3.3 正确答案 3.4 错误代码找错 四、二叉树转为双向链表 相应oj链接： htt...
我这个链表程序咋回事呀，怎么输不进去数据呀？
m0_64165260的博客
03-12 1389
#include<stdio.h> #include<stdlib.h> typedef struct link{ int date; struct link *next; }link,*linklist; void print(linklist head) { linklist p=head; while(p !=NULL){ printf("%d ",p->date ); p=p->next ;//让P指向下一...
链表常遇错误记录
肥仔的博客
03-22 902
1.结合数据结构第3次作业的一道题目：文件加密(环)来说一下吧，错误的原因是当环里只剩下两个节点时，比如节点A+节点B，那么用start_c存储B节点的字符，然后把B删掉，环里就只剩下1个节点了，不满足循环继续进行下去的条件了，注意，这时候就有两个字符没有设置密文，所以结束循环后，我们应该设置密文的字符有两个，节点A和节点B的字符。我原来的错误原因是在循环结束后，只设置了节点A的字符的密文，而把B...
链表常见问题
weixin_43817702的博客
02-26 990
链表常见的问题有这几种： 1、链表反转； 2、以一定顺序插入节点； 3、判断回文； 4、循环链表； 5、链表重排； 链表问题的解决方案无非就这几种： 1、双指针，用来删除倒数第几个节点，或者是寻找中间节点，或者是判断是否有环； 2、链表反转； 3、链表合并； ...
链表中常见问题
qq_46897935的博客
04-27 1245
常见的链表题有： 1、翻转单向链表 2、判断一个链表是否是回文结构 3、将单链表按照给定的值划分左边小，中间相等，右边大的形式 4、复制含有随机指针结点的链表 #include<iostream> #include<list> #include<stack> #include<unordered_map> using namespace std; struct ListNode { int val; ListNode *next; ListNode* r
创建单链表中出现的一些经典错误（typedef关键字与指针）
benigh的博客
03-14 1629
本文记录的是本人在单链表学习及实现过程中的个人理解和遇到的一些错误，不严谨之处欢迎批评指正。
链表面试问题总结：
weixin_43934357的博客
07-20 247
**无法高效获取长度，无法根据偏移快速访问元素，是链表的两个劣势。**然而面试的时候经常碰见诸如获取倒数第k个元素，获取中间位置的元素，判断链表是否存在环，判断环的长度等和长度与位置有关的问题。这些问题都可以通过灵活运用双指针来解决。 Tips：双指针并不是固定的公式，而是一种思维方式~ 1.先来看"倒数第k个元素的问题"。设有两个指针 p 和 q，初始时均指向头结点。首先，先让 p 沿着 next 移动 k 次。此时，p 指向第 k+1个结点，q 指向头节点，两个指针的距离为 k 。然后，同时移动 p 和
一、链表及经典问题
qq_43403759的博客
11-13 608
文章目录一、141 环形链表1、思路2、注意细节，起点不一样3、代码二、142 环形链表入口三、202 快乐数四、206 反转链表五、92 反转链表二六、61 旋转链表七、19 删除链表第N个节点八、83 删除排序链表中的重复元素九、82 删除排序链表中的重复元素二十、24 两两交换链表中的节点 一、141 环形链表 1、思路   本方法需要到「Floyd 判圈算法」（又称龟兔赛跑算法）有所了解。   假想「乌龟」和「兔子」在链表上移动，「兔子」跑得快，「乌龟」跑得慢。当「乌龟」和「兔子」从链表上的同一个节
链表求解约瑟夫环问题
05-25
解决该问题的一种常见方式是使用循环链表。具体步骤如下： 1. 创建一个循环链表，将n个人依次加入链表中。 2. 从第一个人开始报数，每报到第m个人就将其从链表中删除。 3. 将被删除的人的编号记录下来，并将其从...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CodePanda@GPF

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值