LeetCode-Insertion Sort List-链表插入排序-链表操作

https://oj.leetcode.com/problems/insertion-sort-list/

插入排序为假设[0,i)已经为有序数组,下一步从[i,n)找最小的元素交换到i处。用指针模拟这个过程即可。就是操作有些麻烦。

每次[head,p)为已经有序的数组,下次从[p,tail]找出最小的节点r以及其前继节点l。将其插入到lp->p之间。并且注意检测这个节点是否为p这样的边界条件。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 const int INF=2147483647;
class Solution {
public:
    ListNode *insertionSortList(ListNode *head) {
        if (head==NULL) return NULL;
        ListNode *p=head;
        ListNode *lp=NULL;
        ListNode *h=head;
        while(p!=NULL){
            int minv=INF;
            ListNode *l,*r=p;
            ListNode *lq=lp;
            ListNode *q=p;
            while(q!=NULL){
                if (q->val<minv){
                    minv=q->val;
                    l=lq;
                    r=q;
                }
                lq=q;
                q=q->next;
            }
            if (r==p) {
                lp=p;
                p=p->next;
                continue;
            }
            if (l!=NULL) l->next=r->next;
            r->next=p;
            if (lp==NULL) h=r;
            else lp->next=r;
            lp=r;
        }
        return h;
    }
};

  

时间: 2024-12-21 12:38:35

LeetCode-Insertion Sort List-链表插入排序-链表操作的相关文章

leetcode——Insertion Sort List 对链表进行插入排序(AC)

Sort a linked list using insertion sort. class Solution { public: ListNode *insertionSortList(ListNode *head) { if(head == NULL || head->next == NULL) return head; ListNode *result; result->val = INT_MIN; result->next = NULL; ListNode *cur=head,*

[leetcode]Insertion Sort List @ Python

原题地址:http://oj.leetcode.com/problems/insertion-sort-list/ 题意:对链表进行插入排序. 解题思路:首先来对插入排序有一个直观的认识,来自维基百科. 代码循环部分图示: 代码: class Solution: # @param head, a ListNode # @return a ListNode def insertionSortList(self, head): if not head: return head dummy = Lis

LeetCode :: Insertion Sort List [详细分析]

Sort a linked list using insertion sort. 仍然是一个非常简洁的题目,让我们用插入排序给链表排序:这里说到插入排序,可以来回顾一下, 最基本的入门排序算法,就是插入排序了:时间复杂度为n^2,最基本的插入排序是基于数组实现的,下面给出基于数组实现的插入排序,来体会一个插入排序的思想: 以下仅为数组实现,不是解题代码,没兴趣可以跳过. void insertionsort (int a[], int N) { for (int i = 1; i < N; i+

LeetCode: Insertion Sort List [147]

[题目] 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 Insertion Sort List

class Solution { public: ListNode *insertionSortList(ListNode *head) { if (head == NULL) return NULL; ListNode* sorted_head = head; ListNode* unsorted_head = head->next; head->next = NULL; ListNode* cur = unsorted_head; while (cur != NULL) { unsorte

Insertion Sort List(单链表插入排序)

来源:https://leetcode.com/problems/insertion-sort-list Sort a linked list using insertion sort. 方法: 1. 使用一个preHead指向头节点,这样在将节点插入头节点前面时(即某个节点值比头节点小)不需要进行特殊处理 2. 从头节点开始遍历,如果当前节点的下一个节点的值比当前节点的值大,就从头开始遍历找到第一个比当前节点的下一个节点的值大的节点,并插入到它的前面,注意插入时需要同时处理节点移出位置和插入位

[LeetCode]Insertion Sort

Sort a linked list using insertion sort. 这道题是要求用插入排序的方式对单链表进行排序. 先不考虑边界情况: 1. 将第一个结点看做有序区,之后的所有结点看做无序区. 2. 从第二个结点p开始,遍历有序区,知道遇到比结点p值大的结点q,将结点p插入到结点q之前. 3. 重复上述步骤直到链表遍历结束. 需要注意的是: 1. 遍历无序区时,需要保存当前结点的后继结点,以防指针丢失. 2. 若原链表为空,则直接返回NULL. 下面贴上代码: /** * Defi

LeetCode Insertion Sort List 链表插入排序

题意:给一个链表,实现插入排序. 思路:O(1)空间,O(n*n)复杂度.将排好的用另一个链表头串起来,那个链表头最后删掉,再返回链表. 1 /** 2 * Definition for singly-linked list. 3 * struct ListNode { 4 * int val; 5 * ListNode *next; 6 * ListNode(int x) : val(x), next(NULL) {} 7 * }; 8 */ 9 class Solution { 10 pub

【链表】Insertion Sort List

题目: Sort a linked list using insertion sort. 思路: 插入排序是一种O(n^2)复杂度的算法,基本想法相信大家都比较了解,就是每次循环找到一个元素在当前排好的结果中相对应的位置,然后插进去,经过n次迭代之后就得到排好序的结果了.了解了思路之后就是链表的基本操作了,搜索并进行相应的插入.时间复杂度是排序算法的O(n^2),空间复杂度是O(1). /** * Definition for singly-linked list. * function Lis