排序算法工具类

说明

1. Sort类是一个提供测试排序算法的模板类和工具类
2. 具体使用案例, 在排序专栏的其它文章中

public abstract class Sort {

    public abstract void sortNums(int[] nums);

    public void sortClazz(Clazz[] array) { }

    /**
     * 排序算法耗时
     */
    public void timeTest(int times) {
        //创建8w随机数组，进行测试运行时间
        //创建数组
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        int[] nums = new int[times];
        for (int i = 0; i < times; i++) {
            nums[i] = (int)(Math.random() * times + 1);//[1, 80001)
        }
        //记录开始时间
        Date date1 = new Date();
        String date1Str = simpleDateFormat.format(date1);
        System.out.println("排序开始时间：" + date1Str);

        sortNums(nums);

        Date date2 = new Date();
        System.out.println("结束时间:  " + simpleDateFormat.format(date2));
    }

    /**
     * 使用一个给定数组,测试排序算法正确性
     */
    public void correctTest(int[] nums) {
        if (nums == null) {
            nums = new int[]{7, 9, 1, 1, 6 ,3, 5, 9, 8, 0, 0, 6, 2, 4};
        }
        int[] toBeSorted = Arrays.copyOf(nums, nums.length);
        System.out.print("原数组---: ");
        System.out.println(Arrays.toString(nums));
        Arrays.sort(nums);
        System.out.print("原数组升序: ");
        System.out.println(Arrays.toString(nums));
        sortNums(toBeSorted);
        System.out.print("\n排序后数组: ");
        System.out.println(Arrays.toString(toBeSorted));
        System.out.print("\n原数组降序: [");
        for (int i = nums.length - 1; i >= 0; i--) {
            System.out.print(nums[i] + ", ");
        }
        System.out.println();
    }

    /**
     * 测试排序算法在对象数组的效果
     */
    public void testClazz() {
        Clazz a1 = new Clazz("abc");
        Clazz a2 = new Clazz("bcd");
        Clazz a3 = new Clazz("def");
        Clazz a4 = new Clazz("efg");
        Clazz[] array = {a1, a3, a2, a4};
        System.out.print("\n原数组  : ");
        System.out.println(Arrays.toString(array));
        sortClazz(array);
        System.out.print("排序后数组: ");
        System.out.println(Arrays.toString(array));
    }

    /**
     * 交换数组中两个数
     */
    public static void swap(int[] nums, int index1, int index2) {
        int temp = nums[index1];
        nums[index1] = nums[index2];
        nums[index2] = temp;
    }
}

3. LC 86. 分隔链表 我的实现代码

class Solution {
    // 划分区间的方式, 即快排的一种partition()函数的写法. 这么看这种方法可以做到对链表进行稳定移动,则快排的链表形式可以实现稳定排序
    // 技巧:使用dummy头节点,便于添加操作
    public ListNode partition(ListNode head, int x) {
        ListNode dummyHead = new ListNode();
        dummyHead.next = head;
        ListNode minRight = dummyHead; //该指针后面的元素(假设为i), i前面的元素(不包括i)都是小于x的区间
         //1.遍历指针,同时也表示从[i,cur]的元素都是大于等于x的区间.所以遇到小于x的节点,就要插到i前面. 
         //2.从dummyHead开始是因为移动cur就等价于删除cur后添加到i之前,所以要指向cur之前的元素.注释中的cur代表被遍历到的节点,curPre代表cur的指针,指向cur前一个节点位置
         //3.这和快排的一种写法一样,只是由操作数组变成了操作链表
        ListNode curPre = dummyHead;
        if (curPre == null) {
            System.out.println(curPre.val);
            return null;
        }

        while(curPre != null && curPre.next != null) {
            ListNode cur = curPre.next;
            
            if (cur.val < x && curPre == minRight) {// 遍历的就是小于的值,那么不用向前调整,原因上面说了
                curPre = curPre.next;
                minRight = minRight.next;
            } else { // 如果小于区间落下了,即区分出了两个区间,说明后序有向前调整操作
                if (cur.val < x) {
                    ListNode temp = cur.next;
                    cur.next = minRight.next;
                    minRight.next = cur;
                    curPre.next = temp;
                    minRight = minRight.next;
                } else {
                    curPre = curPre.next;
                }
            }
        }
        return dummyHead.next;
    }
}