【LeetCode每日一题】——147.对链表进行插入排序

一【题目类别】

• 链表

二【题目难度】

• 中等

三【题目编号】

• 147.对链表进行插入排序

四【题目描述】

• 对链表进行插入排序。
• 注：插入排序的动画演示gif暂时出了一点问题，后续会补充上，读者可以百度一下插入排序的主要思想，我想大家应该都明白
• 插入排序的动画演示如上。从第一个元素开始，该链表可以被认为已经部分排序（用黑色表示）。
  每次迭代时，从输入数据中移除一个元素（用红色表示），并原地将其插入到已排好序的链表中。
• 插入排序算法：
• 插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。
• 每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，并将其插入。
• 重复直到所有输入数据插入完为止。

五【题目示例】

• 示例 1：
  输入: 4->2->1->3
  输出: 1->2->3->4
• 示例 2：
  输入: -1->5->3->4->0
  输出: -1->0->3->4->5

六【解题思路】

• 这种题肯定要设置一个pre前驱指针方便指针的链接和删除，所以pre指向头部位置，然后循环整个链表，挨个比较，如果两两之间有序，那么指针后移，如果两两之间无序，pre前驱指针从头开始向后找插入位置，然后插入即可，有个小细节就是要先把待插入指针的后继指针连接到head指针，否则pre的后继指针连接到待插入结点就无法给当前结点的后继结点链接了

七【时间频度】

• 时间复杂度：$O(N^2)$

八【代码实现】

1. Java语言版

package LinkedList;

public class p147_InsertionSortList {

    int val;

    p147_InsertionSortList next;

    p147_InsertionSortList(int x) {
        this.val = x;
    }

    public static void main(String[] args) {
        p147_InsertionSortList num1 = new p147_InsertionSortList(4);
        p147_InsertionSortList num2 = new p147_InsertionSortList(2);
        p147_InsertionSortList num3 = new p147_InsertionSortList(1);
        p147_InsertionSortList num4 = new p147_InsertionSortList(3);
        num1.next = num2;
        num2.next = num3;
        num3.next = num4;
        p147_InsertionSortList res = insertionSortList(num1);
        while (res != null) {
            System.out.print(res.val + " ");
            res = res.next;
        }
    }

    public static p147_InsertionSortList insertionSortList(p147_InsertionSortList head) {
        // 如果为空直接返回
        if (head == null || head.next == null) {
            return head;
        }
        // 首先定义指向头结点的指针
        p147_InsertionSortList newHead = new p147_InsertionSortList(Integer.MIN_VALUE);
        newHead.next = head;
        // 定义前驱结点和链表指针
        p147_InsertionSortList cur = head;
        p147_InsertionSortList pre = newHead;
        // 遍历每一个结点
        while (cur != null) {
            // 如果待插入值小于基准值，那么进入查找插入位置并交换的代码
            if (cur.val < pre.val) {
                // 首先定义新的头节点，这个不是传统的最开始的结点，而是插入的那个头结点
                p147_InsertionSortList newIndex = newHead.next;
                // 定义新的前驱结点，这个newPre最后是待插入结点的前驱的前驱，用于链的修改
                p147_InsertionSortList newPre = newHead;
                // 这步很重要，如果newIndex==pre，说明找到了待插入结点，否则需要向下查找插入位置；并且如果newIndex.val<cur.val，说明这个结点不能被待插入结点插入，需要向下查找找到可以插入的位置
                while (newIndex != pre && newIndex.val < cur.val) {
                    newIndex = newIndex.next;
                    newPre = newPre.next;
                }
                // 已经找到待插入位置，首先将pre指向cur的下一个，断开pre和cur的连接
                pre.next = cur.next;
                // 然后cur指向插入位置，新建连接
                cur.next = newIndex;
                // 修改cur的前驱，将newPre指向cur，也就是修改之前的待插入结点的前驱的前驱不再指向pre，而是指向cur，因为cur和pre交换了位置
                newPre.next = cur;
                // 因为还需要继续排序，所以cur继续向下，此时cur为pre的下一个，也就是之前cur的下一个
                cur = pre.next;
            }
            // 否则两个指针继续向下比较
            else {
                cur = cur.next;
                pre = pre.next;
            }
        }
        // 最后返回头结点
        return newHead.next;
    }

}

2. C语言版

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

struct ListNode
{
	int val;
	struct ListNode *next;
};

struct ListNode* insertionSortList(struct ListNode* head)
{
	/*如果为空直接返回*/
	if (head == NULL || head->next == NULL)
	{
		return head;
	}
	/*首先定义指向头结点的指针*/
	struct ListNode* newHead = (struct ListNode*)malloc(sizeof(struct ListNode));
	newHead->next = head;
	struct ListNode* cur = head->next;
	struct ListNode* pre = newHead->next;
	/*遍历每一个结点*/
	while (cur != NULL)
	{
		/*如果待插入值小于基准值，那么进入查找插入位置并交换的代码*/
		if (cur->val < pre->val)
		{
			/*首先定义新的头节点，这个不是传统的最开始的结点，而是插入的那个头结点*/
			struct ListNode* newIndex = newHead->next;
			/*定义新的前驱结点，这个newPre最后是待插入结点的前驱的前驱，用于链的修改*/
			struct ListNode* newPre = newHead;
			/*这步很重要，如果newIndex==pre，说明找到了待插入结点，否则需要向下查找插入位置；并且如果newIndex.val<cur.val，说明这个结点不能被待插入结点插入，需要向下查找找到可以插入的位置*/
			while (newIndex != pre && newIndex->val < cur->val)
			{
				newIndex = newIndex->next;
				newPre = newPre->next;
			}
			/*已经找到待插入位置，首先将pre指向cur的下一个，断开pre和cur的连接*/
			pre->next = cur->next;
			/*然后cur指向插入位置，新建连接*/
			cur->next = newIndex;
			/*修改cur的前驱，将newPre指向cur，也就是修改之前的待插入结点的前驱的前驱不再指向pre，而是指向cur，因为cur和pre交换了位置*/
			newPre->next = cur;
			/*因为还需要继续排序，所以cur继续向下，此时cur为pre的下一个，也就是之前cur的下一个*/
			cur = pre->next;
		}
		/*否则两个指针继续向下比较*/
		else
		{
			cur = cur->next;
			pre = pre->next;
		}
	}
	/*最后返回头结点*/
	return newHead->next;
}

九【提交结果】

1. Java语言版
   
2. C语言版