剑指offer-------链表篇

最新推荐文章于 2022-10-12 18:02:33 发布
最新推荐文章于 2022-10-12 18:02:33 发布
阅读量252 收藏 1
点赞数
分类专栏： LeetCode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42072280/article/details/104955298
版权

面试题06.从尾到头打印链表

在这里插入图片描述

安安思路：正向遍历链表，反转列表

#python 其实可以直接用head 不用p

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reversePrint(self, head: ListNode) -> List[int]:
        list1 = []
        p = head
        while(p):
            #print(p.val)
            list1.append(p.val)
            p = p.next
        return list1[::-1]

//java

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] reversePrint(ListNode head) {
        ListNode p = head;
        int count = 0;
        while(p != null){
            //System.out.println(p.val);
            count++;
            p = p.next;
        }

        int[] array = new int[count];
        p = head;
        while(p != null){
            array[--count] = p.val;
            p = p.next;
        }
        return array;
    }
}

官方题解：栈 和自己的类似

在这里插入图片描述

//java

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] reversePrint(ListNode head) {
        Stack<ListNode> stack = new Stack<ListNode>();
        ListNode temp = head;
        while (temp != null) {
            stack.push(temp);
            temp = temp.next;
        }
        int size = stack.size();
        int[] print = new int[size];
        for (int i = 0; i < size; i++) {
            print[i] = stack.pop().val;
        }
        return print;
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof/solution/mian-shi-ti-06-cong-wei-dao-tou-da-yin-lian-biao-b/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

//java
class Solution {
    public int[] reversePrint(ListNode head) {
        LinkedList<Integer> stack = new LinkedList<Integer>();
        while(head != null) {
            stack.addLast(head.val);
            head = head.next;
        }
        int[] res = new int[stack.size()];
        for(int i = 0; i < res.length; i++)
            res[i] = stack.removeLast();
    return res;
    }
}

作者：jyd
链接：https://leetcode-cn.com/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof/solution/mian-shi-ti-06-cong-wei-dao-tou-da-yin-lian-biao-d/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

另一解法：递归

在这里插入图片描述
在这里插入图片描述

//java
class Solution {
    ArrayList<Integer> tmp = new ArrayList<Integer>();
    public int[] reversePrint(ListNode head) {
        recur(head);
        int[] res = new int[tmp.size()];
        for(int i = 0; i < res.length; i++)
            res[i] = tmp.get(i);
        return res;
    }
    void recur(ListNode head) {
        if(head == null) return;
        recur(head.next);
        tmp.add(head.val);
    }
}

作者：jyd
链接：https://leetcode-cn.com/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof/solution/mian-shi-ti-06-cong-wei-dao-tou-da-yin-lian-biao-d/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

#python
class Solution:
    def reversePrint(self, head: ListNode) -> List[int]:
        return self.reversePrint(head.next) + [head.val] if head else []

作者：jyd
链接：https://leetcode-cn.com/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof/solution/mian-shi-ti-06-cong-wei-dao-tou-da-yin-lian-biao-d/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

面试题18.删除链表的结点

在这里插入图片描述

常规思路

//java anan 2020.3.18
//常规思路 找到结点并删除
class Solution {
    public ListNode deleteNode(ListNode head, int val) {
        ListNode h = new ListNode();   //新建一个头结点  题目给定的是不带头结点的链表
        h.next = head;
        ListNode p = head;
        ListNode pre = h;
        while(p != null && p.val != val){
            pre = p;
            p = p.next;
        }        
        pre.next = p.next;  
        return h.next;
    }
}

新思路：给定的是要删除结点的结点指针

在这里插入图片描述
在这里插入图片描述
下面这道题就是用的这种思路

面试题02.03.删除中间结点

在这里插入图片描述
在这里插入图片描述

//java
class Solution {
    public void deleteNode(ListNode node) {
        node.val = node.next.val;
        node.next = node.next.next;
    }
}

面试题22.链表中倒数第k个节点

在这里插入图片描述

安安思路：双指针 快慢指针

//java  anan
class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        ListNode p = head;
        ListNode q = head;
        int n = 0;

        while(p != null){
            n++;
            p = p.next;
            if(n==k){
                q = head;
            }else if(n>k){
                q = q.next;
            }
        }
    
        return q;
    }
}

