<算法>基于三路划分的链表快速排序

最新推荐文章于 2025-01-15 21:09:49 发布

原创最新推荐文章于 2025-01-15 21:09:49 发布 · 627 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法

算法专栏收录该内容

17 篇文章

订阅专栏

本文介绍了一种基于三路划分快速排序思想的链表排序算法。通过将链表拆分为小于、等于、大于头结点的三个子链表，并递归地对小链表和大链表进行排序，最终实现整个链表的有序排列。

此算法基于三路划分的快速排序的思想，如果不懂请先看我之前的博客：
http://blog.youkuaiyun.com/gpwner/article/details/76039533

但是又不完全和之前将的三路划分完全一样

下面开始进入正题：
首先得到一个链表之后，我们将链表拆分为小于、等于、大于头结点的子链表：
这里写图片描述

然后再递归调用算法，将小链表和大链表进行排序，最后再将链表连接成一个与原来的链表一样的链表。

递归结束的条件是：

头结点为null或者链表只有一个节点（也就是说只有头结点）

链表节点的定义：

/**
 * @version 2017/7/30 14:57
 */
public class ListNode {
    int val;
    ListNode next;

    ListNode(int x) {
        val = x;
    }
}

public class Main {
    public static void main(String[] args) {
        Main main = new Main();
        ListNode node1 = new ListNode(10);
        ListNode node2 = new ListNode(5);
        ListNode node3 = new ListNode(2);
        ListNode node4 = new ListNode(11);
        ListNode node5 = new ListNode(2);
        ListNode node6 = new ListNode(8);
        ListNode node7 = new ListNode(9);
        ListNode node8 = new ListNode(7);
        ListNode node9 = new ListNode(6);

        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;
        node5.next = node6;
        node6.next = node7;
        node7.next = node8;
        node8.next = node9;

        node1 = main.sortList(node1);
        while (node1 != null) {
            System.out.print(node1.val + " ");
            node1 = node1.next;
        }

    }

    public ListNode sortList(ListNode head) {
        if (head == null || head.next == null)
            return head;

        int val = head.val;
        ListNode smaller = null;
        ListNode smaller_head = null;
        ListNode mid = head;
        ListNode larger = null;
        ListNode larger_head = null;

        ListNode iter = head.next;
        while (iter != null) {
            //大于头结点
            if (iter.val < val) {
                if (smaller_head == null) {
                    smaller_head = iter;
                } else {
                    smaller.next = iter;
                }
                smaller = iter;
                //等于头结点
            } else if (iter.val == val) {
                mid.next = iter;
                mid = iter;
                //小于头结点
            } else {
                if (larger_head == null) {
                    larger_head = iter;
                } else {
                    larger.next = iter;
                }
                larger = iter;
            }
            iter = iter.next;
        }
        //将小链表的末端指针置为null
        if (smaller != null)
            smaller.next = null;
        //将大链表的末指针置为null
        if (larger != null)
            larger.next = null;
        mid.next = sortList(larger_head);
        //可能会出现头结点是最小的节点的情况
        if (smaller == null) {
            return head;
        }

        smaller_head = sortList(smaller_head);
        smaller = smaller_head;
        while (smaller.next != null)
            smaller = smaller.next;
        //将小链表重新连接上
        smaller.next = head;
        return smaller_head;
    }
}