快速排序java
1. java怎么让数组的数字从大到小排序
将数字从大到小排序的方法：
例如简一点的冒泡排序，将第一个数字和后面的数字逐个比较大小，如果小于，则互换位置，大于则不动。此时，第一个数为数组中的最大数。然后再将第二个数与后面的数逐个比较，以次类推。
示例代码如下：
publicclassTest{
publicstaticvoidmain(String[]args){
int[]array={12,3,1254,235,435,236,25,34,23};
inttemp;
for(inti=0;i<array.length;i++){
for(intj=i+1;j<array.length;j++){
if(array[i]<array[j]){
temp=array[i];
array[i]=array[j];
array[j]=temp; //两个数交换位置
}
}
}
for(inti=0;i<array.length;i++){
System.out.print(array[i]+"");
}
}
}
数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。
Java 语言中提供的数组是用来存储固定大小的同类型元素。
你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，....，number99
(1)快速排序java扩展阅读
Java中利用数组进行数字排序一般有4种方法：
1、选择排序是先将数组中的第一个数作为最大或最小数，然后通过循环比较交换最大数或最小数与一轮比较中第一个数位置进行排序。
2、冒泡排序也是先将数组中的第一个数作为最大或最小数，循环比较相邻两个数的大小，满足条件就互换位置，将最大数或最小数沉底。
3、快速排序法主要是运用Arrays类中的Arrays.sort方法（）实现。
4、插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。
2. java 怎么将List里面数据排序
不好意思，上午只是粗略地看了一下，没有细致看，现在详细回答你的提问。
ArrayList底层是用一个长度为10的Object数组实现，不管添加进去什么类型的数据，都会转换成Object对象，除非你用很早以前的JDK版本。这样就好理解了，像你写的程序arrayList1中add了String和Integer两种类型的数据，这两类对象没有什么可比性，就像拿打火机和U盘比一个性质。所以，是没有办法进行直接排序的。
你要求的是要按ArrayList里面的第1、2、4数据进行排序，这个可以。
先来arrayList1
四个数据分别是2、"daas"、6、"1"，第1、2、4数据即2、“daas”、“1”，我选择按照String类型进行排序，所以第1个数据2转换成String类型即可。因为第3个数据6不进行排序，remove就好。这是个题还是个什么，其实还是留了点活路的，因为后面的（你arrayList234下面）代码都是往arrayList1中添加的，而且还都是String类型。这也是我选择String类型进行排序的原因。代码如下：
List arrayList1 = new ArrayList();
arrayList1.add(2); //0
arrayList1.add("daas"); //1
arrayList1.add(6); //2
arrayList1.add("1"); //3
list.add(arrayList1);
//my code
String convert = String.valueOf(arrayList1.get(0));
arrayList1.remove(2);
arrayList1.remove(0);
arrayList1.add(convert);
/此处为你的arrayList234代码
Collections.sort(arrayList1);
for(int i = 0; i < arrayList1.size(); i++) {
System.out.println(arrayList1.get(i));
}
结果为：
1
2
3
5
8
daas
因为怕你深挖，强调两点：
第一点，由结果看出Collections.sort(arrayList1)，是以String的ASCII码进行排序的，为了证明这一点，就要看原代码，这时你就会发现JDK中String的compareTo方法是个空实现，底层并不是用java写的，这点没事，我们可以用一定的方法让它把特征暴露出来，然后就可以理解思想。你看我下面写的小测试程序就会明白。
String a = new String("Z");
String b = new String("A");
System.out.println(a.compareTo(b));
String c = new String("A");
String d = new String("B");
System.out.println(c.compareTo(d));
//看结果，证明String的自然顺序比较即比较ASCII值，只是第一步。
//看结果，证明compareTo返回值是后面的ASCII码减支前面的ASCII码，第二步。
String e = new String("g");
String f = new String("e");
String h = new String("h");
List<String> list = new ArrayList<String>();
list.add(e);
list.add(f);
list.add(h);
Collections.sort(list);
for(String i : list) {
System.out.println(i);
}
结果为：
25
-1
e
g
h
//证明String的自然排序即ASCII码从小到大排序，最后一步。
第二点，你的要求是“要按ArrayList里面的第1、2.4数据进行排序，分别怎么做啊”，这个问题的描述有问题，或者不详细，arryList2、arrayList3、arrayList4任何一个里面一共就add了3个数据，哪来第4个。如果是分别对arrayList234里面的数据进行排序，两个选择，（1）把所有Integer转换成String类型，再排序，参考arrayList2。（2）运用Integer.valueOf()方法，将内容为数字的String数据转换成Integer，把原来的remove掉，把内容非数字的String数据remove掉，再排序，桶排序、冒泡排序、快速排序等你随便选。
讲解到这，不管想对哪个list进行排序，你应该都会写了。
总结：
除非比较ASCII码，Integer类型和内容为非数字的String类型数据是没有办法进行比较的，不管是直接比较，还是间接比较。还是上面那句话，像打火机和U盘没有可比性一样，理解这点很重要。
即使用Integer.valueOf()方法对内容为非数字的String类型数据进行转换没有用，会报NumberFormatException。说这点意思是如果你想按Integer类型排序，得把所有内容为非数字的String类型数据remove掉。
题外话：这种类型的题我记得上大学的时候有，不知道你是不是学生，今天想来，其实用处真不大，都用泛型，现在写代码不用泛型的程序员几乎是完全不存在了。
祝心情愉快~~
亲手打，如果满意，把分给我吧~~哈哈。。
3. 在java编程中如何对数组进行排序，并输出排序后的数组及原数组下标值
java变成对数组进行排序可以使用ArraySort方法，保存源数组下标值可以存入map中，如下代码：
importjava.util.ArrayList;
importjava.util.Arrays;
importjava.util.HashMap;
importjava.util.List;
publicclassceshi{
publicstaticvoidmain(String[]args){
intn=5;
int[]a={8,5,4,6,2,1,7,9,3};
HashMapmap=newHashMap();
for(inti=0;i<a.length;i++){
map.put(a[i],i);//将值和下标存入Map
}
//排列
Listlist=newArrayList();
Arrays.sort(a);//升序排列
for(inti=0;i<a.length;i++){
list.add(a[i]);
}
for(Objectobject:list){
System.out.print(object+",");
}
System.out.println();
//查找原始下标
for(inti=0;i<n;i++){
System.out.print(map.get(a[i])+",");
}
}
}
运行结果如下：
4. Java通过几种经典的算法来实现数组排序
JAVA中在运用数组进行排序功能时，一般有四种方法：快速排序法、冒泡法、选择排序法、插入排序法。
快速排序法主要是运用了Arrays中的一个方法Arrays.sort（）实现。
冒泡法是运用遍历数组进行比较，通过不断的比较将最小值或者最大值一个一个的遍历出来。
选择排序法是将数组的第一个数据作为最大或者最小的值，然后通过比较循环，输出有序的数组。
插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。下面我就将他们的实现方法一一详解供大家参考。
<1>利用Arrays带有的排序方法快速排序
public class Test2{ public static void main(String[] args){ int[] a={5,4,2,4,9,1}; Arrays.sort(a); //进行排序 for(int i: a){ System.out.print(i); } } }
<2>冒泡排序算法
public static int[] bubbleSort(int[] args){//冒泡排序算法 for(int i=0;i<args.length-1;i++){ for(int j=i+1;j<args.length;j++){ if (args[i]>args[j]){ int temp=args[i]; args[i]=args[j]; args[j]=temp; } } } return args; }
<3>选择排序算法
public static int[] selectSort(int[] args){//选择排序算法 for (int i=0;i<args.length-1 ;i++ ){ int min=i; for (int j=i+1;j<args.length ;j++ ){ if (args[min]>args[j]){ min=j; } } if (min!=i){ int temp=args[i]; args[i]=args[min]; args[min]=temp; } } return args; }
<4>插入排序算法
public static int[] insertSort(int[] args){//插入排序算法 for(int i=1;i<args.length;i++){ for(int j=i;j>0;j--){ if (args[j]<args[j-1]){ int temp=args[j-1]; args[j-1]=args[j]; args[j]=temp; }else break; } } return args; }
5. java中应该怎样对字符串数组进行排序
可以使用冒泡排序，选择排序等多种方式就行排序，两个for循环嵌套就可以或者使用sort()方法进行快速排序
6. java十大算法
算法一：快速排序算法
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。
快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。
算法步骤：
1 从数列中挑出一个元素，称为 "基准"（pivot），
2 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
3 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。
算法二：堆排序算法
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
堆排序的平均时间复杂度为Ο(nlogn) 。
算法步骤：
创建一个堆H[0..n-1]
把堆首（最大值）和堆尾互换
3. 把堆的尺寸缩小1，并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置
4. 重复步骤2，直到堆的尺寸为1
算法三：归并排序
归并排序（Merge sort，台湾译作：合并排序）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
算法步骤：
1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置
3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
4. 重复步骤3直到某一指针达到序列尾
5. 将另一序列剩下的所有元素
7. java实现几种常见排序算法
下面给你介绍四种常用排序算法：
1、冒泡排序
特点：效率低，实现简单
思想（从小到大排）：每一趟将待排序序列中最大元素移到最后，剩下的为新的待排序序列，重复上述步骤直到排完所有元素。这只是冒泡排序的一种，当然也可以从后往前排。
8. 快速排序的算法复杂度分析
原文地址：
快速排序的算法复杂度分析
以下是快排的java算法：
大家都知道快排的时间复杂度是O(n*ln[n])，那么这个复杂度是如何计算出来的呢？
最好的情况下，每次划分对一个记录定位后，要记录的左侧子序列与右侧子序列的长度相同。在具有n个记录的序列中，一次划分需要对整个待划分序列扫描一遍，所需的时间为O(n)。
设 是对n个记录的序列进行排序的时间，每次划分后，正好把划分区域分为长度相等的连个子序列，显然T(0)=T(1) =1,则有：
最坏的情况下，待排序的记录序列正序或逆序，每次划分只能得到一个比上一次划分少一个记录的子序列，（另一个子序列为空）。此时，必须经过n-1次递归调用才能把所有记录定位，而且第i趟划分需要经过n-i次比较才能找个才能找到第i个记录的位置，因此时间复杂度为
平均情况下，设轴值记录的关键码第k小（1≤k≤n）,则有：
由上式可推出如下两式：
两式相减,然后两边同除以n(n+1)得
又因为f(n)单调递减，单调有界数列极限定理，所以f(n)有界
此数称为欧拉常数，
约为 0.57721566490153286060651209
所以
所以
**如果有何处不当，请不吝赐教，一定多加完善。谢谢 **
参考资料：
【1】《算法设计与分析》第二版 王红梅