//java 第一个指针先走k步  然后两个指针一起走
class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        ListNode p = head;
        ListNode q = head;

        for(int i = 0; i < k; i++){
            p = p.next;
        }
        while(p != null){
            p = p.next;
            q = q.next;
        }
    
        return q;
    }
}

注意的点：鲁棒性

在这里插入图片描述

//java
class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        if(head == null || k <= 0){
            return null;
        }

        ListNode p = head;
        ListNode q = head;

        for(int i = 0; i < k; i++){
            if(p == null && i < k){
                return null;
            }
            p = p.next;
        }
        while(p != null){
            p = p.next;
            q = q.next;
        }
    
        return q;
    }
}

19.删除链表的倒数第N个节点

在这里插入图片描述

//java
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        if(head == null || n <= 0){
            return null;
        }

        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode p = dummy;
        ListNode q = dummy;

        for(int i = 0; i < n+1; i++){
            if(p == null){
                return null;
            }
            p = p.next;
        }
        while(p != null){
            p = p.next;
            q = q.next;
        }
        q.next = q.next.next;
           
        return dummy.next;
    }
}

本题和上一题的区别：
1.上一题快指针需要先走n个节点 本题快指针需要走n+1个节点 为什么呢？
因为上一题找的是倒数第n个节点，定位到这个节点即可；但是本题要删除倒数第n个节点，所以需要定位的是倒数第n+1个节点，所以快慢指针的间隔是n+1

2.上一题不需要添加哑节点，本题却需要，为什么？
如果倒数第n个节点刚好是第1个节点，上一题直接返回即可，没有什么影响；但是本题却要删除，删除势必会影响到头结点，所以需要定义哑结点，删除第一个节点不需要单独考虑。

面试题22相关题目：求链表的中间节点

在这里插入图片描述

面试题24.反转链表(206)

在这里插入图片描述

修改next指针

//java
class Solution {
    // public void show(ListNode head){
    //     ListNode p = head;
    //     while(p != null){
    //         System.out.print(p.val + " ");
    //         p = p.next;
    //     }
    //     System.out.println();
    // }

    public ListNode reverseList(ListNode head) {
        if(head == null) return null;

        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode pre = null;
        ListNode p = head;
        ListNode post = p.next;

        while(post != null){           
            p.next = pre;
            //show(p);
            pre = p;
            p = post;
            post = post.next;
        }
        p.next = pre;
        return p;
    }
}

(二刷)修改next指针

//anan 2020/8/3
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null) return null;

        ListNode pre = head;
        ListNode cur = head;
        ListNode suc = head.next;

        while(cur != null){
            cur.next = pre;
            if(pre == head) pre.next = null;
            pre = cur;
            cur = suc;
            if(suc != null) suc = suc.next;
        }

        return pre;
    }
}

递归

//java anan 2020.3.18
class Solution {
    // public void show(ListNode head){
    //     ListNode p = head;
    //     while(p != null){
    //         System.out.print(p.val + " ");
    //         p = p.next;
    //     }
    //     System.out.println();
    // }

    public ListNode reverseList(ListNode head) {
        if(head == null)  return null;
        ListNode p = head;
        if(head.next == null) return head;
        else{
            p = reverseList(head.next); 
            ListNode q = p;
            while(q.next != null) q = q.next;           
            q.next = head;           
            head.next = null;
            //show(p);
            return p;
        }       
    }
}

