快速排序 java（我用java写了一个快速排序算法，一直卡着不动，什么原因呢）

本文目录

• 我用java写了一个快速排序算法，一直卡着不动，什么原因呢
• java快速排序简单代码
• Java通过几种经典的算法来实现数组排序
• java快速排序 要求0-100之间随机的20个数 并存放在list里
• java编程实现随机数组的快速排序
• 如何用J**A实现快速排序算法
• java 编写一个程序,输入3个整数,然后程序将对这三个整数按照从大到小进行排列
• 怎么用java实现快速排序
• 请问一下java快速排序源代码
• 如何用java实现快速排序，简答讲解下原理

我用java写了一个快速排序算法，一直卡着不动，什么原因呢

class QuickSort {public int getMiddle(int list, int low, int high) {if (low 《 high) {int middle = getMiddle(list, low, high); //将list数组进行一分为二 sort(list, low, middle - 1); //对低字表进行递归排序 sort(list, middle + 1, high); //对高字表进行递归排序 }}}
别人的代码，参考一下

java快速排序简单代码

.example-btn{color:#fff;background-color:#5cb85c;border-color:#4cae4c}.example-btn:hover{color:#fff;background-color:#47a447;border-color:#398439}.example-btn:active{background-image:none}div.example{width:98%;color:#000;background-color:#f6f4f0;background-color:#d0e69c;background-color:#dcecb5;background-color:#e5eecc;margin:0 0 5px 0;padding:5px;border:1px solid #d4d4d4;background-image:-webkit-linear-gradient(#fff,#e5eecc 100px);background-image:linear-gradient(#fff,#e5eecc 100px)}div.example_code{line-height:1.4em;width:98%;background-color:#fff;padding:5px;border:1px solid #d4d4d4;font-size:110%;font-family:Menlo,Monaco,C***olas,"Andale Mono","lucida c***ole","Courier New",monospace;word-break:break-all;word-wrap:break-word}div.example_result{background-color:#fff;padding:4px;border:1px solid #d4d4d4;width:98%}div.code{width:98%;border:1px solid #d4d4d4;background-color:#f6f4f0;color:#444;padding:5px;margin:0}div.code div{font-size:110%}div.code div,div.code p,div.example_code p{font-family:"courier new"}pre{margin:15px auto;font:12px/20px Menlo,Monaco,C***olas,"Andale Mono","lucida c***ole","Courier New",monospace;white-space:pre-wrap;word-break:break-all;word-wrap:break-word;border:1px solid #ddd;border-left-width:4px;padding:10px 15px} 排序算法是《数据结构与算法》中最基本的算法之一。排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。以下是快速排序算法：

快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。

快速排序又是一种分而治之思想在排序算法上的典型应用。本质上来看，快速排序应该算是在冒泡排序基础上的递归分治法。

快速排序的名字起的是简单粗暴，因为一听到这个名字你就知道它存在的意义，就是快，而且效率高！它是处理大数据最快的排序算法之一了。虽然 Worst Case 的时间复杂度达到了 O(n?)，但是人家就是优秀，在大多数情况下都比平均时间复杂度为 O(n logn) 的排序算法表现要更好，可是这是为什么呢，我也不知道。好在我的强迫症又犯了，查了 N 多资料终于在《算法艺术与信息学竞赛》上找到了满意的答案：

快速排序的最坏运行情况是 O(n?)，比如说顺序数列的快排。但它的平摊期望时间是 O(nlogn)，且 O(nlogn) 记号中隐含的常数因子很小，比复杂度稳定等于 O(nlogn) 的归并排序要小很多。所以，对绝大多数顺序性较弱的随机数列而言，快速排序总是优于归并排序。
1. 算法步骤
从数列中挑出一个元素，称为 "基准"（pivot）;

重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；

递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；
2. 动图演示
代码实现 JavaScript 实例 function quickSort ( arr , left , right ) {
    var len = arr. length ,
        partitionIndex ,
        left = typeof left != ’number’ ? 0 : left ,
        right = typeof right != ’number’ ? len - 1 : right ;

    if ( left

Java通过几种经典的算法来实现数组排序

J**A中在运用数组进行排序功能时，一般有四种方法：快速排序法、冒泡法、选择排序法、插入排序法。
快速排序法主要是运用了Arrays中的一个方法Arrays.sort（）实现。
冒泡法是运用遍历数组进行比较，通过不断的比较将最小值或者最大值一个一个的遍历出来。
选择排序法是将数组的第一个数据作为最大或者最小的值，然后通过比较循环，输出有序的数组。
插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。下面我就将他们的实现方法一一详解供大家参考。
《1》利用Arrays带有的排序方法快速排序
public class Test2{ public static void main(String a={5,4,2,4,9,1}; Arrays.sort(a); //进行排序 for(int i: a){ System.out.print(i); } } }
《2》冒泡排序算法
public static int=temp; } } } return args; }
《3》选择排序算法
public static int=temp; } } return args; }
《4》插入排序算法
public static int=temp; }else break; } } return args; }

