精华内容
下载资源
问答
  • K 个一组翻转链表

    2020-07-25 14:11:46
    K 个一组翻转链表 1、题目 题目说明 给你一链表,每 k 节点一组进行翻转,请你返回翻转后的链表。 k 是一正整数,它的值小于或等于链表的长度。 如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持...

    K 个一组翻转链表

    1、题目

    • 题目说明

      • 给你一个链表,每 k 个节点一组进行翻转,请你返回翻转后的链表。
      • k 是一个正整数,它的值小于或等于链表的长度。
      • 如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。
    • 示例:

      • 给你这个链表:1->2->3->4->5
      • 当 k = 2 时,应当返回: 2->1->4->3->5
      • 当 k = 3 时,应当返回: 3->2->1->4->5
    • 说明:

      • 你的算法只能使用常数的额外空间。看这图应该就清楚了,In-place 就是常数内存,Out-place 就是额外内存,说白了让你用 In-place 方式的算法来解决问题。

      image-20200722204342414

      • 你不能只是单纯的改变节点内部的值,而是需要实际进行节点交换。

    2、代码

    2.1、代码思路

    • 以两个为一组讲解思路,其他情况类似

      • curNode 指向当前的节点
      • nextNode 为 curNode 的下一个节点
      • reverseHead 指向每一段子链表的首节点
      • reverseTail 指向每一段子链表的尾节点
    • 下面举例说明一下程序的大致流程,以 K = 2 为例讲解

      • 原链表如下

      image-20200723084658007

      • 初始操作:
        • reverseHead 为子链表的链表头,可以看作是子链表的头结点,初始化时是自己 new 出来的
        • reverseTail 每次初始化时,指向子链表的首节点,随着翻转的进行,链表首节点自然就变成了尾节点

      image-20200723085246958

      • 执行第一次翻转后:将 curNode 指向的节点放在 reversehead 之后 ,curNode、nextNode 指针后移

      image-20200723084737792

      • 执行第二次翻转:
        • 将 curNode 指向的节点放在 reversehead 之后 ,curNode、nextNode 指针后移
        • 此时赶紧将原链表的头结点 head 指向 reverseHead ,因为这时候 reverseHead 指向的节点是新的首节点,不珍惜这次,之后就没机会啦

      image-20200723084923216

      image-20200723085638646

      • 此时已经执行了两次翻转,需要重新初始化子链表的头结点和尾节点
        • reverseHead 指向之前的 reverseTail ,作为子链表新的头结点
        • reverseTail 指向 curNode ,随着翻转的进行,reverseTail 会成为子链表的尾节点

      image-20200723085625380

      • 注意:如果链表长度不是 K 的整数倍,那么退出循环后需要将 reverseHead 指向 curNode ,否则后面的子链表将丢失。。。

      image-20200722232942683

    image-20200723090035239

    2.2、链表节点的定义

    // 节点
    class Node {
    	public Integer data;
    	public Node next;
    
    	public Node(Integer data) {
    		this.data = data;
    	}
    
    	public String toString() {
    		return data.toString();
    	}
    }
    

    2.3、K 个一组翻转链表

    // 链表类
    class SingleLinkedList {
    
    	private Node head = new Node(0);
    
    	public void add(Node node) {
    		// 首节点指针不能移动哦,需要定义辅助指针
    		Node preNode = head;
    		while (preNode.next != null) {
    			preNode = preNode.next;
    		}
    		preNode.next = node;
    	}
    
    	public void show() {
    		// 首节点指针不能移动哦,需要定义辅助指针
    		Node curNode = head.next;
    		while (curNode != null) {
    			System.out.print(curNode.data + "-->");
    			curNode = curNode.next;
    		}
    		System.out.println();
    	}
    
    	public int length() {
    		// 首节点指针不能移动哦,需要定义辅助指针
    		Node curNode = head.next;
    		// 链表长度
    		int len = 0;
    		while (curNode != null) {
    			len++;
    			curNode = curNode.next;
    		}
    		return len;
    	}
    
    	public void reverse(int gap) {
    		int len = length();
    
    		// gap 过大
    		if (len < gap) {
    			return;
    		}
    
    		// 链表中没有元素或者只有一个元素
    		if (head.next == null || head.next.next == null) {
    			return;
    		}
    
    		// 新的头结点和尾节点
    		Node reverseHead = new Node(0);
    		Node reverseTail = new Node(0);
    
    		// 当前正在遍历的节点
    		Node curNode = head.next;
    		// 当前节点的下个节点
    		Node nextNode = curNode.next;
    		// reverseTail 是每个子链表的第一个元素
    		reverseTail = curNode;
    
    		// 翻转计数器,记录当前一共翻转了多少个节点
    		int reverseCount = 0;
    
    		while (curNode != null) {
    			// 将当前正在遍历的节点挂在 reverseHead 之后
    			nextNode = curNode.next;
    			curNode.next = reverseHead.next;
    			reverseHead.next = curNode;
    			// 指针后移,计数器加 1
    			curNode = nextNode;
    			reverseCount++;
    
    			// 到达指定个数,则重新需要为 reverseHead 和 reverseTail 重新赋值
    			if (reverseCount % gap == 0) {
    				// 如果是第一次到达指定个数,则将头指针指向首节点,否则后面就没机会了。。。
    				if (reverseCount / gap == 1) {
    					head.next = reverseHead.next;
    				}
    				// 头指针指向左边链表尾节点
    				reverseHead = reverseTail;
    				// 尾指针指向右边链表的首节点
    				reverseTail = curNode;
    				// 如果不足 gap 个,则推出,不再继续翻转
    				if (reverseCount + gap > len) {
    					break;
    				}
    			}
    		}
    		// 如果不足 gap 个,不翻转,直接连接
    		if (reverseCount != len) {
    			reverseHead.next = curNode;
    		}
    	}
    }
    

    2.4、代码测试

    • 代码
    public static void main(String[] args) {
    
        SingleLinkedList singleLinkedList = new SingleLinkedList();
    
        singleLinkedList.add(new Node(1));
        singleLinkedList.add(new Node(2));
        singleLinkedList.add(new Node(3));
        singleLinkedList.add(new Node(4));
        singleLinkedList.add(new Node(5));
    
        System.out.println("翻转前~~~");
        singleLinkedList.show();
    
        System.out.println("翻转后~~~");
        singleLinkedList.reverse(2);
        singleLinkedList.show();
    
    }
    
    • 程序运行结果
    翻转前~~~
    1-->2-->3-->4-->5-->
    翻转后~~~
    2-->1-->4-->3-->5-->
    

    2.5、全部代码

    public class ReverseListWithK {
    	public static void main(String[] args) {
    
    		SingleLinkedList singleLinkedList = new SingleLinkedList();
    
    		singleLinkedList.add(new Node(1));
    		singleLinkedList.add(new Node(2));
    		singleLinkedList.add(new Node(3));
    		singleLinkedList.add(new Node(4));
    		singleLinkedList.add(new Node(5));
    
    		System.out.println("翻转前~~~");
    		singleLinkedList.show();
    
    		System.out.println("翻转后~~~");
    		singleLinkedList.reverse(2);
    		singleLinkedList.show();
    
    	}
    }
    
    // 链表类
    class SingleLinkedList {
    
    	private Node head = new Node(0);
    
    	public void add(Node node) {
    		// 首节点指针不能移动哦,需要定义辅助指针
    		Node preNode = head;
    		while (preNode.next != null) {
    			preNode = preNode.next;
    		}
    		preNode.next = node;
    	}
    
    	public void show() {
    		// 首节点指针不能移动哦,需要定义辅助指针
    		Node curNode = head.next;
    		while (curNode != null) {
    			System.out.print(curNode.data + "-->");
    			curNode = curNode.next;
    		}
    		System.out.println();
    	}
    
    	public int length() {
    		// 首节点指针不能移动哦,需要定义辅助指针
    		Node curNode = head.next;
    		// 链表长度
    		int len = 0;
    		while (curNode != null) {
    			len++;
    			curNode = curNode.next;
    		}
    		return len;
    	}
    
    	public void reverse(int gap) {
    		int len = length();
    
    		// gap 过大
    		if (len < gap) {
    			return;
    		}
    
    		// 链表中没有元素或者只有一个元素
    		if (head.next == null || head.next.next == null) {
    			return;
    		}
    
    		// 新的头结点和尾节点
    		Node reverseHead = new Node(0);
    		Node reverseTail = new Node(0);
    
    		// 当前正在遍历的节点
    		Node curNode = head.next;
    		// 当前节点的下个节点
    		Node nextNode = curNode.next;
    		// reverseTail 是每个子链表的第一个元素
    		reverseTail = curNode;
    
    		// 翻转计数器,记录当前一共翻转了多少个节点
    		int reverseCount = 0;
    
    		while (curNode != null) {
    			// 将当前正在遍历的节点挂在 reverseHead 之后
    			nextNode = curNode.next;
    			curNode.next = reverseHead.next;
    			reverseHead.next = curNode;
    			// 指针后移,计数器加 1
    			curNode = nextNode;
    			reverseCount++;
    
    			// 到达指定个数,则重新需要为 reverseHead 和 reverseTail 重新赋值
    			if (reverseCount % gap == 0) {
    				// 如果是第一次到达指定个数,则将头指针指向首节点,否则后面就没机会了。。。
    				if (reverseCount / gap == 1) {
    					head.next = reverseHead.next;
    				}
    				if (reverseCount + gap > len) {
    					break;
    				}
    				reverseHead = reverseTail;
    				reverseTail = curNode;
    			}
    		}
    		if (reverseCount == len) {
    			reverseTail.next = null;
    		} else {
    			reverseTail.next = curNode;
    		}
    	}
    }
    
    // 节点
    class Node {
    	public Integer data;
    	public Node next;
    
    	public Node(Integer data) {
    		this.data = data;
    	}
    
    	public String toString() {
    		return data.toString();
    	}
    }
    
    展开全文
  • K个一组翻转链表

    2020-06-27 22:05:40
    节点一组进行翻转,请你返回翻转后的链表k 是一正整数,它的值小于或等于链表的长度。 如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。 示例: 给你这个链表:1->2-&...

    给你一个链表,每 k 个节点一组进行翻转,请你返回翻转后的链表。

    k 是一个正整数,它的值小于或等于链表的长度。
    如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。

    示例:
    给你这个链表:1->2->3->4->5
    当 k = 2 时,应当返回: 2->1->4->3->5
    当 k = 3 时,应当返回: 3->2->1->4->5

    说明:
    你的算法只能使用常数的额外空间。
    你不能只是单纯的改变节点内部的值,而是需要实际进行节点交换。

    官方解法

    本题的目标非常清晰易懂,不涉及复杂的算法,但是实现过程中需要考虑的细节比较多,容易写出冗长的代码。主要考察面试者设计的能力。

    我们需要把链表结点按照 k 个一组分组,所以可以使用一个指针 head 依次指向每组的头结点。这个指针每次向前移动 k 步,直至链表结尾。对于每个分组,我们先判断它的长度是否大于等于 k。若是,我们就翻转这部分链表,否则不需要翻转。

    接下来的问题就是如何翻转一个分组内的子链表。翻转一个链表并不难,过程可以参考 206. 反转链表。但是对于一个子链表,除了翻转其本身之外,还需要将子链表的头部与上一个子链表连接,以及子链表的尾部与下一个子链表连接。如下图所示:

    因此,在翻转子链表的时候,我们不仅需要子链表头结点 head,还需要有 head 的上一个结点 pre,以便翻转完后把子链表再接回 pre。

    但是对于第一个子链表,它的头结点 head 前面是没有结点 pre 的。太麻烦了!难道只能特判了吗?答案是否定的。没有条件,我们就创造条件;没有结点,我们就创建一个结点。我们新建一个结点,把它接到链表的头部,让它作为 pre 的初始值,这样 head 前面就有了一个结点,我们就可以避开链表头部的边界条件。这么做还有一个好处,下面我们会看到。

    反复移动指针 head 与 pre,对 head 所指向的子链表进行翻转,直到结尾,我们就得到了答案。下面我们该返回函数值了。

    有的同学可能发现这又是一件麻烦事:链表翻转之后,链表的头结点发生了变化,那么应该返回哪个结点呢?照理来说,前 k 个结点翻转之后,链表的头结点应该是第 k 个结点。那么要在遍历过程中记录第 k 个结点吗?但是如果链表里面没有 k 个结点,答案又还是原来的头结点。我们又多了一大堆循环和判断要写,太崩溃了!

    等等!还记得我们创建了节点 pre吗?这个结点一开始被连接到了头结点的前面,而无论之后链表有没有翻转,它的 next 指针都会指向正确的头结点。那么我们只要返回它的下一个结点就好了。至此,问题解决。

    可以将链表分成几份,对每份进行翻转,重要的是怎么将转好的接上原来的:

    /**
     * Definition for singly-linked list.
     * struct ListNode {
     *     int val;
     *     struct ListNode *next;
     * };
     */
    int ListLength(struct ListNode* head)//求表长
    {
        int i = 1;
        while(head->next)//head是第一个,有next就有下一个
        {
            i++;
            head = head->next;
        }
        return i;
    }
    struct ListNode* reverseKGroup(struct ListNode* head, int k)
    {
        if (k == 0 || k == 1)
            return head;
        struct ListNode* Head = (struct ListNode*)malloc(sizeof(struct ListNode));//新建一个头
        Head->next = head;
        Head->val = 0;
        //这三个用来翻转每份链表
        struct ListNode* before = head;
        struct ListNode* p = NULL;
        struct ListNode* later = NULL;
        
        //这个用来记录每份头结点前面的结点
        struct ListNode* record = Head;
        
        int length = ListLength(head);
        int num = length / k;//多少份
        while (num)
        {
            before = head;
            p = head->next;
            for (int j = 1; j < k; j++)//子链翻转
            {
                later = p->next;
                p->next = before;
                before = p;
                p = later;
            }
            record->next = before;//before是每份翻转后的头,让record接上头
            head->next = p;//head是每份翻转后的尾,接上下一个头p
            record = head;//每份的head最后都是尾,也就是下一份头前面的结点
            head = p;//head移动到下一个的头,翻转后它就是尾了
            num--;
        }
        struct ListNode* r = Head->next;
        free(Head);
        return r;
    }
    

    开始前
    在这里插入图片描述
    第一份成功后(关于这个怎么来的可以看我的另一个博客)
    单链表逆转
    在这里插入图片描述
    看图,接下来是不是要

            record->next = before;//before是每份翻转后的头,让record接上头
            head->next = p;//head是每份翻转后的尾,接上下一个头p
            record = head;//每份的head最后都是尾,也就是下一份头前面的结点
            head = p;//head移动到下一份的头
    

    在这里插入图片描述
    下一次就是
    在这里插入图片描述
    又来一遍,如此下去。最终返回以2开头的链表
    在这里插入图片描述
    作者:LeetCode-Solution
    链接:https://leetcode-cn.com/problems/reverse-nodes-in-k-group/solution/k-ge-yi-zu-fan-zhuan-lian-biao-by-leetcode-solutio/
    来源:力扣(LeetCode)
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

    来源:力扣(LeetCode)
    链接:https://leetcode-cn.com/problems/reverse-nodes-in-k-group
    著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

    展开全文
  • 使用迭代,根据题目提供的 k 值确定翻转链表部分,在内部实现翻转,进而解决《25. K 个一组翻转链表》的主要内容。其中注意要定义链表的前驱和后继,防止指向错误。

    25. K 个一组翻转链表


    题目来源:https://leetcode-cn.com/problems/reverse-nodes-in-k-group

    题目


    给你一个链表,每 k 个节点一组进行翻转,请你返回翻转后的链表。

    k 是一个正整数,它的值小于或等于链表的长度。

    如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。

    示例:

    给你这个链表:1->2->3->4->5

    当 k = 2 时,应当返回: 2->1->4->3->5

    当 k = 3 时,应当返回: 3->2->1->4->5

    说明:

    • 你的算法只能使用常数的额外空间。
    • 你不能只是单纯的改变节点内部的值,而是需要实际进行节点交换。

    解题思路


    思路:迭代、翻转链表

    具体思路:

    • 首先要确保翻转的范围,这个是由题目中提及的 k 来控制;
    • 关于链表的翻转,要注意前驱和后继的问题,防止指向错误,这里也为了将翻转后的链表与后续进行连接;
    • 定义 pre 和 tail,pre 表示待翻转链表部分的前驱,tail 表示末尾;
    • 上面的 tail 经由 k 控制到达末尾;
    • 翻转链表,将翻转后的部分与后续进行拼接;
    • 注意:根据题意,当翻转部分的长度小于 k 时,这个时候不做处理。

    具体的代码实现如下。

    代码实现


    # Definition for singly-linked list.
    # class ListNode:
    #     def __init__(self, x):
    #         self.val = x
    #         self.next = None
    
    class Solution:
        def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
            if head == None and head.next == None and k < 2:
                return head
            # 定义哨兵节点
            dummy = ListNode(0)
            # 指向节点
            dummy.next = head
    
            # 定义前驱后继节点
            pre = dummy
            tail = dummy
    
            # 控制 tail 到待翻转链表部分的末尾
            while True:
                count = k
                while count > 0 and tail != None:
                    count -= 1
                    tail = tail.next
                # 到达尾部时,长度不足 k 时,跳出循环
                if tail == None:
                    break
    
                # 这里用于下次循环
                head = pre.next
                # 开始进行翻转
                while pre.next != tail:
                    tmp = pre.next
                    pre.next = tmp.next
                    tmp.next = tail.next
                    tail.next = tmp
                
                # 重置指针
                pre = head
                tail = head
            
            return dummy.next
    

    实现结果


    实现结果


    以上就是使用迭代,根据题目提供的 k 值确定翻转链表部分,在内部实现翻转,进而解决《25. K 个一组翻转链表》的主要内容。其中注意要定义链表的前驱和后继,防止指向错误。

    展开全文
  • 题目来源:Leetcode K个一组翻转链表 题目 给你一链表,每 k 节点一组进行翻转,请你返回翻转后的链表。 k 是一正整数,它的值小于或等于链表的长度。 如果节点总数不是 k 的整数倍,那么请将最后剩余的节点...

    题目来源Leetcode K个一组翻转链表

    一.题目

    给你一个链表,每 k 个节点一组进行翻转,请你返回翻转后的链表。
    k 是一个正整数,它的值小于或等于链表的长度。
    如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。

    示例:

    给你这个链表:1->2->3->4->5
    当 k = 2 时,应当返回: 2->1->4->3->5
    当 k = 3 时,应当返回: 3->2->1->4->5
    

    说明:

    • 你的算法只能使用常数的额外空间。
    • 你不能只是单纯的改变节点内部的值,而是需要实际进行节点交换。

    二.解题核心思路

    要想解决该问题需要解决如下几个问题:

    • 寻找到K个一组结点(存在时);
    • 如何能够将当前一组逆序后连接到之前“逆序处理”好的序列后面,以及将当前一组逆序结点的末尾连接未经处理的链表结点序列。

    2.1.如何寻找K个一组结点

    • 可采用双指针法,这里利用两个指针pre和p,其中pre用来指向K个结点的开头,p用来指向K个结点的末尾。
    • 开始时pre和p同时指向同一个结点,然后移动p到第k个结点处,若在移动过程中结点p为变为空则说明剩余的结点数少于K个,此时说明原链表已经处理完毕。

    伪代码

    pre = p = start_position //start_position开始寻找K个一组节点的第一个结点位置
    for i = 1 to k
    	p = p->next;
    	if p is NULL
    		break
    

    2.2.逆序连接

    2.2.1.处理步骤

    在介绍之前首先说明一些使用到的指针(pre和p上面已经介绍):

    • curhead:指向已经经过处理的部分序列的末尾;
    • rear:用来保存p指针之后的序列,防止其丢失;
    • curp:用来暂时指向从k个一组结点中取出来的结点;

    设之前已经翻转了几组数据,此时curhead执行在处理完的序列的末尾:

    1. 首先需要将curhead的next指针置为NULL,即断可处理完的序列和未处理完的序列之间的连接。
    2. 同时使用rear指针指向p指向的后一个结点。
    3. 然后逐一的将从pre到p的全部结点取下来,取下的结点用curp指向,然后插入到curhead结点相邻的下一个位置。(插入的方法curp->next = curhead->next; curhead->next = curp
    4. 通过步骤三的操作就可以完成将pre到p的结点序列逆序连接,然后curhead要移动到新处理完的序列的末尾结点位置,然后将rear指向的剩下的序列连接在其后面。

    2.2.2.逆序连接算法图示

    设K = 3,原始元素列表为1->2->3->4->5->6->7,则经过一次处理后的链表如下图所示
    经过一次K个一组翻转后
    第二次处理第一步:将处理好的序列与未处理的序列断开,并将p的后一结点用rear指向
    times 2 step1
    第二次处理第二步:从K个一组序列取出第一个结点,连接到与curhead相邻的下一位置
    times2 step2
    第二次处理第三步:取出第二个结点,连接到curhead相邻的下一位置
    times2 step 3
    第二次处理第四步:取出最后一个结点,连接到curhead相邻的下一位置
    time2 step 4
    第二次处理第五步:将curhead指针移动至当前已处理序列的末尾,并将未处理的指针序列连接在其后,然后重新初始化pre和p进行下一次处理
    times2 step 5

    三.核心代码(C语言)

    /**
     * Definition for singly-linked list.
     * struct ListNode {
     *     int val;
     *     struct ListNode *next;
     * };
     */
     
    struct ListNode* reverseKGroup(struct ListNode* head, int k) {
    	 struct ListNode* pre, * p;
    	 struct ListNode *rear, * curhead,*curp;
    	 int i;
    
    	 curhead = (struct ListNode*)malloc(sizeof(struct ListNode));
    	 pre = p = head;
    	 while (p)
    	 {
    		 for (i = 1; i < k; i++)
    		 {
    			 if (!p)
    				 break;
    			 p = p->next;
    		 }
    		 if (p)
    		 {
    			 rear = p->next;
    			 curhead->next = NULL;
    			 if (pre == head)
    				 head = curhead;
    			 while (pre != rear)
    			 {
    				 curp = pre;
    				 pre = pre->next;
    				 curp->next = curhead->next;
    				 curhead->next = curp;
    			 }
    			 while (curhead->next)
    			 {
    				 curhead = curhead->next;
    			 }
    			 curhead->next = rear;
    			 p = pre;
    		 }
    
    	 }
    	 return head->next;
     }
    
    展开全文
  • 需要一个指针lastEnd记录已经翻转后形成的链表的尾结点,还需要一个指针nextHead记录下一个翻转链表的链头,然后需要start和end记录当前需要翻转k个结点组成的链表的表头和表尾,需要注意的是在调用reverse...
  • 给你一个链表,每k个节点一组进行翻转,请你返回翻转后的链表k是一正整数,它的值小于或等于链表的长度。 如果节点总数不是k的整数倍,那么请将最后剩余的节点保持原有顺序。 示例: 给你这个链表:1->2...
  • 给你一个链表,每 k 节点一组进行翻转,请你返回翻转后的链表k 是一正整数,它的值小于或等于链表的长度。 如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。 示例: 给你这个链表:1->...
  • 25. K 个一组翻转链表

    2021-01-09 19:00:19
    给你一个链表,每 k 节点一组进行翻转,请你返回翻转后的链表k 是一正整数,它的值小于或等于链表的长度。 如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。 示例: 给你这个链表:1->...
  • //链表长度 while (num >= k) { cur = pre->next; //依次交换节点元素 for (int i = 1; i < k; ++i) { ListNode *t = cur->next; cur->next = t->next; t->next = pre->next; pre->next = t; } pre = cur; num -= k;...
  • 给出一个链表,每 k 节点一组进行翻转,并返回翻转后的链表k 是一正整数,它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍,那么将最后剩余节点保持原有顺序。 说明: 你需要自行定义链表结构,将...
  • 给你一个链表,每k个节点一组进行翻转,请你返回翻转后的链表k是一正整数,它的值小于或等于链表的长度。 如果节点总数不是k的整数倍,那么请将最后剩余的节点保持原有顺序。 示例: 给你这个链表:1->...
  • K个一组翻转链表--Java版

    千次阅读 2019-06-07 12:32:47
    翻转后的子链表接到头节点后面(如果没有头节点,就创建一个虚拟头节点),然后把接下来的K个节点看成另外一个单独的链表进行翻转,把翻转后的子链表连接到上一个已经完成的子链表后面。 /** * Definition for ...
  • 给你一个链表,每 k 节点一组进行翻转,请你返回翻转后的链表k 是一正整数,它的值小于或等于链表的长度。 如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。示例: 给你这个链表:1->2...
  • a.append(head.val) head = head.next # 计算有几组需要循环 b = len(a)//k # 如果只有一组需要循环 if b == 1: a = self.aa(a,0,k-1,k) # 有两组或者三组以上需要循环 else: for i in range(0,k*b,k): a = self.aa...
  • 给你一个链表,每 k 节点一组进行翻转,请你返回翻转后的链表k 是一正整数,它的值小于或等于链表的长度。 如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。 示例: 给你这个链表:1->...
  • 题目:给你一个链表,每k个节点一组进行翻转,请你返回翻转后的链表k是一正整数,它的值小于或等于链表的长度。如果节点总数不是k的整数倍,那么请将最后剩余的节点保持原有顺序。 示例 : 给定这个链表:1-&...
  • # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = None class Solution: def reverseKGroup(self, head: ListNode, k: in...
  • K 个一组翻转链表:         给你一链表,每 k 节点一组进行翻转,请你返回翻转后的链表。         k 是一正整数,它的值小于或等于链表的长度。如果节点总数不是 k ...
  • 别被红色的困难两字吓到了,其实滤清思路后你会觉得真的不难 ...第一组翻转完毕; 第一次迭代:32154678 第二次迭代:32165478 剩余节点数小于k,则这即为要返回的结果; 代码实现: /** * Definition fo.
  • * 设置start指向一组的头,设置end指向一组的尾。设置next指向下一组的头 * 之后让pre指向反转后的当前组,start指向next * 之后start变为pre和end,next变为start * 迭代这过程 * * * 核心关键: * pre...
  • 学习内容: 实现链表, 完成leetCode 25 K个一组翻转链表 1、 实现链表 2、 完成leetCode 25 K个一组翻转链表 题目:给你一链表,每K个节点一组锦绣翻转,请你返回翻转后的链表。 K是一正整数,它的值小于或...
  • k个一组翻转链表

    2019-10-24 11:04:54
    给你一个链表,每 k 节点一组进行翻转,请你返回翻转后的链表k 是一正整数,它的值小于或等于链表的长度。 如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。 示例 : 给定这个链表:1->...
  • 题目:k个一组翻转链表 思路:递归 递归函数返回已经反转好的链表; 递归函数需要把本次翻转好的链表 链到 下一次翻转好的链表上。 代码: /** * Definition for singly-linked list. * public class ListNode { ...
  • 给出一个链表,每k个节点一组进行翻转,并返回翻转后的链表k是一正整数,它的值小于或等于链表的长度。如果节点总数不是k的整数倍,那么将最后剩余节点保持原有顺序。 示例 : 给定这个链表:1->2->3-&...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,558
精华内容 3,023
关键字:

k个一组翻转链表