//java
/*
递归解法
这题有个很骚气的递归解法，递归解法很不好理解，这里最好配合代码和动画一起理解。
递归的两个条件：
终止条件是当前节点或者下一个节点==null
在函数内部，改变节点的指向，也就是 head 的下一个节点指向 head 递归函数那句
head.next.next = head
很不好理解，其实就是 head 的下一个节点指向head
*/
class Solution {
    // public void show(ListNode head){
    //     ListNode p = head;
    //     while(p != null){
    //         System.out.print(p.val + " ");
    //         p = p.next;
    //     }
    //     System.out.println();
    // }

    public ListNode reverseList(ListNode head) {       
        if(head == null || head.next == null) return head;        
        ListNode res = reverseList(head.next);        
        head.next.next = head;         
        head.next = null;
        //show(res);
        return res;              
    }
}

学习的一个很骚的写法：
head.next.next = head
很不好理解，其实就是 head 的下一个节点指向head

92.反转链表II

在这里插入图片描述

安安思路：分成三段，按照反转整个链表进行，然后拼接

//java anan 2020.3.20
/*
1 -> 2 -> 3 -> 4 -> 5   m=2, n=4   
定义两个指针，左指针和右指针
左指针指向要翻转的第一个结点的前一个结点    即指向1
右指针指向要反转的最后一个结点的下一个结点  即指向5
翻转234后进行拼接
*/
class Solution {
    public ListNode reverseBetween(ListNode head, int m, int n) {
        if(m == n || head == null) return head;  //考虑特殊情况，保证鲁棒性

        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode left = new ListNode(0);
        ListNode right = new ListNode(0);
        ListNode p = dummy;
        int count = 0;

        //查找要翻转的部分
        while(p != null){
            if(count == m-1) left = p;
            if(count == n){
                right = p.next;
                break;
            }
            count++;
            p = p.next;
        }
        p.next = null;    //注意找到要翻转的部分之后，要把最后一个结点的下一个结点置空

        //进行翻转
        ListNode rev = reverse(left.next);   
        
        //进行拼接
        left.next = rev;
        p = rev;
        while(p.next != null) p = p.next; 
        p.next = right;

        return dummy.next;
    }

    public ListNode reverse(ListNode head){
        if(head.next == null)  return head;

        ListNode res = reverse(head.next);
        head.next.next = head;
        head.next = null;
        return res;
    }
}

大佬思路：递归

大佬原题解 强烈推荐去看，写的特别好
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

官方题解1：不改变链表结构，只交换链表结点的值

在这里插入图片描述
左指针设为全局变量，递归回溯时后指针前移，此时讲左指针后移，交换对应的值即可

新的技巧点：本题，只要左右指针移到两个的中间便需要停止递归回溯，直接返回去，但是该怎样直接结束返回去呢？题解里给了一个思路：设一个flag指针，只有在满足flag为初始值时才进行，需要返回时改变flag的值即可。
妙哉妙哉！

//Java anan写的 最后一步参考了题解


class Solution {
    ListNode left;
    boolean stop;

    public void reverse(ListNode head, int m, int n){       
        if(m == 1) left = head;
        if(n == 0) return ;

        reverse(head.next, m-1, n-1);

        if(left == head || head.next == left){
            this.stop = true;
            return ;
        }
        
        if(! this.stop){
            int tmp;
            tmp = left.val;
            left.val = head.val;
            head.val = tmp;
            left = left.next;
        }

    }

    public ListNode reverseBetween(ListNode head, int m, int n) {
        left = head;
        stop = false;
        reverse(head, m, n);
        return head;
    }
}

官方题解2：依次修改结点指针的指向

和自己之前做反装整个链表时相似

24.两两交换链表中的节点

在这里插入图片描述
这两个解法都是自己写的
具体思路可以参见：某童鞋题解

解法1：迭代

