用java写一个递归排序

可以使用以下代码实现递归排序：

public static void recursiveSort(int[] arr, int left, int right) {
if (left < right) {
int pivot = partition(arr, left, right);
recursiveSort(arr, left, pivot - 1);
recursiveSort(arr, pivot + 1, right);
}
}

public static int partition(int[] arr, int left, int right) {
int pivot = arr[right];
int i = left - 1;
for (int j = left; j < right; j++) {
if (arr[j] < pivot) {
i++;
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
int temp = arr[i + 1];
arr[i + 1] = arr[right];
arr[right] = temp;
return i + 1;
}

相关问题

用java写一个快速排序

### 回答1：
好的，这是一个简单的 Java 实现快速排序的代码：

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = { 3, 7, 1, 4, 6, 2, 9, 8, 5 };
        quickSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }

    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int index = partition(arr, low, high);
            quickSort(arr, low, index - 1);
            quickSort(arr, index + 1, high);
        }
    }

    public static int partition(int[] arr, int low, int high) {
        int pivot = arr[low];
        while (low < high) {
            while (low < high && arr[high] >= pivot) {
                high--;
            }
            arr[low] = arr[high];
            while (low < high && arr[low] <= pivot) {
                low++;
            }
            arr[high] = arr[low];
        }
        arr[low] = pivot;
        return low;
    }
}

快速排序的思路是：选取一个基准元素，将数组分为左右两个部分，左边的元素均小于基准元素，右边的元素均大于基准元素，然后对左右两个部分分别进行递归排序，直至整个数组有序。这个实现中，我们选取了数组的第一个元素作为基准元素，然后使用两个指针从两端向中间移动，不断交换元素，最终完成一轮划分。

### 回答2：
快速排序（Quick Sort）是一种常用的排序算法，它通过将待排序的序列分割成小于基准值和大于基准值的两个子序列，然后对子序列进行递归排序，最终得到有序序列。

下面是用Java实现快速排序的代码：

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 9, 1, 3};
        quickSort(arr, 0, arr.length - 1);
        
        // 输出排序后的结果
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
    
    public static void quickSort(int[] arr, int left, int right) {
        if (left < right) {
            int pivotIndex = partition(arr, left, right);   // 获取基准值的索引位置
            quickSort(arr, left, pivotIndex - 1);   // 对左侧子序列进行排序
            quickSort(arr, pivotIndex + 1, right);  // 对右侧子序列进行排序
        }
    }
    
    public static int partition(int[] arr, int left, int right) {
        int pivot = arr[left];   // 选择第一个元素作为基准值
        int i = left, j = right;
        
        while (i < j) {
            while (i < j && arr[j] >= pivot) {
                j--;
            }
            if (i < j) {
                arr[i++] = arr[j];
            }
            
            while (i < j && arr[i] <= pivot) {
                i++;
            }
            if (i < j) {
                arr[j--] = arr[i];
            }
        }
        
        arr[i] = pivot;   // 将基准值放入最终位置
        return i;
    }
}

以上代码实现了快速排序的核心逻辑，通过选择第一个元素作为基准值，不断地从序列两端找到比基准值大和比基准值小的元素，然后进行交换。最终，分割点左侧的元素都比基准值小，右侧的元素都比基准值大。然后对左右子序列进行递归排序，直到排序完成。最终输出排序后的结果为：1 2 3 5 8 9。

### 回答3：
快速排序是一种常用的排序算法，其基本思想是通过选择一个枢轴（pivot），将数组分为左右两个子数组，使得左子数组的元素都比枢轴小，右子数组的元素都比枢轴大，然后对左右子数组分别进行递归快速排序，直到子数组的长度为1或0为止。

以下是用Java语言实现的快速排序算法示例：

public class QuickSort {
    public static void quickSort(int[] array, int low, int high) {
        if (low < high) {
            int pivotIndex = partition(array, low, high);
            quickSort(array, low, pivotIndex - 1);
            quickSort(array, pivotIndex + 1, high);
        }
    }

    private static int partition(int[] array, int low, int high) {
        int pivot = array[low];
        while (low < high) {
            while (low < high && array[high] >= pivot) {
                high--;
            }
            array[low] = array[high];
            while (low < high && array[low] <= pivot) {
                low++;
            }
            array[high] = array[low];
        }
        array[low] = pivot;
        return low;
    }

    public static void main(String[] args) {
        int[] array = {9, 5, 7, 4, 2, 8, 1, 6, 3};
        quickSort(array, 0, array.length - 1);
        for (int num : array) {
            System.out.print(num + " ");
        }
    }
}

以上代码实现了快速排序算法。在`quickSort`方法中，选择数组的第一个元素作为枢轴，然后调用`partition`方法将数组分为两部分并返回枢轴的下标。接着递归调用`quickSort`方法对左右子数组进行排序。`partition`方法通过比较枢轴和数组元素的大小，交换元素位置，最终将枢轴放到正确的位置上。

在`main`方法中，我们定义了一个测试数组`array`，然后调用`quickSort`方法对其进行排序，并输出结果。通过运行程序，可以验证快速排序算法的正确性。

用Java写一个快速排序

