QuickSort的实现2_quicksort sublist-优快云博客

本文链接：https://blog.youkuaiyun.com/hillMover/article/details/562008

该博客主要展示了快速排序算法的Java代码实现。先将列表划分为两个子列表，分别对其进行快速排序，最后合并排序好的子列表。代码包含输入元素、执行排序、输出排序结果及耗时等功能，还实现了分区和交换元素等操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

package sort;
/**
if (the list size is greater than 1)
{
  a. Partition the list into 2 sublists,say lowerSublist and upperSublist;
  b. Quick sort lowerList;
  c. Quick sort upperList;
  d. Combine the sorted lowerSublist and sorted upperSublist.

}

quickSort说明图片
**/
public class QuickSort
{
private Comparable[] datum;
public static int times;

//constructor
public QuickSort(){}
public QuickSort(Comparable[] datum)
{
  this.datum = datum;
}
//main method to invoke quickSort() as an example
public static void main(String[] args)throws IOException
{
  String inString ;
  StringTokenizer tokenizer;
  Comparable [] elements;

  BufferedReader in = new BufferedReader( new InputStreamReader(System.in));

  //get size
  System.out.println("Please input the size: ");
  inString = in.readLine();
  elements = new Integer[Integer.parseInt(inString)];

  //get elements
  System.out.println("Enter the numbers of elements : ");
  inString = in.readLine();
  tokenizer = new StringTokenizer(inString);
  for (int i =0; i<elements.length && tokenizer.hasMoreTokens();i++)
  {
   elements[i] = Integer.parseInt(tokenizer.nextToken());
  }

  QuickSort qs = new QuickSort(elements);
  long startTime = System.currentTimeMillis();
  qs.quickSort();

  System.out.println("after sorted :");
  for (int i=0;i<qs.getSize();i++)
  {
   System.out.println(qs.getDatum()[i]);
  }

  System.out.println("take time = "+(System.currentTimeMillis()-startTime)+" ms");
  System.out.println("size : "+elements.length+" , cursory times : "+times);
}
public void quickSort()
{
  recQuickSort(0,datum.length-1);
}
private void recQuickSort(int first,int last)
{
  times++;
  int pivotLocation;
  if(first < last)
  {
   pivotLocation = partition(first,last);
   recQuickSort(first,pivotLocation-1);
   recQuickSort(pivotLocation+1,last);
  }
}
private int partition(int first,int last)
{
  Comparable pivot;
  int index , smallIndex;
  swap(first,(first+last)/2);
  pivot = datum[first];
  smallIndex = first;

  for(index=first+1;index<=last;index++)
  {
   if(datum[index].compareTo(pivot) < 0)
   {
    smallIndex++;
    swap(smallIndex,index);
   }
  }
  swap(first,smallIndex);
  return smallIndex;
}
private void swap(int first,int second)
{
  Comparable temp;
  temp = datum[first];
  datum[first] = datum[second];
  datum[second] = temp;
}
public int getSize()
{
  return this.datum.length;
}
public Comparable[] getDatum()
{
  return this.datum;
}
}