JAVA中有哪几种常用的排序方法？

最主要的是冒泡排序、选择排序、插入排序以及快速排序

1、冒泡排序

冒泡排序是一个比较简单的排序方法。在待排序的数列基本有序的情况下排序速度较快。若要排序的数有n个，则需要n-1轮排序，第j轮排序中，从第一个数开始，相邻两数比较，若不符合所要求的顺序，则交换两者的位置；直到第n+1-j个数为止，第一个数与第二个数比较，第二个数与第三个数比较，......，第n-j个与第n+1-j个比较，共比较n-1次。此时第n+1-j个位置上的数已经按要求排好，所以不参加以后的比较和交换 *** 作。

例如：第一轮排序：第一个数与第二个数进行比较，若不符合要求的顺序，则交换两者的位置，否则继续进行二个数与第三个数比较......。直到完成第n-1个数与第n个数的比较。此时第n个位置上的数已经按要求排好，它不参与以后的比较和交换 *** 作；第二轮排序：第一个数与第二个数进行比较，......直到完成第n-2个数与第n-1个数的比较；......第n-1轮排序：第一个数与第二个数进行比较，若符合所要求的顺序，则结束冒泡法排序；若不符合要求的顺序，则交换两者的位置，然后结束冒泡法排序。

共n-1轮排序处理，第j轮进行n-j次比较和至多n-j次交换。

从以上排序过程可以看出，较大的数像气泡一样向上冒，而较小的数往下沉，故称冒泡法。

public void bubbleSort(int a[])

{

int n = a.length

for(int i=0i<n-1i++)

{

for(int j=0j<n-i-1j++)

{

if(a[j] >a[j+1])

{

int temp = a[j]

a[j] = a[j + 1]

a[j + 1] = temp

}

}

}

}

2、选择排序

选择法的原理是先将第一个数与后面的每一个数依次比较,不断将将小的赋给第一个数,从而找出最小的,然后第二个数与后面的每一个数依次比较,从而找出第二小的,然后第三个数与后面的每一个数依次比较,从而找出第三小的.....直到找到最后一个数。

public void sort(int x[])

{

int n=x.length

int k,t

for(int i=0i<n-1i++)

{

k=i

for(int j=i+1j=nj++)

{

if(x[j]>x[k])k=j

if(k!=i)

{

t=x[i]

x[i]=x[k]

x[k]=t

}

}

}

}

3、插入排序

插入排序的原理是对数组中的第i个元素，认为它前面的i-1个已经排序好，然后将它插入到前面的i-1个元素中。插入排序对少量元素的排序较为有效.

public void sort(int obj[])

{

for(int j=1j<obj.lengthj++)

{

int key=obj[j]

int i=j-1

while(i>=0&&obj[i]>key)

{

obj[i+1]=obj[i]

i--

}

obj[i+1]=key

}

}

4、快速排序

快速排序是对冒泡排序的一种改进。它的基本思想是：通过一次排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按次方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此大道整个数据变成有序序列。

public void quickSort(int obj[],int low,int high)

{

int i=low

int j=high

int keyValue=obj[i]

while(i<j)

{

int temp=0

while(i<j&&obj[j]>=keyValue)

{

j=j-1

}

temp=obj[j]

obj[j]=obj[i]

obj[i]=temp

while(i<j&&obj[i]<=keyValue)

{

i=i+1

}

temp=obj[j]

obj[j]=ojb[i]

obj[i]=temp

}

obj[i]=keyValue

if(low<i-1)

{

quickSort(obj,low,i-1)

}

if(high>i+1)

{

quickSort(obj,i+1,high)

}

}

Java实现几种常见排序方法

日常 *** 作中常见的排序方法有：冒泡排序、快速排序、选择排序、插入排序、希尔排序，甚至还有基数排序、鸡尾酒排序、桶排序、鸽巢排序、归并排序等。

以下常见算法的定义

1. 插入排序：插入排序基本 *** 作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。插入排序的基本思想是：每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

2. 选择排序：选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。

3. 冒泡排序：冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。

4. 快速排序：快速排序（Quicksort）是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

5. 归并排序：归并排序是建立在归并 *** 作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

6. 希尔排序：希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

https://www.cnblogs.com/wangmingshun/p/5635292.html

java常见的排序分为：

1 插入类排序

主要就是对于一个已经有序的序列中，插入一个新的记录。它包括：直接插入排序，折半插入排序和希尔排序

2 交换类排序

这类排序的核心就是每次比较都要“交换”，在每一趟排序都会两两发生一系列的“交换”排序，但是每一趟排序都会让一个记录排序到它的最终位置上。它包括：起泡排序，快速排序

3 选择类排序

每一趟排序都从一系列数据中选择一个最大或最小的记录，将它放置到第一个或最后一个为位置交换，只有在选择后才交换，比起交换类排序，减少了交换记录的时间。属于它的排序：简单选择排序，堆排序

