写一段排序算法，Java实现

好的，以下是一个快速排序算法的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);
}
}

private 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 static void quickSort(int[] arr, int low, int high) {
if (arr == null || arr.length == 0)
return;

if (low >= high)
return;

// 找寻基准数据的正确索引
int middle = getMiddle(arr, low, high);

// 进行迭代对分段数组进行排序
quickSort(arr, low, middle-1);
quickSort(arr, middle+1, high);
}

public static int getMiddle(int[] arr, int low, int high) {
// 数组的第一个作为中轴
int tmp = arr[low];

while (low < high) {
while (low < high && arr[high] >= tmp) {
high--;
}

// 比中轴小的记录移到低端
arr[low] = arr[high];
while (low < high && arr[low] <= tmp) {
low++;
}

// 比中轴大的记录移到高端
arr[high] = arr[low];
}

// 中轴记录到尾
arr[low] = tmp;
// 返回中轴的位置
return low;
}

### 回答2：
快速排序是一种常用的排序算法，其基本思想是选择一个基准元素，将数组分为两个部分，左侧部分的元素都小于基准元素，右侧部分的元素都大于基准元素，然后递归地对左右两部分进行排序，直到整个数组有序。

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

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

    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);
        }
    }

    public 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;
    }
}

以上代码中，`quickSort`方法接受一个数组和两个索引作为参数，在每次递归调用中，根据基准元素将数组分为两部分，并对两部分进行排序。`partition`方法用于实现分区操作，将数组中的元素按照基准元素分成两部分。最后通过递归调用，整个数组就会有序。

示例中的数组经过排序后的结果为 [1, 2, 3, 4, 5, 6, 7, 8, 9]。

### 回答3：
快速排序（Quicksort）是一种基于分治思想的排序算法。它通过选择一个基准元素，将数组分为左右两个部分，并将小于基准的元素放在左边，大于基准的元素放在右边。然后再对左右两部分递归地进行快速排序，直到整个数组有序。

以下是用Java实现的快速排序算法：

public class QuickSort {
    public static void sort(int[] arr, int low, int high) {
        if (arr == null || arr.length == 0) {
            return;
        }
        
        if (low >= high) {
            return;
        }
        
        int pivot = arr[low + (high - low) / 2];
        int left = low;
        int right = high;
        
        while (left <= right) {
            while (arr[left] < pivot) {
                left++;
            }
            
            while (arr[right] > pivot) {
                right--;
            }
            
            if (left <= right) {
                int temp = arr[left];
                arr[left] = arr[right];
                arr[right] = temp;
                
                left++;
                right--;
            }
        }
        
        if (low < right) {
            sort(arr, low, right);
        }
        
        if (high > left) {
            sort(arr, left, high);
        }
    }
    
    public static void main(String[] args) {
        int[] arr = {4, 2, 6, 8, 3, 1, 5, 7};
        int low = 0;
        int high = arr.length - 1;
        
        sort(arr, low, high);
        
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

以上代码定义了一个`QuickSort`类，其中`sort`方法接收一个数组`arr`和两个索引`low`、`high`，用于表示待排序部分的起始和结束位置。在`sort`方法内部，首先判断输入的数组是否为空或者长度为0，若是，则直接返回。然后，选择基准元素`pivot`，并初始化左右指针`left`和`right`。接下来，进行循环，将小于基准的元素放在左边，大于基准的元素放在右边，直到左指针大于右指针。最后，对左右两部分分别递归调用`sort`方法，直到整个数组有序。

在`main`方法中，我们创建一个测试数组`arr`，并传入起始和结束位置调用`sort`方法。最后，我们遍历输出排序后的数组。

以上就是用Java实现的快速排序算法。快速排序的时间复杂度为O(nlogn)，是一种高效的排序算法。

写一段java 冒泡排序算法

好的，以下是用Java编写的冒泡排序算法：

public static void bubbleSort(int[] arr) {
    int n = arr.length; 
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // swap arr[j] and arr[j+1]
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

这个算法使用了嵌套循环，在每次循环中比较相邻的两个元素，如果它们的顺序不正确，则进行交换。

请注意，这只是一种简单的排序算法，并不适用于大型数据集。更高效的算法如快速排序和归并排序更适合大型数据集的排序。