四种语言刷算法之对链表进行插入排序

Posted 2023-04-20 萌新w

力扣147. 对链表进行插入排序

1、C

/**
 * Definition for singly-linked list.
 * struct ListNode 
 *     int val;
 *     struct ListNode *next;
 * ;
 */
struct ListNode* insertionSortList(struct ListNode* head)
    struct ListNode* newHead = head;
    struct ListNode* p = newHead;
    struct ListNode* q = head->next;
    
    newHead->next = NULL;
    while(q!=NULL)
        struct ListNode* r = NULL;
        struct ListNode* temp = q;
        q = q->next;
        while(p!=NULL&&p->val<temp->val)
            r = p;
            p = p->next;
        
        if(r==NULL)
            temp->next = newHead;
            newHead = temp;
        
        else
            r->next = temp;
            temp->next = p;
        
        p = newHead;
    
    return newHead;

2、C++

/**
 * Definition for singly-linked list.
 * struct ListNode 
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) 
 *     ListNode(int x) : val(x), next(nullptr) 
 *     ListNode(int x, ListNode *next) : val(x), next(next) 
 * ;
 */
class Solution 
public:
    ListNode* insertionSortList(ListNode* head) 
        ListNode* newHead = head;
        ListNode* q = head->next;
        newHead->next = nullptr;
        while(q!=nullptr)
            ListNode* p = newHead;
            ListNode* temp = q;
            ListNode* r = newHead;
            q = q->next;
            while(p!=nullptr&&temp->val>p->val)
                r = p;
                p = p->next;
            
            if(r==p)
                temp->next = newHead;
                newHead = temp;
            
            else
                r->next = temp;
                temp->next = p;
            
        
        return newHead;
    
;

3、JAVA

/**
 * Definition for singly-linked list.
 * public class ListNode 
 *     int val;
 *     ListNode next;
 *     ListNode() 
 *     ListNode(int val)  this.val = val; 
 *     ListNode(int val, ListNode next)  this.val = val; this.next = next; 
 * 
 */
class Solution 
    public ListNode insertionSortList(ListNode head) 
        ListNode newHead = head;
        ListNode q = head.next;
        newHead.next = null;
        while(q!=null)
            ListNode p = newHead;
            ListNode r = newHead;
            ListNode temp = q;
            q = q.next;
            while(p!=null&&p.val<temp.val)
                r = p;
                p = p.next;
            
            if(r==p)
                temp.next = newHead;
                newHead = temp;
            
            else
                r.next = temp;
                temp.next = p;
            
        
        return newHead;
    

4、Python

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def insertionSortList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        newHead = head
        q = head.next
        newHead.next = None
        while(q is not None):
            p = newHead
            r = newHead
            temp = q
            q = q.next
            while(p is not None and p.val<temp.val):
                r = p
                p = p.next
            if(r==p):
                temp.next = newHead
                newHead = temp
            else:
                r.next = temp
                temp.next = p
        return newHead

279，对链表进行插入排序

对链表进行插入排序。

插入排序的动画演示如上。从第一个元素开始，该链表可以被认为已经部分排序（用黑色表示）。

每次迭代时，从输入数据中移除一个元素（用红色表示），并原地将其插入到已排好序的链表中。

插入排序算法：

1. 插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。

2. 每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，并将其插入。

3. 重复直到所有输入数据插入完为止。

   
   

示例 1：

输入: 4->2->1->3
输出: 1->2->3->4

示例 2：

输入: -1->5->3->4->0
输出: -1->0->3->4->5

答案：

 1public ListNode insertionSortList(ListNode head) {
 2    if (head == null)
 3        return head;
 4    ListNode helper = new ListNode(0);
 5    ListNode cur = head;
 6    ListNode pre = helper;
 7    ListNode next = null;
 8    while (cur != null) {
 9        next = cur.next;
10        while (pre.next != null && pre.next.val < cur.val) {
11            pre = pre.next;
12        }
13        cur.next = pre.next;
14        pre.next = cur;
15        pre = helper;
16        cur = next;
17    }
18    return helper.next;
19}

解析：

关于排序前面我们介绍了十几种排序算法，这里让使用插入排序，其实插入排序并不难，这里难的是链表的断开和重连。当然我们还可以使用其他的方法，比如我们把链表的每一个节点全部断开，然后存放到数组中，接着在排序，最后再把排序好的数组按顺序全部再连接起来即可。关于排序算法可以看下