leetcode之Insertion Sort List

Sort a linked list using insertion sort.

这道题是用链表做插入排序。虽然之前数据结构中学习了链表的插入删除等,但那些都是最简单的基本操作,只是给出一个节点,直接给出插入位置。

首先,插入排序的思想是,每次将一个元素插入到前面已排序的有序的链表中,因此首先要找到需要插入的元素,如果链表的链接顺序是按照生序排列的话直接continue

当找到要插入的元素时,即第一个使得无序的元素。首先应该记录下当前元素的位置,以及该元素之前的位置。

其次开始从头遍历已排序的前面链表,直到找到要插入的位置

最后再用之前学习过的插入的基本操作。

整个题目思路相对来说比较清晰,只是一定要记住插入时几点next的顺序。

有一点不明白的地方是为什么要返回newHead.next?

下面附上源码

public ListNode insertionSortList(ListNode head) {
        if(head==null||head.next==null){
            return head;
        }
        ListNode newHead = new ListNode(-1);
        newHead.next = head;
        ListNode cur = head;
        ListNode post = head.next;
        while(post!=null){
            if(post.val>cur.val){
                cur = cur.next;
                post = post.next;
            }
            else{
                ListNode insertCur = newHead;
                ListNode insertPost = newHead.next;
                while(insertPost.val<post.val){
                    insertCur = insertCur.next;
                    insertPost = insertPost.next;
                }
                cur.next = post.next;
                post.next = insertPost;
                insertCur.next = post;
                post = cur.next;

            }
        }
        return newHead.next;
    }

  

时间: 2024-10-28 16:36:23

leetcode之Insertion Sort List的相关文章

【LeetCode】Insertion Sort List

题目 Sort a linked list using insertion sort. 解答 链表无法像数组那样从后往前依次比较插入,只能从前往后:在链表首部添加一个哨兵可以稍微简化下代码,代码如下: /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { * val = x; * next = null; * } * }

[LeetCode 题解]: Insertion Sort List

Sort a linked list using insertion sort. 题目要求:链表的插入排序,由于没有时间复杂度的要求,可以直接循环操作. /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode

LeetCode OJ - Insertion Sort List

题目: Sort a linked list using insertion sort. 解题思路: 假设 list[1..i]是排好序的,找到第i+1个元素应该插入的位置及其前驱,然后将其插入. 代码: /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class S

leetcode 147. Insertion Sort List (Python版)

题目: Sort a linked list using insertion sort. 大意是要实现一个链表的插入排序 算法思路:     从原链表中逐个弹出一个node 对于每一个node用插入排序的思想插入新的升序排列的链表中 这里有一个小trick,leetcode有一组数据是1~4999的升序序列,如果我们采用如上方法会超时 于是我们在插入排序的时候设置一个last位,记录当前插入的位置 在下一次插入的时候与上次插入位置last比较,如果当前node.val > last.val,那么

Java for LeetCode 147 Insertion Sort List

Sort a linked list using insertion sort. 解题思路: 插入排序,JAVA实现如下: public ListNode insertionSortList(ListNode head) { if(head==null||head.next==null) return head; ListNode root=new ListNode(Integer.MIN_VALUE); root.next=head; head=head.next; root.next.nex

leetcode:Insertion Sort List

Sort a linked list using insertion sort. 分析:此题要求在链表上实现插入排序. 思路:插入排序是一种O(n^2)复杂度的算法,基本想法就是每次循环找到一个元素在当前排好的结果中相对应的位置然后插进去,经过n次迭代之后就能得到排好序的结果. 可以这么做:建立一个helper头结点,然后依次将head链表中的结点有序的插入到helper链表中 代码: /** * Definition for singly-linked list. * struct ListN

Leetcode 147. Insertion Sort List 插入排序 in Java

147. Insertion Sort List Total Accepted: 80869 Total Submissions: 263074 Difficulty: Medium Sort a linked list using insertion sort. /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { va

leetcode - [5]Insertion Sort List

Sort a linked list using insertion sort. 思路:插入排序 #include <iostream> using namespace std; struct ListNode { int val; ListNode *next; ListNode(int x): val(x), next(NULL) {} }; class Solution { public: ListNode *insertionSortList(ListNode *head) { if

[LeetCode] 147. Insertion Sort List 解题思路

Sort a linked list using insertion sort. 问题:实现单向链表的插入排序. 这是比较常规的一个算法题目. 从左往右扫列表,每次将指针的下一个元素插入前面已排好序的对应位置中. 需要注意的一定是,列表只能定位下一个元素,不能定位前一个元素,所有,每次插入位置的适合,都是对左右指针的下一个元素进行操作. 1 void insertSort(ListNode* p1, ListNode* p2){ 2 ListNode* next2 = p2->next; 3 p

【leetcode】Insertion Sort List (middle)

Sort a linked list using insertion sort. 思路: 用插入排序对链表排序.插入排序是指每次在一个排好序的链表中插入一个新的值. 注意:把排好序的部分和未排序的部分完全分开,指针不要有交叉. 即不会通过->next 重叠 class Solution { public: ListNode *insertionSortList(ListNode *head) { if(head == NULL) return NULL; ListNode * ans = hea