java快速排序 要求0-100之间随机的20个数 并存放在list里

import java.util.ArrayList;
import java.util.List;
public class Cat
{
/**
 * 快速排序
 */
private static void quickSort(List《Integer》 array, int start, int end)
{
if(start 《 end)
{
int key = array.get(start);
int i = start;
for(int j = start + 1; j 《 end + 1; j++)
{
if(key 》 array.get(j))
{
int temp = array.get(j);
array.set(j, array.get(i + 1));
array.set(i + 1, temp);
i++;
}
}
array.set(start, array.get(i));
array.set(i, key);
quickSort(array, start, i - 1);
quickSort(array, i + 1, end);
}
}
public static void main(String args)
{
List《Integer》 array = new ArrayList《Integer》();
for(int i = 0; i 《 20; i++)
{
int rand = (int)(Math.random() * 100);
array.add(rand);
}
System.out.println(array);
quickSort(array, 0, array.size() - 1);
System.out.println(array);
}
}

java编程实现随机数组的快速排序

    java编程实现随机数组的快速排序步骤如下：

    1、打开Eclipse，新建一个Java工程，在此工程里新建一个Java类；

    2、在新建的类中声明一个产生随机数的Random变量，再声明一个10个长度的int型数组；

    3、将产生的随机数逐个放入到数组中；

    4、利用排序算法对随机数组进行排序。

    具体代码如下：

import java.util.Random;
public class Demo {
    public static void main(String args) {
        int count = 0;
        Random random = new Random();
        int a;
        while(count 《 10){
            a = random.nextInt(1000);//产生0-999的随机数
            count++;
        }
        for (int i = 0; i 《 a.length - 1; i++) {
            int min = i;
            for (int j = i + 1; j 《 a.length; j++) {
                if (a) {
                    min = j;
                }
            }
            if (min != i) {
                int b = a;
                a;
                a = b;
            }
        }
        for (int c = 0; c 《 a.length; c++) {
            System.out.print(a + " ");
        }
    }
}

如何用J**A实现快速排序算法

本人特地给你编的代码\x0d\x0a亲测\x0d\x0a\x0d\x0apublicclassQuickSort{\x0d\x0a\x0d\x0apublicstaticintPartition(inta);\x0d\x0a\x0d\x0a}\x0d\x0a\x0d\x0a} <="" div="">

java 编写一个程序,输入3个整数,然后程序将对这三个整数按照从大到小进行排列

可以实现比较器Comparator来定制排序方案，同时使用Colleti***.sort的方式进行排序，代码如下：

public void sortDesc(List《Long》 s){
Collecti***.sort(s, new Comparator《Long》() {
public int compare(Long o1, Long o2) {
Long result = o2 - o1;
return result.intValue();
}
});
s.forEach(item-》{
System.out.print(item +" ");
});
}

同时常用的比较排序算法主要有：冒泡排序，选择排序，插入排序，归并排序，堆排序，快速排序等。

java的冒泡排序实现如下：

还有非比较排序，时间复杂度可以达到O(n)，主要有：计数排序，基数排序，桶排序等。

怎么用java实现快速排序

package com.xinhua.test2;
public class Student {
int sno;
String name;
double chiness;
double math;
double english;
double three_sco;
double all_s;
public Student(int sno, String name, double chiness, double math, double english, double three_sco) {
this.sno = sno;
this.name = name;
this.chiness = chiness;
this.math = math;
this.english = english;
this.three_sco = three_sco;
}
@Override
public String toString() {
return "学号：" + sno + ", 名字：" + name + ", 语文成绩：" + chiness + ", 数学成绩：" + math + ", 英语成绩："
+ english + "总成绩："+(chiness+math+english+three_sco);
}
public static void main(String args) {
Student A=new Student(1, "张三", 118, 145, 114.5, 198);
Student B=new Student(2, "李四", 130,110.5,100,210);
Student C=new Student(3, "王五",142.5,120,87.5,245.5);
System.out.println("学生列表信息为：");
System.out.println(A.toString());
System.out.println(B.toString());
System.out.println(C.toString());
//
double a_scoAll=A.chiness+A.math+A.english+A.three_sco;
A.all_s=a_scoAll;
double b_scoAll=B.chiness+B.math+B.english+B.three_sco;
B.all_s=b_scoAll;
double c_sclAll=C.chiness+C.math+C.english+C.three_sco;
C.all_s=c_sclAll;
Student s_s={A,B,C};
System.out.println("按总成绩从大到小排序为");
Student temp;
for(int i=0;i《s_s.length;i++){
for(int j=1;j《s_s.length-i;j++){
if(s_s.all_s){
temp=s_s ;
s_s;
s_s=temp;
}
}
}
for(int i=0;i《s_s.length;i++){
System.out.println("第"+(i+1)+"名为："+s_s.toString());
}
}
}

请问一下java快速排序源代码

