常用排序算法总结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 代码实现

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 代码实现

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 代码实现

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）