常用排序算法总结java实现（一）

目录

1.直接插入排序

2 希尔排序

3 冒泡排序

1.直接插入排序

1.1 描述

直接插入排序是一种稳定的排序算法。

直接插入排序是插入排序中最简单直接的算法，是将待排序序列中的每一个元素依次插入到排好序的序列中，类似于整理纸牌的过程。例如待排序序列：【25，8，16，21，10】

第一次：【8，25，16，21，10】

第二次：【8，16，25，21，10】

第三次：【8，16，21，25，10】

第四次：【8，10，16，21，25】

1.2 算法过程

1. 把序列第一个元素看作已排好序部分，从第二个元素开始，为待排序部分；

2. 取出待排序部分的第一个元素，与排好序部分从后往前依次比较；

3. 若取出的元素<排序元素，把记录后移一位，继续该步骤直到取出的元素>排序元素为止；

4. 在此位置插入取出的元素；

5. 重复2

1.3 代码实现

[code]import java.util.*;

public class InsertSort {
public static void InsertSorttest(int s[]) {
//从第二个元素开始，与排好序元素依次比较
for(int i=1;i < s.length; i++) {
int temp=s[i];                //待排序元素的暂存单元temp
int j=i-1;
while((j>=0) && temp<s[j] ) {    //依次比较排好序的直到不满足条件
s[j+1]=s[j];
j--;
}
s[j+1]=temp;                      //将待排序元素插入到当前位置
}
System.out.print(Arrays.toString(s));
}

public static void main(String str[]) {
int[] x= {25,8,16,21,10};
InsertSorttest(x);
}
}

输出：【8，10，16，21，25】

1.4 算法效率

最好情况：序列为正序，时间复杂度为O(N)

最好情况：序列为逆序，时间复杂度为O(N^2)

平均情况：时间复杂度为O(N^2)

2 希尔排序

2.1 描述

希尔排序是不稳定的算法。

也利用了直接插入排序，适用于当整个序列不基本有序时。主要思想是把整个序列划分为好几个子序列，在子序列中完成直接插入排序，当整个序列基本有序时，再对整个序列进行直接插入排序。

2.2 算法过程

1. 若待排序记录为n个
2. 设按间隔为d=n/2设置子序列，相距为d的为一组子序列。
3. 从第d+1个记录开始插入，与其子序列中另一个记录（第前d个）进行直接插入排序
4. 缩小d=d/2，重复3

3.3 代码实现

[code]import java.util.Arrays;

public class ShellSort {
public static void shellsorttest(int s[]) {
int n=s.length;
//		d为间隔
for(int d=n/2;d>=1;d=d/2) {
//			前n个记录为d个子序列的第一个记录，从d+1个记录开始插入,数组中表示为d
for(int i=d;i<n;i++) {
int temp=s[i];
int j=i-d;		//与i的第前d个比较
while(j>=0 && temp<s[j]) {
//					若当前插入元素小于s[j],则记录后移d
s[j+d]=s[j];
j=j-d;
}
s[j+d]=temp;
}
}
System.out.print(Arrays.toString(s));
}

public static void main(String[] args) {
int[] x= {3,6,4,8,1,10};
shellsorttest(x);
}

}

2.4 算法效率

时间复杂度：O(N^2)~O(Nlog2n）

3 冒泡排序

3.1 描述

冒泡排序是一种稳定的排序算法。

采用两两比较，大的记录后移即交换位置，就像水里的气泡，最大的先冒出来。

3.2 算法过程

1. 将序列划分为有序区和无序区，有序区初始时为空，无序区为整个序列。
2. 对无序区从前往后将相邻的两个元素依次比较，若为反序则交换双方位置，重复该步骤至无序区没有反序为止。

3.3 代码实现

[code]import java.util.*;
public class BubbleSort {
public static void bubblesort(int s[],int n) {
int k;
int flag=n;			//flag为无序区边界

while(flag>0) {
k=flag;
flag=0;        //若无交换，则flag=0，结束

for(int i=1;i<k;i++) {
//				反序则交换位置
if(s[i]<s[i-1]) {
int temp=s[i-1];
s[i-1]=s[i];
s[i]=temp;
}
flag=i;		//交换的位置
}
}
System.out.print(Arrays.toString(s));
}

public static void main(String str[]) {
int[] x= {3,6,4,8,1,10};
bubblesort(x,6);
}
}

3.4 算法效率

最好情况：序列为正序，时间复杂度为O（n）

最坏情况：为逆序，时间复杂度O（n^2）

平均情况：时间复杂度为O（n^2）