4 归并类排序

将两个或两个以上的有序序列合并成一个新的序列

5 基数排序

主要基于多个关键字排序的。

下面针对上面所述的算法，讲解一些常用的java代码写的算法

二 插入类排序之直接插入排序

直接插入排序,一般对于已经有序的队列排序效果好。

基本思想：每趟将一个待排序的关键字按照大小插入到已经排序好的位置上。

算法思路，从后往前先找到要插入的位置，如果小于则就交换，将元素向后移动，将要插入数据插入该位置即可。时间复杂度为O(n2),空间复杂度为O(1)

package sort.algorithm

public class DirectInsertSort {

public static void main(String[] args) {

// TODO Auto-generated method stub

int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 }

int temp, j

for (int i = 1i <data.lengthi++) {

temp = data[i]

j = i - 1

// 每次比较都是对于已经有序的

while (j >= 0 &&data[j] >temp) {

data[j + 1] = data[j]

j--

}

data[j + 1] = temp

}

// 输出排序好的数据

for (int k = 0k <data.lengthk++) {

System.out.print(data[k] + " ")

}

}

}

三 插入类排序之折半插入排序(二分法排序)

条件：在一个已经有序的队列中，插入一个新的元素

折半插入排序记录的比较次数与初始序列无关

思想：折半插入就是首先将队列中取最小位置low和最大位置high，然后算出中间位置mid

将中间位置mid与待插入的数据data进行比较，

如果mid大于data，则就表示插入的数据在mid的左边，high=mid-1

如果mid小于data，则就表示插入的数据在mid的右边,low=mid+1

最后整体进行右移 *** 作。

时间复杂度O(n2),空间复杂度O(1)

package sort.algorithm

//折半插入排序

public class HalfInsertSort {

public static void main(String[] args) {

int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 }

// 存放临时要插入的元素数据

int temp

int low, mid, high

for (int i = 1i <data.lengthi++) {

temp = data[i]

// 在待插入排序的序号之前进行折半插入

low = 0

high = i - 1

while (low <= high) {

mid = (low + high) / 2

if (temp <data[mid])

high = mid - 1

else

// low=high的时候也就是找到了要插入的位置，

// 此时进入循环中，将low加1，则就是要插入的位置了

low = mid + 1

}

// 找到了要插入的位置，从该位置一直到插入数据的位置之间数据向后移动

for (int j = ij >= low + 1j--)

data[j] = data[j - 1]

// low已经代表了要插入的位置了

data[low] = temp

}

for (int k = 0k <data.lengthk++) {

System.out.print(data[k] + " ")

}

}

}

四 插入类排序之希尔排序

希尔排序，也叫缩小增量排序，目的就是尽可能的减少交换次数，每一个组内最后都是有序的。

将待续按照某一种规则分为几个子序列，不断缩小规则，最后用一个直接插入排序合成

空间复杂度为O(1)，时间复杂度为O(nlog2n)

算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。

package sort.algorithm

public class ShellSort {

public static void main(String[] args) {

int a[] = { 1, 54, 6, 3, 78, 34, 12, 45, 56, 100 }

double d1 = a.length

int temp = 0

while (true)

{

//利用这个在将组内倍数减小

//这里依次为5,3,2,1

d1 = Math.ceil(d1 / 2)

//d为增量每个分组之间索引的增量

int d = (int) d1

//每个分组内部排序

for (int x = 0x <dx++)

{

//组内利用直接插入排序

for (int i = x + di <a.lengthi += d) {

int j = i - d

temp = a[i]

for (j >= 0 &&temp <a[j]j -= d) {

a[j + d] = a[j]

}

a[j + d] = temp

}

}

if (d == 1)

break

}

for (int i = 0i <a.lengthi++)

System.out.print(a[i]+" ")

}

}

五 交换类排序之冒泡排序

交换类排序核心就是每次比较都要进行交换

冒泡排序：是一种交换排序

每一趟比较相邻的元素，较若大小不同则就会发生交换，每一趟排序都能将一个元素放到它最终的位置！每一趟就进行比较。

时间复杂度O(n2)，空间复杂度O(1)

package sort.algorithm

//冒泡排序：是一种交换排序

public class BubbleSort {

// 按照递增顺序排序

public static void main(String[] args) {

// TODO Auto-generated method stub

int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20, 13, 100, 37, 16 }

int temp = 0

// 排序的比较趟数,每一趟都会将剩余最大数放在最后面

for (int i = 0i <data.length - 1i++) {

// 每一趟从开始进行比较，将该元素与其余的元素进行比较

for (int j = 0j <data.length - 1j++) {

if (data[j] >data[j + 1]) {

temp = data[j]

data[j] = data[j + 1]

data[j + 1] = temp

}

}

}

for (int i = 0i <data.lengthi++)

System.out.print(data[i] + " ")

}

}

---