13518219792
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 = 1; i data.length; i++) {
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 = 0; k data.length; k++) {
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 = 1; i data.length; i++) {
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 = i; j = low + 1; j--)
data[j] = data[j - 1];
// low已经代表了要插入的位置了
data[low] = temp;
}
for (int k = 0; k data.length; k++) {
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 = 0; x d; x++)
{
//组内利用直接插入排序
for (int i = x + d; i a.length; i += 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 = 0; i a.length; i++)
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 = 0; i data.length - 1; i++) {
// 每一趟从开始进行比较，将该元素与其余的元素进行比较
for (int j = 0; j data.length - 1; j++) {
if (data[j] data[j + 1]) {
temp = data[j];
data[j] = data[j + 1];
data[j + 1] = temp;
}
}
}
for (int i = 0; i data.length; i++)
System.out.print(data[i] + " ");
}
}
给你介绍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;
}
}
}
本节内容是排序算法系列之一： 希尔排序 ，主要讲解了希尔排序的主体思路，选取了一个待排序的数字列表对希尔排序算法进行了演示，给出了希尔排序算法的 Java 代码实现，帮助大家可以更好的理解希尔排序算法。
希尔排序（Shell Sort），是计算机科学与技术领域中较为简单的一种排序算法。
希尔排序是插入排序的一种，有时候也被称为 “缩小增量排序”。它是插入排序的改进版，与插入排序的不同之处在于，希尔排序会优先比较距离较远的元素。希尔排序是按照其设计者希尔（Donald Shell）的名字命名而来，并于 1959 年公布出来。
在介绍完希尔排序之后，我们一起来看一下希尔排序的实现步骤具体是什么样的吧。这里我们假设待排序的序列为 [9,2,11,7,12,5]，我们按照从小到大的序列进行排序。
选择一个增量序列 k1，k2, … km，其中 k1k2…km=1，即增量序列大小依次减小，并且最后一个增量序列大小为 1。
按照增量序列的个数 m，对整个待排序序列进行 m 趟排序。
每一趟排序，根据对应的增量 ki，需要将待排序的序列分成对应长度的子序列，分别在子序列上面进行直接插入排序。当且仅当增量序列为 1 时，整个序列作为一个整体处理。
其实，上面的 步骤 1 和 步骤 2 都是在排序之前进行的处理，选择对应的增量。上面的 步骤 3 每执行一次，就相当于是进行了一次插入排序，只是每次都会选择一个增量，将整个待排序序列按照增量进行划分，然后在对应增量上面进行插入排序。接下来，让我们用上面的待排序数字队列 [9,2,11,7,12,5] 进行整个算法步骤的排序演示工作。
按照 2.1 节的排序步骤，我们需要先选择对应的希尔排序中的增量值，按照一般性的原则，我们可以将增量按照待排序的序列长度依次整除 2，直到增量为 1 停止，得到对应的增量。如下：
接着，我们调用 2.1 中的 步骤 2, 步骤 3 ，按照增量值的取法，依次进行对应序列的插入排序，首先我们取增量值为 3，对应排序示例如下：
在完成增量为 3 的插入排序之后，我们接着进行增量为 1 的插入排序，这个步骤其实跟我们之前的插入排序步骤完全一致。整个过程如下：
从上面的示例可以看出，其实整个希尔排序的过程，就是根据增量大小依次进行插入排序，本质上还是针对插入排序的一种优化。
在说明希尔排序的整个过程之后，接下来，我们看看如何用 Java 代码实现希尔排序算法。
运行结果如下：
代码中的第 8 行初始化一个需要排序的数组，后面按照从小到大的排序规则，实现了数组的排序。第 12 行至 30 行是整个希尔排序的流程。第 14 行代码表示希尔排序中的增量每次整除 2 取得，第 17 行至 25 行是一个 for 循环结构，表明按照增量进行插入排序。最后第 32 行代码输出排序好的数组。
本节主要学习了希尔排序算法，通过本节课程的学习，需要熟悉希尔排序的算法流程，知道希尔排序算法的实现思路，可以自己用代码实现希尔排序算法。至此，我们已经学习了排序算法中的冒泡排序、插入排序、选择排序、希尔排序。