快速排序：
package org***t.util.algorithm.support;
import org***t.util.algorithm.SortUtil;
/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/
public class QuickSort implements SortUtil.Sort{
/* (non-Javadoc)
* @see org***t.util.algorithm.SortUtil.Sort#sort(int)
*/
public void sort(int data) {
quickSort(data,0,data.length-1);
}
private void quickSort(int data,int i,int j){
int pivotIndex=(i+j)/2;
//swap
SortUtil.swap(data,pivotIndex,j);

int k=partition(data,i-1,j,data);
SortUtil.swap(data,k,j);
if((k-i)》1) quickSort(data,i,k-1);
if((j-k)》1) quickSort(data,k+1,j);

}
/**
* @param data
* @param i
* @param j
* @return
*/
private int partition(int data, int l, int r,int pivot) {
do{
while(data《pivot);
while((r!=0)&&data》pivot);
SortUtil.swap(data,l,r);
}
while(l《r);
SortUtil.swap(data,l,r);
return l;
}
}
改进后的快速排序：
package org***t.util.algorithm.support;
import org***t.util.algorithm.SortUtil;
/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/
public class ImprovedQuickSort implements SortUtil.Sort {
private static int MAX_STACK_SIZE=4096;
private static int THRESHOLD=10;
/* (non-Javadoc)
* @see org***t.util.algorithm.SortUtil.Sort#sort(int)
*/
public void sort(int data) {
int;

int top=-1;
int pivot;
int pivotIndex,l,r;

stack=0;
stack=data.length-1;

while(top》0){
int j=stack;
int i=stack;

pivotIndex=(i+j)/2;
pivot=data;

SortUtil.swap(data,pivotIndex,j);

//partition
l=i-1;
r=j;
do{
while(data《pivot);
while((r!=0)&&(data》pivot));
SortUtil.swap(data,l,r);
}
while(l《r);
SortUtil.swap(data,l,r);
SortUtil.swap(data,l,j);

if((l-i)》THRESHOLD){
stack=i;
stack=l-1;
}
if((j-l)》THRESHOLD){
stack=l+1;
stack=j;
}

}
//new InsertSort().sort(data);
insertSort(data);
}
/**
* @param data
*/
private void insertSort(int data) {
int temp;
for(int i=1;i《data.length;i++){
for(int j=i;(j》0)&&(data);j--){
SortUtil.swap(data,j,j-1);
}
}
}
}

如何用java实现快速排序，简答讲解下原理

快速排序思想：
通过对数据元素集合Rn 进行一趟排序划分出独立的两个部分。其中一个部分的关键字比另一部分的关键字小。然后再分别对两个部分的关键字进行一趟排序，直到独立的元素只有一个，此时整个元素集合有序。
快速排序的过程，对一个元素集合R为基准重新排列所有的元素。
所有比R 划分为两个子集和，再做划分。直到low 》= high 。
比如：对R={37, 40, 38, 42, 461, 5, 7, 9, 12}进行一趟快速排序的过程如下(注:下面描述的内容中元素下表从 0 开始)：
开始选取基准 base = 37，初始位置下表 low = 0 ， high = 8 ， 从high=8，开始如果R中, 将high位置空出来, low = low +1 ;
从low开始探测，由于low=1 ， R , high = high -1 ;
检测到low 《 high ,所以第一趟快速排序仍需继续:
此时low=1，high=7，因为 R中,low = low + 1;
从low开始探测,low = 2 , R，high=high-1;
继续检测到 low 小于high
此时low=2，high=6，同理R中，low=low+1;
从low继续探测,low = 3 , high=6 , R中，high = high-1;
继续探测到low小于high
此时low=3，high=5，同理R中，low = low +1；
从low继续探测，low = 4，high=5，由于R中，high = high -1 ;
此时探测到low == high == 4 ；该位置即是base所在的位置，将base写入到该位置中.
然后再对子序列Rs1 = {12,9,7,5} 和 Rs2={461,42,38,40}做一趟快速排序，直到Rsi中只有一个元素，或没有元素。
快速排序的Java实现：
private static boolean isEmpty(int n) {
return n == null || n.length == 0;
}

// ///////////////////////////////////////////////////
/**
* 快速排序算法思想——挖坑填数方法：
*
* @param n 待排序的数组
*/
public static void quickSort(int n) {
if (isEmpty(n))
return;
quickSort(n, 0, n.length - 1);
}

public static void quickSort(int n, int l, int h) {
if (isEmpty(n))
return;
if (l 《 h) {
int pivot = partion(n, l, h);
quickSort(n, l, pivot - 1);
quickSort(n, pivot + 1, h);
}
}

private static int partion(int n, int start, int end) {
int tmp = n;
while (start 《 end) {
while (n 》= tmp && start 《 end)
end--;
if (start 《 end) {
n;
}
while (n 《 tmp && start 《 end)
start++;
if (start 《 end) {
n;
}
}
n = tmp;
return start;
}
在代码中有这样一个函数：
public static void quickSortSwap(int n, int l, int h)
该函数可以实现，元素集合**定的 l 到 h 位置间的数据元素进行排序。