### 回答1：
下面是Java实现快速排序的代码：

public static void quickSort(int[] arr, int left, int right) {
    if (left < right) {
        int pivot = partition(arr, left, right);
        quickSort(arr, left, pivot - 1);
        quickSort(arr, pivot + 1, right);
    }
}

public static int partition(int[] arr, int left, int right) {
    int pivot = arr[right];
    int i = left - 1;
    for (int j = left; j < right; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(arr, i, j);
        }
    }
    swap(arr, i + 1, right);
    return i + 1;
}

public static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

快速排序的基本思想是选取一个元素作为基准值，然后将比基准值小的元素放在其左边，比基准值大的元素放在其右边，再对左右两部分分别进行递归排序。具体实现可以采用分治法，每次选取一个基准值，将数组分成两个部分，左边的元素都比基准值小，右边的元素都比基准值大。这个过程叫做partition操作。

### 回答2：
快速排序（Quicksort）是一种常用的排序算法，它的基本思想是通过递归地分治策略将一个大问题拆分为若干个小问题，并通过交换元素位置的方式将小问题逐一解决，最后得到有序序列。

以下是用Java语言实现快速排序的代码：

public class QuickSort {
    public static void main(String[] args) {
        int[] array = {9, 5, 7, 1, 4, 3, 6, 2, 8};
        quickSort(array, 0, array.length - 1);
        System.out.println("排序结果：" + Arrays.toString(array));
    }

    public static void quickSort(int[] array, int left, int right) {
        if (left < right) {
            int pivot = partition(array, left, right);
            quickSort(array, left, pivot - 1);
            quickSort(array, pivot + 1, right);
        }
    }

    public static int partition(int[] array, int left, int right) {
        int pivot = array[left]; // 取第一个元素作为枢纽元
        int i = left;
        int j = right;
        while (i < j) {
            // 从右向左找第一个小于等于枢纽元的元素
            while (i < j && array[j] >= pivot) {
                j--;
            }
            if (i < j) {
                array[i] = array[j]; // 将小于等于枢纽元的元素移到左边
                i++;
            }

            // 从左向右找第一个大于枢纽元的元素
            while (i < j && array[i] <= pivot) {
                i++;
            }
            if (i < j) {
                array[j] = array[i]; // 将大于枢纽元的元素移到右边
                j--;
            }
        }
        array[i] = pivot; // 将枢纽元放回正确的位置
        return i;
    }
}

这段代码中，我们定义了一个`quickSort`函数来进行快速排序，其中包含了一个递归调用。在`quickSort`函数中，我们首先通过`partition`函数选择一个枢纽元，并把数组拆分为两部分。然后，对左边部分和右边部分分别递归调用`quickSort`函数，直到拆分到单个元素时停止。`partition`函数负责将数组元素按照枢纽元进行交换，使得左边的元素都小于枢纽元，右边的元素都大于枢纽元。

最后，在主函数中，我们定义一个待排序的整型数组，调用`quickSort`函数进行排序，然后输出排序结果。

运行代码，得到的输出结果为：[1, 2, 3, 4, 5, 6, 7, 8, 9]，即为按照从小到大排序后的结果。

### 回答3：
快速排序（Quick Sort）是一种基于分治策略的排序算法，算法的基本思想是通过一次分割将待排序序列分成两部分，其中左子序列的元素都比分割元素小，右子序列的元素都比分割元素大，然后再对这两部分序列进行递归排序，最终得到有序序列。

下面是用Java编写的快速排序算法实现：

public class QuickSort {

    public static void main(String[] args) {
        int[] nums = {5, 2, 9, 3, 6, 8, 1, 7, 4};
        quickSort(nums, 0, nums.length - 1);
        
        for (int num : nums) {
            System.out.print(num + " ");
        }
    }

    public static void quickSort(int[] nums, int low, int high) {
        if (low < high) {
            int pivotIndex = partition(nums, low, high);
            quickSort(nums, low, pivotIndex - 1);
            quickSort(nums, pivotIndex + 1, high);
        }
    }

    public static int partition(int[] nums, int low, int high) {
        int pivot = nums[low]; // 选择第一个元素为分割元素
        int i = low + 1; // 左侧子序列的起始位置
        
        for (int j = low + 1; j <= high; j++) {
            if (nums[j] < pivot) {
                // 将小于分割元素的元素交换到左侧子序列
                int temp = nums[i];
                nums[i] = nums[j];
                nums[j] = temp;
                
                i++;
            }
        }
        
        // 将分割元素放置到正确的位置
        int temp = nums[low];
        nums[low] = nums[i - 1];
        nums[i - 1] = temp;
        
        return i - 1;
    }
}

这段代码通过递归的方式实现快速排序，首先选取一个分割元素，将小于该元素的数都交换到左侧子序列，然后递归地对左右子序列进行快速排序，直到排序完成得到有序序列。在每次分割过程中，通过比较和交换操作将元素放到合适的位置，从而实现排序的目的。最后将排序后的结果输出。

以上是一个简单的快速排序的示例，实际应用中还需要考虑各种边界条件的处理，以及对不同类型数据的适应性等问题。