//java anan 
class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head == null) return null;

        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode pre = dummy;
        ListNode p = head;
        ListNode post;

        while(p != null && p.next != null){
            post = p.next.next; 
             
            //改变指针的方向
            p.next.next = p;
            pre.next = p.next;          
            p.next = post;
                      
            pre = p;
            p = post;           
        }

        return dummy.next;
    }
}

解法2：递归

//java anan 
class Solution {
    public ListNode swapPairs(ListNode head) {        
        if(head == null || head.next == null) return head;
        
        ListNode ret = swapPairs(head.next.next);
        ListNode res = head.next;

        head.next.next = head;
        head.next = ret;
        return res;
    }
}

面试题25.合并两个排序的链表(21)

在这里插入图片描述

自己之前的解法：类似于集合合并

//c   安安 2020.2
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2){
    struct ListNode *p = l1;
    struct ListNode *q = l2;
    struct ListNode *n = NULL;   //指向新链表的第一个结点
    struct ListNode *r;          //指向新链表的最后一个结点
    struct ListNode *s;          //指向新创建的结点

    while(p && q){
        s = (struct ListNode*)malloc(sizeof(struct ListNode));
        if(p->val <= q->val){
            s->val = p->val;
            p = p->next;
        }else{
            s->val = q->val;
            q = q->next;
        }
        s->next = NULL;

        if(n == NULL){
            n = s;
            r = s;
        }else{
            r->next = s;
            r = s;
        }

        // printf("新链表：");
        // struct ListNode *m = n;
        // while(m){
        //     printf("%d ", m->val);
        //     m = m->next;
        // }
        // printf("\n");
    }

    if(q){
        p = q;
    }
    while(p){
        s = (struct ListNode*)malloc(sizeof(struct ListNode));
        s->val = p->val;
        s->next = NULL;
        p = p->next;

        if(n == NULL){     //特殊例子： []   [0]
            n = s;
            r = s;
        }else{
            r->next = s;
            r = s;
        }

        // printf("新新链表：");
        // struct ListNode *m = n;
        // while(m){
        //     printf("%d ", m->val);
        //     m = m->next;
        // }
        // printf("\n");
    }

    return n;
}

解法1：递归

//java anan 2020.3.20
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l1 == null)   return l2;
        if(l2 == null)   return l1;
        
        if(l1.val <= l2.val){
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        }else{           
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
    }
}

解法2：迭代 代码很漂亮

//java
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode prehead = new ListNode(-1);
        ListNode prev = prehead;
        while(l1 != null && l2 != null){
            if(l1.val <= l2.val){
                prev.next = l1;
                l1 = l1.next;
            }else{
                prev.next = l2;
                l2 = l2.next;
            }
            prev = prev.next;
        }

        prev.next = (l1 == null ? l2:l1);   //这一步漂亮的很
        return prehead.next;
    }
}

(二刷)迭代

//anan 2020.8.3
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode dummy = new ListNode();
        ListNode p = dummy;

        while(l1 != null && l2 != null){
            if(l1.val <= l2.val){
                p.next = l1;
                l1 = l1.next;
            }else if(l1.val > l2.val){
                p.next = l2;
                l2 = l2.next;
            }
            p = p.next;
        }

        if(l2 != null){
            l1 = l2;
        }

        while(l1 != null){
            p.next = l1;
            p = p.next;
            l1 = l1.next;
        }
        return dummy.next;
    }
}

面试题35.复杂链表(带随机指针)的复制(138)

在这里插入图片描述
在这里插入图片描述

安安 哈希表

//自己的想法也是大多数人直接想到的想法，但是这中思想的时间复杂度为O(n2)
//因为要定位random指针  //所以官解(同剑指offer书中)用了哈希表(空间换时间)可以迅速定位random指针指向的节点
//java anan 2020.4.26
/*
// Definition for a Node.
class Node {
    int val;
    Node next;
    Node random;

    public Node(int val) {
        this.val = val;
        this.next = null;
        this.random = null;
    }
}
*/

