java语言实现快速排序的两种方式

方法一:

?





1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

public class QuickSortExp1{

    public
static void main(String[] args){

        int[] sortArray = new
int[]{5,7,4,2,9,8,3,6};

        System.out.println("before sorting ,the numbers are:");

        show(sortArray);

        quickSort(sortArray,0,sortArray.length-1);

        System.out.println("after sorting,the numbers are:");

        show(sortArray);

    }

    public
static void quickSort(int[] intArray,int
left,int
right){

        if(left<right){

            int
partValue =  intArray[left];

            int
low = left;

            int
high = right;

            while(low < high){

                while(low <high && intArray[high]>partValue){

                    high--;

                }

                intArray[low] = intArray[high];

                while(low <high && intArray[low] <partValue){

                    low++;

                }

                intArray[high] = intArray[low];

            }

            intArray[low] = partValue;

            quickSort(intArray,left,low-1);

            quickSort(intArray,low+1,right);

        }

    }

    public
static void show(int[] intArray){

        for(int
i=0;i<intArray.length;i++){

            System.out.print(intArray[i]+"\t");

        }

        System.out.println();

    }

}

  

方法二:

?





1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

import java.util.*;

public class QuickSortExp2{

    public
static void main(String[] args){

        List<Integer> sortList = new
ArrayList<Integer>();

        sortList.add(5);

        sortList.add(7);

        sortList.add(4);

        sortList.add(2);

        sortList.add(9);

        sortList.add(8);

        sortList.add(3);

        sortList.add(6);       

        System.out.println("before sorting ,the numbers are:");

        show(sortList);

        quickSort(sortList);

        System.out.println("after sorting,the numbers are:");

        show(sortList);

    }

    public
static void quickSort(List<Integer> sortList){    

        if(sortList.size() <= 1){

            return;

        } else
if(sortList.size() == 2){

            if(sortList.get(0)>sortList.get(1)){

                int
temp = sortList.get(0);

                sortList.set(0,sortList.get(1));

                sortList.set(1,temp);

            }

        } else{    

            List<Integer> leftList = new
ArrayList<Integer>();

            List<Integer> rightList = new
ArrayList<Integer>();

            int
partValue = sortList.get(0);       

            for(int
i=1;i<sortList.size();i++){

                if(sortList.get(i)< partValue){

                    leftList.add(sortList.get(i));

                } else{

                    rightList.add(sortList.get(i));

                }

            }  

            quickSort(leftList);

            quickSort(rightList);

            

            sortList.clear();

            sortList.addAll(leftList);

            sortList.add(partValue);

            sortList.addAll(rightList);

            leftList.clear();

            rightList.clear();         

        }          

    }

    public
static void show(List<Integer> sortList){

        for(Integer i:sortList){

            System.out.print(i+"\t");

        }

        System.out.println();

    }

}

  

时间: 2024-08-28 08:16:38

java语言实现快速排序的两种方式的相关文章

java中设置代理的两种方式

1 前言 有时候我们的程序中要提供可以使用代理访问网络,代理的方式包括http.https.ftp.socks代理.比如在IE浏览器设置代理. 那我们在我们的java程序中使用代理呢,有如下两种方式.直接上代码. 2 采用设置系统属性 ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 import jav

java基础知识回顾之java Thread类学习(三)--java线程实现常见的两种方式实现好处:

总结:实现Runnable接口比继承Thread类更有优势: 1.因为java只能单继承,实现Runnable接口可以避免单继承的局限性 2.继承Thread类,多个线程不能处理或者共享同一个资源,但是实现Runnable接口可以处理同一个资源. 下面我们做个测试:验证下.车站的售票系统售票的例子,车站的各个售票口相当于各个线程,我们先使用第一种方法几继承Thread类的方式实现: 代码如下: package com.lp.ecjtu.Thread; /** * * @author Admini

java动态获取WebService的两种方式(复杂参数类型)

java动态获取WebService的两种方式(复杂参数类型) 第一种: @Override public OrderSearchListRes searchOrderList(Order_FlightOrderSearchRequest request) { Object myAllMessage; OrderSearchListRes response = null; try { String endpoint = carGlobalSetting.getEndpoint(); JaxWsD

JAVA中Arrays.sort()使用两种方式(Comparable和Comparator接口)对对象或者引用进行排序

一.描述 自定义的类要按照一定的方式进行排序,比如一个Person类要按照年龄进行从小到大排序,比如一个Student类要按照成绩进行由高到低排序. 这里我们采用两种方式,一种是使用Comparable接口:让待排序对象所在的类实现Comparable接口,并重写Comparable接口中的compareTo()方法,缺点是只能按照一种规则排序. 另一种方式是使用Comparator接口:编写多个排序方式类实现Comparator接口,并重写新Comparator接口中的compare()方法,

java 多线程之卖票两种方式

1.通过extends Thread 1 /* 2 需求:简单的卖票,多个窗口同时买票 3 (共用资源) 4 创建线程的第二种方式:实现Runnable接口 5 6 步骤: 7 1,定义类实现Runnable接口 8 2,覆盖/重写Runnable接口中的run方法 9 将将线程要运行的代码存放在该run方法中 10 3,通过Thread类建立线程对象 11 4,将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数 12 为什么要将Runnable接口的子类对象传递给Thr

JAVA中创建字符串的两种方式的区别

我们知道,通常在Java中创建一个字符串会有两种方式,通过双引号直接赋值和通过构造器来创建. String x = "abcd"; String y = new String("abcd"); 然而,这两种方式之间的区别是什么?分别应用于哪些情况,之前还不是很懂. 1.双引号的方式 String x = "abcd"; String y = "abcd"; System.out.println(x==y);//true Sys

Java中实现多线程的两种方式之间的区别

Java提供了线程类Thread来创建多线程的程序.其实,创建线程与创建普通的类的对象的操作是一样的,而线程就是Thread类或其子类的实例对象.每个Thread对象描述了一个单独的线程.要产生一个线程,有两种方法: ◆需要从Java.lang.Thread类派生一个新的线程类,重载它的run()方法:  ◆实现Runnalbe接口,重载Runnalbe接口中的run()方法. 为什么Java要提供两种方法来创建线程呢?它们都有哪些区别?相比而言,哪一种方法更好呢? 在Java中,类仅支持单继承

java的动态代理的两种方式和spring的aop面向切面编程的对比

java动态代理的两种方式 使用动态代理的好处:可以进行类的功能的加强,同时减少耦合和代码的冗余,耦合的意思是不用吧加强的部分写到各个实现类里面,冗余的意思是如果对每个实现类加强的部分是一样的,通过一个代理类即可实现 基于jdk的动态代理 通过jdk中自带的Proxy类进行动态的代理,Proxy创建动态代理对象的时候要传入三个参数,第一个是classloader,第二个是interfaces,第三个是代理类实现的方法 要求:代理的是一个接口,必须至少有一个实现类 创建接口的代码: /** * a

java中String初始化的两种方式

转自:http://www.diybl.com/course/3_program/java/javajs/2007104/75886.html       字符串可能是任何程序语言中都会出现的对象,java中创建并初始化一个String对象,最常见的方式有两种: String str=new String("XXX"); String str="XXX"; 二者看似相同,其实有很大的差别.       前者是java中标准的对象创建方式,其创建的对象将直接放置到堆中