01.
/**
02.
* 带哨所
03.
*
04.
* @param sortList
05.
*/
06.
public
static
void
insertSort1(Integer[] sortList) {
07.
int
len = sortList.length;
08.
for
(
int
i =
2
; i < len; i++) {
09.
if
(sortList[i] < sortList[i -
1
]) {
10.
int
j = i -
1
;
11.
sortList[
0
] = sortList[i];
// 设置哨所
12.
while
(sortList[
0
] < sortList[j]) {
13.
sortList[j +
1
] = sortList[j];
14.
j;
15.
}
16.
sortList[j +
1
] = sortList[
0
];
17.
}
18.
}
19.
}
20.
/**
21.
* 不带哨所
22.
*
23.
* @param sortList
24.
*/
25.
public
static
void
insertSort2(Integer[] sortList) {
26.
int
len = sortList.length;
27.
for
(
int
i =
1
; i < len; i++) {
28.
if
(sortList[i] < sortList[i -
1
]) {
29.
int
j = i -
1
;
30.
int
temp = sortList[i];
31.
while
(j >=
0
&& temp < sortList[j]) {
32.
sortList[j +
1
] = sortList[j];
33.
j;
34.
}
35.
sortList[j +
1
] = temp;
36.
}
37.
}
38.
}
01.
/**
02.
* 二分查找插入排序
03.
* @param sortList
04.
*/
05.
public
static
void
insertSort3(Integer[] sortList) {
06.
int
len = sortList.length;
07.
for
(
int
i =
1
; i < len; i++) {
08.
if
(sortList[i] < sortList[i -
1
]) {
09.
//二分查找在有序区寻找插入的位置
10.
int
index = binarySearchIndex(sortList, i-
1
, sortList[i]);
11.
if
(i != index)
12.
{
13.
int
temp = sortList[i];
14.
// 后移元素,腾出arr[index]位置
15.
for
(
int
j = i -
1
; j >= index; j)
16.
sortList[j +
1
] = sortList[j];
17.
// 将 arr[i] 放到正确位置上
18.
sortList[index] = temp;
19.
}
20.
}
21.
}
22.
}
23.
24.
/**
25.
* 二分查找要插入的位置得index
26.
* @param sortList
27.
* @param maxIndex
28.
* @param data
29.
* @return
30.
*/
31.
private
static
int
binarySearchIndex(Integer[] sortList,
int
maxIndex,
int
data)
32.
{
33.
int
iBegin =
0
;
34.
int
iEnd = maxIndex;
35.
int
middle = -
1
;
36.
while
(iBegin <= iEnd)
37.
{
38.
middle = (iBegin + iEnd) /
2
;
39.
if
(sortList[middle] > data)
40.
{
41.
iEnd = middle -
1
;
42.
}
43.
else
44.
{
45.
iBegin = middle +
1
;
// 如果是相同元素,也是插入在后面的位置
46.
}
47.
}
48.
return
iBegin;
49.
}
算法复杂度
1、时间复杂度:O(n^2)
二分查找插入位置,因为不是查找相等值,而是基于比较查插入合适的位置,所以必须查到最后一个元素才知道插入位置。
二分查找最坏时间复杂度:当2^X>=n时,查询结束,所以查询的次数就为x,而x等于log2n(以2为底,n的对数),即O(log2n)。所以,二分查找排序比较次数为:x=log2n。
二分查找插入排序耗时的操作有:比较 + 后移赋值。时间复杂度如下:
1)最好情况:查找的位置是有序区的最后一位后面一位,则无须进行后移赋值操作,其比较次数为:log2n ,即O(log2n)。
2)最坏情况:查找的位置是有序区的第一个位置,则需要的比较次数为:log2n,需要的赋值操作次数为n(n-1)/2加上 (n-1) 次,即O(n^2)。
3)渐进时间复杂度(平均时间复杂度):O(n^2)。
2、空间复杂度:O(1)
二分查找插入排序是在原输入数组上进行后移赋值操作的(称“就地排序”),所需开辟的辅助空间跟输入数组规模无关,所以空间复杂度为:O(1)。
稳定性
二分查找排序是稳定的,不会改变相同元素的相对顺序。
本文出自 物联网博客,请务必保留此出处http://www.iotblog.cn/u/yangwang/b-76