/*
深拷贝是指源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。举个例子，一个人名叫张三，后来用他克隆（假设法律允许）了另外一个人，叫李四，不管是张三缺胳膊少腿还是李四缺胳膊少腿都不会影响另外一个人。
*/
class Solution {
    public Node copyRandomList(Node head) {
        if(head == null)  return null;
                
        //1.构造原链表中的random映射
        HashMap<Integer, Integer> map = new HashMap<>();  //哈希表  用来存储节点random的关系  用下标表示  
        Node p=head;    //p用来遍历原链表       
        for(int i=0; p != null; p=p.next, i++){
            // System.out.print("本节点对象：" + p + " ");
            // System.out.println("指向的random对象" + p.random);
            Node p1=head;   //p1用来遍历原链表
            int j = 0;
            for(; p.random != p1; p1=p1.next, j++){
                ;
            }
            //System.out.println("指向的random对象的下标位置" + j);
            map.put(i, (p.random==null ? -1 : j));      //random为null的话，对应的键值赋为-1    
        }
        //showHashMap(map);


        //2.构造新链表
        Node dummy = new Node(-1);
        Node q=dummy;   //q指向新链表的最后一个节点  
        //2.1.先把新链表创建起来
        p = head;
        for(int i=0; p != null; p=p.next, i++){
            Node s = new Node(p.val);  //新节点
            q.next= s;
            q = s;
        }
        // show(dummy.next);
        // show(head);

        //2.2.构建random指向
        q=dummy.next;    //q用来遍历新链表       
        for(int i=0; q != null; q=q.next, i++){
            if(map.get(i) == -1){
                q.random = null;
            }else{
                Node q1=dummy.next;   //q1用来遍历新链表
                for(int j = 0; j < map.get(i); q1=q1.next, j++){
                    ;
                }
                q.random = q1;
            }                     
        }

        return dummy.next;
    }

    public void show(Node head){
        Node p=head;
        while(p != null){
            System.out.print(p.val + " ");
            p = p.next;
        }
        System.out.println();
    }

    public void showHashMap(HashMap<Integer, Integer> map){
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            System.out.print(entry.getKey() + "--->");
            System.out.println(entry.getValue());
        }
    }
}

官解

官解1：DFS回溯(剑指offer提到了，但是没写代码)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public class Solution {
  // HashMap which holds old nodes as keys and new nodes as its values.
  HashMap<Node, Node> visitedHash = new HashMap<Node, Node>();

  public Node copyRandomList(Node head) {

    if (head == null) {
      return null;
    }

    // If we have already processed the current node, then we simply return the cloned version of
    // it.
    if (this.visitedHash.containsKey(head)) {
      return this.visitedHash.get(head);
    }

    // Create a new node with the value same as old node. (i.e. copy the node)
    Node node = new Node(head.val, null, null);

    // Save this value in the hash map. This is needed since there might be
    // loops during traversal due to randomness of random pointers and this would help us avoid
    // them.
    this.visitedHash.put(head, node);

    // Recursively copy the remaining linked list starting once from the next pointer and then from
    // the random pointer.
    // Thus we have two independent recursive calls.
    // Finally we update the next and random pointers for the new node created.
    node.next = this.copyRandomList(head.next);
    node.random = this.copyRandomList(head.random);

    return node;
  }
}

作者：LeetCode
链接：https://leetcode-cn.com/problems/copy-list-with-random-pointer/solution/fu-zhi-dai-sui-ji-zhi-zhen-de-lian-biao-by-leetcod/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

官解2：迭代 个人感觉和1差不多

官解3：交织链表(剑指offer)

在这里插入图片描述
1.扭曲链表
2.修改random指针
3.恢复next指针
在这里插入图片描述

//java 根据思路自己写的

