New_Sort_Integer_Sequential解析

import java.util.ArrayList;
public class New_Sort_Integer_Sequential {

static void sort(ArrayList<Integer> list, Integer left, Integer right) {
if (right <= left)
return;
Integer s = part(list, left, right);
sort(list, left, s - 1);
sort(list, s + 1, right);
}

static Integer part(ArrayList<Integer> list, Integer left, Integer right) {
assert(left < right);
Integer i = left - 1, j = right;
for(;;) {
while (compare(list.get(++i), list.get(right)))
;
while (compare(list.get(right), list.get(--j)))
if (j.equals(left))
break;
if (i >= j)
break;
swap(list, i, j);
}
swap(list, i, right);
return i;
}

static boolean compare(Integer x, Integer y) {
return x < y;
}


static void swap(ArrayList<Integer> list, Integer i, Integer j) {
Integer h = list.get(i);
list.set(i, list.get(j));
list.set(j, h);
}


public static void main(String[] args) {
// We test the sorting procedure with a list of random integer objects
Integer n = 100000;
ArrayList<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < n; i++)
list.add((int) Math.ceil(Math.random() * n));
sort(list, 0, n-1);
for (int i = 0; i < n; i++) {
System.out.print(list.get(i) + ", ");
if(i > 0 && i % 20 == 0)
System.out.println();
}
}

}

 

 

快速排序核心笔记（Java 实现）

 

🔁 sort 函数：快速排序主逻辑

java

static void sort(ArrayList<Integer> list, Integer left, Integer right) {
    if (right <= left)
        return;

    Integer s = part(list, left, right);

    sort(list, left, s - 1);
    sort(list, s + 1, right);
}

✨ 功能说明：

• 对 list[left..right] 区间进行排序。

• 使用快速排序（Quicksort）递归地处理左右子区间。

🧠 步骤解析：

1. 边界检查：如果区间为空或只有一个元素，直接返回。

2. 分区操作：调用 part 函数，确定基准值位置 s。

3. 递归排序：

   • 左半部分：sort(list, left, s - 1)

   • 右半部分：sort(list, s + 1, right)

 

🔍 part 函数：分区核心逻辑

java

static Integer part(ArrayList<Integer> list, Integer left, Integer right) {
    assert(left < right);

    Integer i = left - 1, j = right;

    for (;;) {
        while (compare(list.get(++i), list.get(right)))
            ;

        while (compare(list.get(right), list.get(--j)))
            if (j.equals(left))
                break;

        if (i >= j)
            break;

        swap(list, i, j);
    }

    swap(list, i, right);

    return i;
}

✨ 功能说明：

• 以 list[right] 为基准值，将区间 [left..right] 分成两部分：

  • 左边：小于基准值

  • 右边：大于等于基准值

• 返回分区点 i，供 sort 函数递归使用。

🧠 步骤解析：

1. 初始化指针：

   • i = left - 1：从左边界前一个位置开始

   • j = right：从右边界开始

2. 循环分区：

   • 从左向右找第一个 ≥ pivot 的元素

   • 从右向左找第一个 ≤ pivot 的元素

   • 如果 i < j，交换 list[i] 和 list[j]

   • 如果 i ≥ j，结束循环

3. 放置基准值：

   • 将 pivot 放到 i 位置

   • 返回 i 作为分区点

 

⚖️ compare 函数：比较两个整数

java

static boolean compare(Integer x, Integer y) {
    return x < y;
}

✨ 功能说明：

• 判断 x 是否小于 y。

• 用于分区逻辑中判断元素是否需要移动。

 

🔄 swap 函数：交换两个元素位置

java

static void swap(ArrayList<Integer> list, Integer i, Integer j) {
    Integer h = list.get(i);
    list.set(i, list.get(j));
    list.set(j, h);
}

✨ 功能说明：

• 交换列表中第 i 和第 j 个元素。

• 用于将不在正确位置的元素调换。

 

🧪 main 函数：测试排序效果

java

public static void main(String[] args) {
    Integer n = 100000;
    ArrayList<Integer> list = new ArrayList<>();

    for (int i = 0; i < n; i++)
        list.add((int) Math.ceil(Math.random() * n));

    sort(list, 0, n - 1);

    for (int i = 0; i < n; i++) {
        System.out.print(list.get(i) + ", ");
        if (i > 0 && i % 20 == 0)
            System.out.println();
    }
}

✨ 功能说明：

• 创建一个包含 100000 个随机整数的列表。

• 使用快速排序对整个列表排序。

• 打印排序后的结果，每 20 个元素换一行。

 

📌 快速排序核心思想总结

• 分而治之：每次选一个基准值，把列表分成左右两部分。

• 递归排序：分别对左右部分继续排序。

• 高效性：平均时间复杂度是 O(n log n)，空间复杂度是 O(log n)。