13518219792
参考代码如下，可以按需求自己修改
创新互联建站-专业网站定制、快速模板网站建设、高性价比南阳网站开发、企业建站全套包干低至880元,成熟完善的模板库,直接使用。一站式南阳网站制作公司更省心,省钱,快速模板网站建设找我们，业务覆盖南阳地区。费用合理售后完善，10余年实体公司更值得信赖。
import java.util.Date;
public class SortThread {
public static void main(String[] args) {
//产生一个随机数组
int[] ary = getArray();
//启动冒泡排序线程
new Thread(new MaoPao(ary)).start();
//启动快速排序线程
new Thread(new KuaiSu(ary)).start();
}
private static int[] getArray() {
//建议数字n不要超过1百万，十万左右就好了
int n = (int) (Math.random()*1000000)+11;
int[] ary= new int[n];
System.out.println("n的值是" + n);
for (int i = 0; i ary.length; i++) {
ary[i] = (int) (Math.random()*100000);
}
return ary;
}
}
//冒泡排序
class MaoPao implements Runnable {
int[] ary;
public MaoPao(int[] ary) {
this.ary = ary;
}
@Override
public void run() {
long st = System.currentTimeMillis();
System.out.println(new Date() + "冒泡排序线程：开始执行排序");
for (int i = 0; i ary.length - 1; i++) {
for (int j = 0; j ary.length - i - 1; j++) {
if (ary[j] ary[j + 1]) {
int temp = ary[j];
ary[j] = ary[j + 1];
ary[j + 1] = temp;
}
}
}
long et = System.currentTimeMillis();
System.out.println(new Date() + "冒泡排序线程完成排序,耗费时间" + (et - st) + "毫秒");
for (int i = 0; i ary.length; i++) {
System.out.println(ary[i]+" ");
}
}
}
//快速排序
class KuaiSu implements Runnable {
int[] ary;
public KuaiSu(int[] ary) {
this.ary = ary;
}
@Override
public void run() {
long st = System.currentTimeMillis();
System.out.println(new Date() + "快速排序线程：开始执行排序");
quickSort(ary, 1, ary.length);
long et = System.currentTimeMillis();
System.out.println(new Date() + "快速排序线程排序完成,耗费时间" + (et - st) + "毫秒");
for (int i = 0; i ary.length; i++) {
System.out.println(ary[i]+" ");
}
}
public static int Partition(int a[], int p, int r) {
int x = a[r - 1];
int i = p - 1;
int temp;
for (int j = p; j = r - 1; j++) {
if (a[j - 1] = x) {
i++;
temp = a[j - 1];
a[j - 1] = a[i - 1];
a[i - 1] = temp;
}
}
temp = a[r - 1];
a[r - 1] = a[i + 1 - 1];
a[i + 1 - 1] = temp;
return i + 1;
}
public static void quickSort(int a[], int p, int r) {
if (p r) {
int q = Partition(a, p, r);
quickSort(a, p, q - 1);
quickSort(a, q + 1, r);
}
}
}
package temp;
import sun.misc.Sort;
/**
* @author zengjl
* @version 1.0
* @since 2007-08-22
* @Des java几种基本排序方法
*/
/**
* SortUtil:排序方法
* 关于对排序方法的选择：这告诉我们，什么时候用什么排序最好。当人们渴望先知道排在前面的是谁时，
* 我们用选择排序；当我们不断拿到新的数并想保持已有的数始终有序时，我们用插入排序；当给出的数
* 列已经比较有序，只需要小幅度的调整一下时，我们用冒泡排序。
*/
public class SortUtil extends Sort {
/**
* 插入排序法
* @param data
* @Des 插入排序(Insertion Sort)是，每次从数列中取一个还没有取出过的数，并按照大小关系插入到已经取出的数中使得已经取出的数仍然有序。
*/
public int[] insertSort(int[] data) {
1/11页
int temp;
for (int i = 1; i data.length; i++) {
for (int j = i; (j 0) (data[j] data[j - 1]); j--) {
swap(data, j, j - 1);
}
}
return data;
}
/**
* 冒泡排序法
* @param data
* @return
* @Des 冒泡排序(Bubble Sort)分为若干趟进行，每一趟排序从前往后比较每两个相邻的元素的大小（因此一趟排序要比较n-1对位置相邻的数）并在
* 每次发现前面的那个数比紧接它后的数大时交换位置；进行足够多趟直到某一趟跑完后发现这一趟没有进行任何交换操作（最坏情况下要跑n-1趟，
* 这种情况在最小的数位于给定数列的最后面时发生）。事实上，在第一趟冒泡结束后，最后面那个数肯定是最大的了，于是第二次只需要对前面n-1
* 个数排序，这又将把这n-1个数中最小的数放到整个数列的倒数第二个位置。这样下去，冒泡排序第i趟结束后后面i个数都已经到位了，第i+1趟实
* 际上只考虑前n-i个数（需要的比较次数比前面所说的n-1要小）。这相当于用数学归纳法证明了冒泡排序的正确性
冒泡排序是比较经典的排序算法。代码如下：
for(int i=1;iarr.length;i++){
for(int j=1;jarr.length-i;j++){
//交换位置
}
拓展资料：
原理：比较两个相邻的元素，将值大的元素交换至右端。
思路：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复第一趟步骤，直至全部排序完成。
第一趟比较完成后，最后一个数一定是数组中最大的一个数，所以第二趟比较的时候最后一个数不参与比较；
第二趟比较完成后，倒数第二个数也一定是数组中第二大的数，所以第三趟比较的时候最后两个数不参与比较；
依次类推，每一趟比较次数-1；
??
举例说明：要排序数组：int[] arr={6,3,8,2,9,1};
for(int i=1;iarr.length;i++){
for(int j=1;jarr.length-i;j++){
//交换位置
}
参考资料：冒泡排序原理
给你介绍4种排序方法及源码，供参考
1.冒泡排序
主要思路： 从前往后依次交换两个相邻的元素，大的交换到后面，这样每次大的数据就到后面，每一次遍历，最大的数据到达最后面，时间复杂度是O(n^2)。
public static void bubbleSort(int[] arr){
for(int i =0; i arr.length - 1; i++){
for(int j=0; j arr.length-1; j++){
if(arr[j] arr[j+1]){
arr[j] = arr[j]^arr[j+1];
arr[j+1] = arr[j]^arr[j+1];
arr[j] = arr[j]^arr[j+1];
}
}
}
}
2.选择排序
主要思路：每次遍历序列，从中选取最小的元素放到最前面，n次选择后，前面就都是最小元素的排列了，时间复杂度是O(n^2）。
public static void selectSort(int[] arr){
for(int i = 0; i arr.length -1; i++){
for(int j = i+1; j arr.length; j++){
if(arr[j] arr[i]){
arr[j] = arr[j]^arr[i];
arr[i] = arr[j]^arr[i];
arr[j] = arr[j]^arr[i];
}
}
}
}
3.插入排序
主要思路：使用了两层嵌套循环，逐个处理待排序的记录。每个记录与前面已经排好序的记录序列进行比较，并将其插入到合适的位置，时间复杂度是O(n^2）。
public static void insertionSort(int[] arr){
int j;
for(int p = 1; p arr.length; p++){
int temp = arr[p]; //保存要插入的数据
//将无序中的数和前面有序的数据相比，将比它大的数，向后移动
for(j=p; j0 temp arr[j-1]; j--){
arr[j] = arr[j-1];
}
//正确的位置设置成保存的数据
arr[j] = temp;
}
}
4.希尔排序
主要思路：用步长分组，每个分组进行插入排序，再慢慢减小步长，当步长为1的时候完成一次插入排序， 希尔排序的时间复杂度是：O（nlogn）～O（n2），平均时间复杂度大致是O(n^1.5)
public static void shellSort(int[] arr){
int j ;
for(int gap = arr.length/2; gap 0 ; gap/=2){
for(int i = gap; i arr.length; i++){
int temp = arr[i];
for(j = i; j=gap temparr[j-gap]; j-=gap){
arr[j] = arr[j-gap];
}
arr[j] = temp;
}
}
}
简单的实现排序，可以参考如下的代码
import java.text.Collator;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Locale;
public class PYDemo {
public static void main(String[] args) {
String[] names= {"赵z子z龙l","刘l备b","关g羽y","张z飞f"};
System.out.println("排序前"+Arrays.toString(names));
Comparator cpt = Collator.getInstance(Locale.CHINA);
Arrays.sort(names, cpt);
System.out.println("排序后"+Arrays.toString(names));
}
}
测试输出
排序前[赵z子z龙l, 刘l备b, 关g羽y, 张z飞f]
排序后[关g羽y, 刘l备b, 张z飞f, 赵z子z龙l]
如果有一些非常用的汉字，生僻字等，建议使用一些jar包实现,比如pinyin4j