class Solution {
    public Node copyRandomList(Node head) {
        if(head == null)  return null;

        //创建交织链表
        Node p = head;
        while(p != null){
            Node s = new Node(p.val);
            s.next = p.next;
            p.next = s;
            p = p.next.next;
        }
        //show(head);

        //修改random指针
        p = head;
        while(p != null){
            if(p.random == null) p.next.random = null;
            else{
                p.next.random = p.random.next;
            }
            p = p.next.next;
        }

        //修改next指针
        Node p1 = head;    //遍历原链表
        Node p2 = head.next;   //遍历新链表
        Node returnNode = head.next; 
        while(p2.next != null){
            p1.next = p1.next.next;  //恢复原链表的next指针
            p2.next = p2.next.next;  //恢复新链表的next指针
            p1 = p1.next;
            p2 = p2.next;
        }
        p1.next = null;
        p2.next = null;

        return returnNode;
    }

    public void show(Node head){
        Node p=head;
        while(p != null){
            System.out.print(p.val + " ");
            p = p.next;
        }
        System.out.println();
    }

}
安安csdn
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
链表经典练习题
erwuhuoche的博客
04-16 2万+
链表经典练习题 一、从尾到头打印单链表 因为单链表是有指向的，前一节点只能指向下一节点，因此为了实现从尾到头打印链表可以使用一种非常简单的方法就是递归，先遍历再输出。 代码实现： void LinkListReversePrint(LinkNode* head){ 85 if(head == NULL){ 86 return;//空链表 8...
关于链表的一些题目
songsongL的博客
08-05 430
#include<iostream> #include <stdlib.h> #include <string.h> using namespace std; typedef struct Node//结点 { int data;//数据域 struct Node *next;//指针域 }NODE, *PNODE;//NODE等价于struct St...
有关链表的练习题。
ymk1507050118的博客
06-19 426
刚刚学了线性表，会了一些基本操作，现在来做一些经典面试题来巩固一下知识。一。打印链表从尾到头。//（1）从尾到头打印单链表。普通法: void Print(SListNode *pFirst) { SListNode *end=NULL; //定义指针指向空。 SListNode *pNode=pFirst; //定义指针指向头结点。 while(end!=pFirst...
链表相关题目汇总
那一抹天空蓝的博客
07-21 570
目录 前言 1.反转单链表 2.反转部分单链表 3.查找单链表中的倒数第K个结点（k &gt; 0）  4.查找单链表的中间结点  5.从尾到头打印单链表 6.已知两个单链表pHead1 和pHead2 各自有序，把它们合并成一个链表依然有序  7.判断一个单链表是否有环，如果存在环，求第一个入环节点 8.判断两个单链表是否相交（分有环和无环），若相交，求交点 9.删除排序链表...
链表相关题解
travel_dream的博客
04-09 1157
以下题目皆来自力扣和牛客，可以通过搜索题目名找到对应题目 前期最好配合画图进行解题，要进行特殊情况的考虑。 在进行链表题训练时，最好自己先画图，然后再进行代码的书写，卡壳了或者完全没有思路再看解析。只看完本篇文章不代表你能从容解决链表题。 1. 删除链表中等于给定值 val 的所有节点。//这里的头结点是链表实现的一种方式，后面会介绍到。 画图分析，因为返回头结点，所以可以不用考虑头指针的因素。在实现单链表时也可以这样创建节点，但是要额外创建变量接受指针(返回值)，每次创建节点都要创
剑指offer刷题日记-链表
01-20
链表03-从尾到头打印链表（python） #采用insert方法 class Solution: def printlist(self,listNode): if not listNode: return [] result=[] while listNode: result.insert(0,listNode.val) ...
剑指Offer-V1.pdf
12-12
《剑指Offer》是一本专注于算法和数据结构的书籍，特别针对面试和编程竞赛中的常见问题进行了深入解析。V1版本仅提供了Java语言的解决方案。书中涵盖了大量编程面试中经常遇到的问题，旨在提升读者在算法设计、实现...
剑指offer--java版1--10源码及解析总结.zip
07-08
《剑指Offer》中的一些题目涉及到数组排序、查找以及链表的插入、删除等操作。例如，"二维数组中的查找"问题，要求在二维数组中寻找特定元素，这需要对数组遍历有深入理解；"两个链表的第一个公共节点"，则考察了...
剑指offer-Java代码_java_剑指offer_
09-30
《剑指Offer》是一本备受推崇的编程面试指南，尤其对于Java开发者来说，它提供了大量精心设计的面试题目，旨在帮助求职者提升编程技能和解决问题的能力。这本书的Java代码实现和文字说明是深入理解问题解决方案的...
剑指offer-java-pdf1
08-04
《剑指Offer——Java解题方案》是一本专注于Java编程技术的面试准备书籍，它涵盖了大量常见的编程面试问题，旨在帮助求职者提升编程技能和解决实际问题的能力。书中的题目和解决方案涵盖了数据结构、算法、设计模式...
数据结构中有关链表的题目
春风十米的博客
07-04 444
import java.util.HashMap; import java.util.Stack; /** * Created by wst on 2017/6/30. */ public class List_Algorithm { public static void main(String[] args) { Node n1 = new Node(1);
leetcode:两两交换链表中的节点（java）
pioneer的博客
11-19 216
package LeetCode; public class TwoChangeNode { public ListNode swapPairs(ListNode head) { if(head==null) return head; ListNode preHead=new ListNode(-1); preHe...
剑指leetcode—两两交换链表的节点
super_CSDNer的博客
06-02 192
题目描述：给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 示例一 给定 1->2->3->4, 你应该返回 2->1->4->3. 示例二 给定 1->2->5->3->4，返回2->1->3->5->4 题目中要求是两两交换相邻的节点，每一次交换的操作都是一样的，所以我们可以想到递归，不断的调用自身函数 方法一： 递归 算法流程 从链表的头结.
《数据结构》十道链表经典面试题多种方法深度解析
m0_62171658的博客
03-20 6682
《数据结构》十道链表经典面试题多种方法深度解析，配有图解深度挖掘各种细节问题，打好根基，为冲击金丹期做准备。
链表经典 10题
最新发布
mu_tong_的博客
10-12 2261
链表10 道经典例题
LeetCode-24-两两交换链表中的节点-C语言
SFFS
05-06 515
使用递归的方法 递归的截至条件为链表小于等于一个节点， 每次仅处理头节点head以及head->next节点，使二者交换。 /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */ typedef struct L...
【典例】链表经典题目合集
浮光掠影
02-04 5239
爷把鱼缸搬出来了好吧~
链表经典题目
qq_33253721的博客
05-19 509
一、虚拟头结点 题目203. 移除链表元素. 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 在链表中想要删除一个节点，让节点（待删除节点的上一个节点）的next指针指向下下个节点即可（node.next = node.next.next）。 除了正常的删除，我们还需要考虑特殊的情况，比如，删除的是头节点该怎么办？ 第一种方式：直接使用原来的链表进行删除操作 即将头节点向后移动一位即可 然后再将原本的头节点删
剑指 Offer 06. 从尾到头打印链表
人工智能曾小健
08-25 196
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。 示例 1： 输入：head = [1,3,2] 输出：[2,3,1] class Solution: def reversePrint(self, head: ListNode) -> List[int]: return self.reversePrint(head.next) + [head.val] if head else [] class Solution: def.
O(1)时间删除链表节点：剑指Offer算法详解
在《剑指Offer》这本书中，包含了丰富的IT算法题和数据结构问题，主要针对Java程序员，旨在帮助求职者提升面试中的各项能力。以下是一些关键知识点的详细讲解： 1. **O(1)时间删除链表节点**：此部分讨论的是在链表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

安安csdn

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

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

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

打赏作者

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

抵扣说明：

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

余额充值