Java 快速排序-递归

我尝试用两种方式编写快速排序代码，一种是就地编写，另一种是使用单独的数组编写。我有点被一些逻辑所束缚，看看我有什么，提前谢谢你的帮助

public List<Integer> sort(List<Integer> arr){
  if(arr.length > 0)
    List<Integer> ret = new ArrayList<Integer>();
  ret = quickSort(arr);
  return ret;
 }

public List<Integer> quickSort(List<Integer> arr){
  if(arr.length < 2)
    return;

  int pivot = arr[0];
  List<Integer> left = new ArrayList<Integer>();
  List<Integer> right = new ArrayList<Integer>();

  for(int i = 0; i < arr.length; i++){
    if(arr[i] <= pivot)
      left.add(arr[i]);
    else
      right.add(arr[i]);
  }
  quickSort(left);
  quickSort(right);

}

公共列表排序（列表arr）{
如果（arr.length>0）
List ret=new ArrayList（）；
ret=快速排序（arr）；
返回ret；
}
公共列表快速排序（列表arr）{
如果（arr.length<2）
返回；
int pivot=arr[0]；
左列表=新建ArrayList（）；
List right=new ArrayList（）；
对于（int i=0；i如果（arr[i]您需要将
左
和
右
序列组合在一起。您需要在算法结束时（在关闭
}
之前）执行此操作。在伪代码中：

int leftpos = 0, rightpos = 0;
List newlist = new ArrayList();
for(int pos = 0; pos < arr.length; pos++)
  if left[pos] < right[pos] newlist.add(left[leftpos++]);
    else newlist.add(right[rightpos++]);
return newlist;

您需要将
左
和
右
序列组合在一起。您需要在算法结束时（在关闭
}
之前）进行组合。在伪代码中：

int leftpos = 0, rightpos = 0;
List newlist = new ArrayList();
for(int pos = 0; pos < arr.length; pos++)
  if left[pos] < right[pos] newlist.add(left[leftpos++]);
    else newlist.add(right[rightpos++]);
return newlist;

让我为你试一下

首先，除非您使用的是链表，否则您总是希望进行就地排序（即使这样，转换为数组、就地排序，然后再转换回链表通常也是值得的——这对垃圾收集器的压力要小得多）…网络列表实际上是在扩展数组

接下来，快速排序实际上是关于透视操作的。这里有一种方法：

// Quicksort the sub-array xs[lo..hi].
void QSort(int[] xs, int lo, int hi) {
    if (hi <= lo) return; // Don't sort empty or singleton sub-arrays.
    var p = [choose some pivot value from xs[lo..hi]];
    var a = lo; // Invariant: x[lo..a - 1] <= p.
    var z = hi; // Invariant: p < x[z + 1..hi].
    while (a <= z) {
        if (xs[a] <= p) a++; else Swap(xs, a, z--);
    }
    QSort(xs, lo, a - 1); // Sort the items <= p.
    QSort(xs, z + 1, hi); // Sort the items > p.
}

void Swap(int[] xs, int i, int j) {
    var tmp = xs[i];
    xs[i] = xs[j];
    xs[j] = tmp;
}

//对子数组xs[lo..hi]进行快速排序。
无效QSort（int[]xs，int-lo，int-hi）{
如果（嗨让我为你试一试

首先，除非您使用的是链表，否则您总是希望进行就地排序（即使这样，转换为数组、就地排序，然后再转换回链表通常也是值得的——这对垃圾收集器的压力要小得多）…网络列表实际上是在扩展数组

接下来，快速排序实际上是关于透视操作的。这里有一种方法：

// Quicksort the sub-array xs[lo..hi].
void QSort(int[] xs, int lo, int hi) {
    if (hi <= lo) return; // Don't sort empty or singleton sub-arrays.
    var p = [choose some pivot value from xs[lo..hi]];
    var a = lo; // Invariant: x[lo..a - 1] <= p.
    var z = hi; // Invariant: p < x[z + 1..hi].
    while (a <= z) {
        if (xs[a] <= p) a++; else Swap(xs, a, z--);
    }
    QSort(xs, lo, a - 1); // Sort the items <= p.
    QSort(xs, z + 1, hi); // Sort the items > p.
}

void Swap(int[] xs, int i, int j) {
    var tmp = xs[i];
    xs[i] = xs[j];
    xs[j] = tmp;
}

//对子数组xs[lo..hi]进行快速排序。
无效QSort（int[]xs，int-lo，int-hi）{
if（hi在Groovy上的简单实现

def qs(list) {
  if (list.size() < 2) return list   
  def pivot = list[0]
  def items = list.groupBy { it <=> pivot }.withDefault { [] }
  qs(items[-1]) + items[0] + qs(items[1])
}

def qs（列表）{
if（list.size（）<2）返回列表
def pivot=列表[0]
def items=list.groupBy{it pivot}.withDefault{[]}
qs（项目[-1]）+项目[0]+qs（项目[1]）
}
在Groovy上的简单实现

def qs(list) {
  if (list.size() < 2) return list   
  def pivot = list[0]
  def items = list.groupBy { it <=> pivot }.withDefault { [] }
  qs(items[-1]) + items[0] + qs(items[1])
}

def qs（列表）{
if（list.size（）<2）返回列表
def pivot=列表[0]
def items=list.groupBy{it pivot}.withDefault{[]}
qs（项目[-1]）+项目[0]+qs（项目[1]）
}
将左右两边放在一起并返回它？我的实现是否正确？为什么不测试结果是否正确？输入一个数组并查看自己是否对结果进行了排序。将左右两边放在一起并返回它？我的实现是否正确？为什么不测试结果是否正确？输入一个数组并查看自己是否正确结果已排序。