数组
优点：查询快,如果知道索引可以快速地存取
缺点：删除慢,大小固定
有序数组
优点：比无序数组查找快
缺点：删除和插入慢，大小固定
栈
优点：提供后进先出的存取方式
缺点：存取其他项很慢
队列
优点：提供先进先出的存取方式
缺点：存取其他项都很慢
链表
优点：插入快，删除快
缺点：查找慢(一个个节点查)
二叉树
优点：查找，插入，删除都快（平衡二叉树）
缺点：删除算法复杂
红-黑树
优点：查找，插入，删除都快，树总是平衡的(局部调整)
缺点：算法复杂
2-3-4树
优点：查找，插入，删除都快，树总是平衡的。类似的树对磁盘存储有用
缺点：算法复杂
哈希表
优点：如果关键字已知则存取速度极快，插入快
缺点：删除慢，如果不知道关键字则存取很慢，对存储空间使用不充分
堆
优点：插入，删除快，对最大数据的项存取很快
缺点：对其他数据项存取很慢
图
优点：对现实世界建模
缺点：有些算法慢且复杂
1.插入排序算法
插入排序的基本思想是在遍历数组的过程中，假设在序号 i 之前的元素即 [0..i-1] 都已经排好序，本趟需要找到 i 对应的元素 x 的正确位置 k ，并且在寻找这个位置 k 的过程中逐个将比较过的元素往后移一位，为元素 x “腾位置”，最后将 k 对应的元素值赋为 x ，一般情况下，插入排序的时间复杂度和空间复杂度分别为 O(n2 ) 和 O(1)。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
/**
* @param int[] 未排序数组
* @return int[] 排完序数组
*/
public
int
[] sortInsert(
int
[] array){
for
(
int
i=
1
;i<array.length;i++){
int
temp = array[i];
int
j;
for
(j=i-
1
;j >=
0
&& temp< array[j]; j--){
array[j +
1
] = array[j];
}
array[j +
1
] = temp;
}
return
array;
}
|
2.选择排序算法
选择排序的基本思想是遍历数组的过程中，以 i 代表当前需要排序的序号，则需要在剩余的 [i…n-1] 中找出其中的最小值，然后将找到的最小值与 i 指向的值进行交换。因为每一趟确定元素的过程中都会有一个选择最大值的子流程，所以人们形象地称之为选择排序。选择排序的时间复杂度和空间复杂度分别为 O(n2 ) 和 O(1) 。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
/**
* @param int[] 未排序数组
* @return int[] 排完序数组
*/
public
int
[] sortSelect(
int
[] arr){
for
(
int
i =
0
; i < arr.length; i++) {
int
miniPost = i;
for
(
int
m = i +
1
; m < arr.length; m++) {
if
(arr[m] < arr[miniPost]) {
miniPost = m;
}
}
if
(arr[i] > arr[miniPost]) {
int
temp;
temp = arr[i];
arr[i] = arr[miniPost];
arr[miniPost] = temp;
}
}
return
arr;
}
|
3.冒泡排序算法
冒泡排序是將比較大的數字沉在最下面，较小的浮在上面
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
/**
* @param int[] 未排序数组
* @return int[] 排完序数组
*/
public
int
[] sortBubble(
int
[] array){
int
temp;
// 第一层循环:表明比较的次数, 比如 length 个元素,比较次数为 length-1 次（肯定不需和自己比）
for
(
int
i=
0
;i<array.length-
1
;i++){
for
(
int
j = array.length -
1
; j > i; j--) {
if
(array[j] < array[j -
1
]) {
temp = array[j];
array[j] = array[j -
1
];
array[j -
1
] = temp;
}
}
}
return
array;
}
|
4.快速排序算法
通过一趟排序将待排记录分割成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,则可以分别对这两部分记录继续进行排序,已达到整个序列有序的目的，本质就是,找一个基位(枢轴,分水岭,作用是左边的都比它小,右边的都比它大.可随机,取名base，首先从序列最右边开始找比base小的,如果小,换位置,从而base移到刚才右边(比较时比base小)的位置(记为临时的high位),这样base右边的都比base大。然后,从序列的最左边开始找比base大的，如果大,换位置,从而base移动到刚才左边(比较时比base大)的位置(记为临时的low位),这样base左边的都比base小，循环以上两步,直到 low == heigh, 这使才真正的找到了枢轴,分水岭. 返回这个位置,分水岭左边和右边的序列,分别再来递归。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
/**
* @param int[] 未排序数组
* @return int[] 排完序数组
*/
public
int
[] sortQuick(
int
[] array){
return
quickSort(array,
0
, array.length-
1
);
}
private
int
[] quickSort(
int
[] arr,
int
low,
int
heigh) {
if
(low < heigh) {
int
division = partition(arr, low, heigh);
quickSort(arr, low, division -
1
);
quickSort(arr, division +
1
, heigh);
}
return
arr;
}
// 分水岭,基位,左边的都比这个位置小,右边的都大
private
int
partition(
int
[] arr,
int
low,
int
heigh) {
int
base = arr[low];
//用子表的第一个记录做枢轴(分水岭)记录
while
(low < heigh) {
//从表的两端交替向中间扫描
while
(low < heigh && arr[heigh] >= base) {
heigh--;
}
// base 赋值给 当前 heigh 位,base 挪到(互换)到了这里,heigh位右边的都比base大
swap(arr, heigh, low);
while
(low < heigh && arr[low] <= base) {
low++;
}
// 遇到左边比base值大的了,换位置
swap(arr, heigh, low);
}
// now low = heigh;
return
low;
}
private
void
swap(
int
[] arr,
int
a,
int
b) {
int
temp;
temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
|
5.合并排序算法
归并排序采用的是递归来实现，属于“分而治之”，将目标数组从中间一分为二，之后分别对这两个数组进行排序，排序完毕之后再将排好序的两个数组“归并”到一起，归并排序最重要的也就是这个“归并”的过程，归并的过程中需要额外的跟需要归并的两个数组长度一致的空间
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
|
/**
* @param int[] 未排序数组
* @return int[] 排完序数组
*/
private
int
[] sort(
int
[] nums,
int
low,
int
high) {
int
mid = (low + high) /
2
;
if
(low < high) {
// 左边
sort(nums, low, mid);
// 右边
sort(nums, mid +
1
, high);
// 左右归并
merge(nums, low, mid, high);
}
return
nums;
}
private
void
merge(
int
[] nums,
int
low,
int
mid,
int
high) {
int
[] temp =
new
int
[high - low +
1
];
int
i = low;
// 左指针
int
j = mid +
1
;
// 右指针
int
k =
0
;
// 把较小的数先移到新数组中
while
(i <= mid && j <= high) {
if
(nums[i] < nums[j]) {
temp[k++] = nums[i++];
}
else
{
temp[k++] = nums[j++];
}
}
// 把左边剩余的数移入数组
while
(i <= mid) {
temp[k++] = nums[i++];
}
// 把右边边剩余的数移入数组
while
(j <= high) {
temp[k++] = nums[j++];
}
// 把新数组中的数覆盖nums数组
for
(
int
k2 =
0
; k2 < temp.length; k2++) {
nums[k2 + low] = temp[k2];
}
}
public
int
[] sortMerge(
int
[] array) {
return
sort(array,
0
, array.length -
1
);
}
|
6.希尔排序算法
希尔排序的诞生是由于插入排序在处理大规模数组的时候会遇到需要移动太多元素的问题。希尔排序的思想是将一个大的数组“分而治之”，划分为若干个小的数组，以 gap 来划分，比如数组 [1, 2, 3, 4, 5, 6, 7, 8] ，如果以 gap = 2 来划分，可以分为 [1, 3, 5, 7] 和 [2, 4, 6, 8] 两个数组（对应的，如 gap = 3 ， 则划分的数组为： [1, 4, 7] 、 [2, 5, 8] 、 [3, 6] ）然后分别对划分出来的数组进行插入排序，待各个子数组排序完毕之后再减小 gap 值重复进行之前的步骤，直至 gap = 1 ，即对整个数组进行插入排序，此时的数组已经基本上快排好序了，所以需要移动的元素会很小很小，解决了插入排序在处理大规模数组时较多移动次数的问题，
希尔排序是插入排序的改进版，在数据量大的时候对效率的提升帮助很大，数据量小的时候建议直接使用插入排序就好了。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
/**
* @param int[] 未排序数组
* @return int[] 排完序数组
*/
public
int
[] sortShell(
int
[] array) {
// 取增量
int
step = array.length /
2
;
while
(step >=
1
) {
for
(
int
i = step; i < array.length; i++) {
int
temp = array[i];
int
j =
0
;
// 跟插入排序的区别就在这里
for
(j = i - step; j >=
0
&& temp < array[j]; j -= step) {
array[j + step] = array[j];
}
array[j + step] = temp;
}
step /=
2
;
}
return
array;
}
|
7.堆排序算法
本质就是先构造一个大顶堆,parent比children大,root节点就是最大的节点 把最大的节点(root)与尾节点(最后一个节点,比较小)位置互换，剩下最后的尾节点,现在最大,其余的,从第一个元素开始到尾节点前一位,构造大顶堆递归。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
|
/**
* @param int[] 未排序数组
* @return int[] 排完序数组
*/
public
int
[] sortHeap(
int
[] array) {
buildHeap(array);
// 构建堆
int
n = array.length;
int
i =
0
;
for
(i = n -
1
; i >=
1
; i--) {
swap(array,
0
, i);
heapify(array,
0
, i);
}
return
array;
}
private
void
buildHeap(
int
[] array) {
int
n = array.length;
// 数组中元素的个数
for
(
int
i = n /
2
-
1
; i >=
0
; i--)
heapify(array, i, n);
}
private
void
heapify(
int
[] A,
int
idx,
int
max) {
int
left =
2
* idx +
1
;
// 左孩子的下标（如果存在的话）
int
right =
2
* idx +
2
;
// 左孩子的下标（如果存在的话）
int
largest =
0
;
// 寻找3个节点中最大值节点的下标
if
(left < max && A[left] > A[idx])
largest = left;
else
largest = idx;
if
(right < max && A[right] > A[largest])
largest = right;
if
(largest != idx) {
swap(A, largest, idx);
heapify(A, largest, max);
}
}
}
// 建堆函数，认为【s，m】中只有 s
// 对应的关键字未满足大顶堆定义，通过调整使【s，m】成为大顶堆=====================================================
public
static
void
heapAdjust(
int
[] array,
int
s,
int
m) {
// 用0下标元素作为暂存单元
array[
0
] = array[s];
// 沿孩子较大的结点向下筛选
for
(
int
j =
2
* s; j <= m; j *=
2
) {
// 保证j为较大孩子结点的下标，j < m 保证 j+1 <= m ，不越界
if
(j < m && array[j] < array[j +
1
]) {
j++;
}
if
(!(array[
0
] < array[j])) {
break
;
}
// 若S位较小，应将较大孩子上移
array[s] = array[j];
// 较大孩子的值变成S位的较小值，可能引起顶堆的不平衡，故对其所在的堆进行筛选
s = j;
}
// 若S位较大，则值不变；否则，S位向下移动至2*s、4*s、。。。
array[s] = array[
0
];
}
|
数组
优点：查询快,如果知道索引可以快速地存取
缺点：删除慢,大小固定
有序数组
优点：比无序数组查找快
缺点：删除和插入慢，大小固定
栈
优点：提供后进先出的存取方式
缺点：存取其他项很慢
队列
优点：提供先进先出的存取方式
缺点：存取其他项都很慢
链表
优点：插入快，删除快
缺点：查找慢(一个个节点查)
二叉树
优点：查找，插入，删除都快（平衡二叉树）
缺点：删除算法复杂
红-黑树
优点：查找，插入，删除都快，树总是平衡的(局部调整)
缺点：算法复杂
2-3-4树
优点：查找，插入，删除都快，树总是平衡的。类似的树对磁盘存储有用
缺点：算法复杂
哈希表
优点：如果关键字已知则存取速度极快，插入快
缺点：删除慢，如果不知道关键字则存取很慢，对存储空间使用不充分
堆
优点：插入，删除快，对最大数据的项存取很快
缺点：对其他数据项存取很慢
图
优点：对现实世界建模
缺点：有些算法慢且复杂
1.插入排序算法
插入排序的基本思想是在遍历数组的过程中，假设在序号 i 之前的元素即 [0..i-1] 都已经排好序，本趟需要找到 i 对应的元素 x 的正确位置 k ，并且在寻找这个位置 k 的过程中逐个将比较过的元素往后移一位，为元素 x “腾位置”，最后将 k 对应的元素值赋为 x ，一般情况下，插入排序的时间复杂度和空间复杂度分别为 O(n2 ) 和 O(1)。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
/**
* @param int[] 未排序数组
* @return int[] 排完序数组
*/
public
int
[] sortInsert(
int
[] array){
for
(
int
i=
1
;i<array.length;i++){
int
temp = array[i];
int
j;
for
(j=i-
1
;j >=
0
&& temp< array[j]; j--){
array[j +
1
] = array[j];
}
array[j +
1
] = temp;
}
return
array;
}
|
2.选择排序算法
选择排序的基本思想是遍历数组的过程中，以 i 代表当前需要排序的序号，则需要在剩余的 [i…n-1] 中找出其中的最小值，然后将找到的最小值与 i 指向的值进行交换。因为每一趟确定元素的过程中都会有一个选择最大值的子流程，所以人们形象地称之为选择排序。选择排序的时间复杂度和空间复杂度分别为 O(n2 ) 和 O(1) 。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
/**
* @param int[] 未排序数组
* @return int[] 排完序数组
*/
public
int
[] sortSelect(
int
[] arr){
for
(
int
i =
0
; i < arr.length; i++) {
int
miniPost = i;
for
(
int
m = i +
1
; m < arr.length; m++) {
if
(arr[m] < arr[miniPost]) {
miniPost = m;
}
}
if
(arr[i] > arr[miniPost]) {
int
temp;
temp = arr[i];
arr[i] = arr[miniPost];
arr[miniPost] = temp;
}
}
return
arr;
}
|
3.冒泡排序算法
冒泡排序是將比較大的數字沉在最下面，较小的浮在上面
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
/**
* @param int[] 未排序数组
* @return int[] 排完序数组
*/
public
int
[] sortBubble(
int
[] array){
int
temp;
// 第一层循环:表明比较的次数, 比如 length 个元素,比较次数为 length-1 次（肯定不需和自己比）
for
(
int
i=
0
;i<array.length-
1
;i++){
for
(
int
j = array.length -
1
; j > i; j--) {
if
(array[j] < array[j -
1
]) {
temp = array[j];
array[j] = array[j -
1
];
array[j -
1
] = temp;
}
}
}
return
array;
}
|
4.快速排序算法
通过一趟排序将待排记录分割成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,则可以分别对这两部分记录继续进行排序,已达到整个序列有序的目的，本质就是,找一个基位(枢轴,分水岭,作用是左边的都比它小,右边的都比它大.可随机,取名base，首先从序列最右边开始找比base小的,如果小,换位置,从而base移到刚才右边(比较时比base小)的位置(记为临时的high位),这样base右边的都比base大。然后,从序列的最左边开始找比base大的，如果大,换位置,从而base移动到刚才左边(比较时比base大)的位置(记为临时的low位),这样base左边的都比base小，循环以上两步,直到 low == heigh, 这使才真正的找到了枢轴,分水岭. 返回这个位置,分水岭左边和右边的序列,分别再来递归。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
/**
* @param int[] 未排序数组
* @return int[] 排完序数组
*/
public
int
[] sortQuick(
int
[] array){
return
quickSort(array,
0
, array.length-
1
);
}
private
int
[] quickSort(
int
[] arr,
int
low,
int
heigh) {
if
(low < heigh) {
int
division = partition(arr, low, heigh);
quickSort(arr, low, division -
1
);
quickSort(arr, division +
1
, heigh);
}
return
arr;
}
// 分水岭,基位,左边的都比这个位置小,右边的都大
private
int
partition(
int
[] arr,
int
low,
int
heigh) {
int
base = arr[low];
//用子表的第一个记录做枢轴(分水岭)记录
while
(low < heigh) {
//从表的两端交替向中间扫描
while
(low < heigh && arr[heigh] >= base) {
heigh--;
}
// base 赋值给 当前 heigh 位,base 挪到(互换)到了这里,heigh位右边的都比base大
swap(arr, heigh, low);
while
(low < heigh && arr[low] <= base) {
low++;
}
// 遇到左边比base值大的了,换位置
swap(arr, heigh, low);
}
// now low = heigh;
return
low;
}
private
void
swap(
int
[] arr,
int
a,
int
b) {
int
temp;
temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
|
5.合并排序算法
归并排序采用的是递归来实现，属于“分而治之”，将目标数组从中间一分为二，之后分别对这两个数组进行排序，排序完毕之后再将排好序的两个数组“归并”到一起，归并排序最重要的也就是这个“归并”的过程，归并的过程中需要额外的跟需要归并的两个数组长度一致的空间
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
|
/**
* @param int[] 未排序数组
* @return int[] 排完序数组
*/
private
int
[] sort(
int
[] nums,
int
low,
int
high) {
int
mid = (low + high) /
2
;
if
(low < high) {
// 左边
sort(nums, low, mid);
// 右边
sort(nums, mid +
1
, high);
// 左右归并
merge(nums, low, mid, high);
}
return
nums;
}
private
void
merge(
int
[] nums,
int
low,
int
mid,
int
high) {
int
[] temp =
new
int
[high - low +
1
];
int
i = low;
// 左指针
int
j = mid +
1
;
// 右指针
int
k =
0
;
// 把较小的数先移到新数组中
while
(i <= mid && j <= high) {
if
(nums[i] < nums[j]) {
temp[k++] = nums[i++];
}
else
{
temp[k++] = nums[j++];
}
}
// 把左边剩余的数移入数组
while
(i <= mid) {
temp[k++] = nums[i++];
}
// 把右边边剩余的数移入数组
while
(j <= high) {
temp[k++] = nums[j++];
}
// 把新数组中的数覆盖nums数组
for
(
int
k2 =
0
; k2 < temp.length; k2++) {
nums[k2 + low] = temp[k2];
}
}
public
int
[] sortMerge(
int
[] array) {
return
sort(array,
0
, array.length -
1
);
}
|
6.希尔排序算法
希尔排序的诞生是由于插入排序在处理大规模数组的时候会遇到需要移动太多元素的问题。希尔排序的思想是将一个大的数组“分而治之”，划分为若干个小的数组，以 gap 来划分，比如数组 [1, 2, 3, 4, 5, 6, 7, 8] ，如果以 gap = 2 来划分，可以分为 [1, 3, 5, 7] 和 [2, 4, 6, 8] 两个数组（对应的，如 gap = 3 ， 则划分的数组为： [1, 4, 7] 、 [2, 5, 8] 、 [3, 6] ）然后分别对划分出来的数组进行插入排序，待各个子数组排序完毕之后再减小 gap 值重复进行之前的步骤，直至 gap = 1 ，即对整个数组进行插入排序，此时的数组已经基本上快排好序了，所以需要移动的元素会很小很小，解决了插入排序在处理大规模数组时较多移动次数的问题，
希尔排序是插入排序的改进版，在数据量大的时候对效率的提升帮助很大，数据量小的时候建议直接使用插入排序就好了。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
/**
* @param int[] 未排序数组
* @return int[] 排完序数组
*/
public
int
[] sortShell(
int
[] array) {
// 取增量
int
step = array.length /
2
;
while
(step >=
1
) {
for
(
int
i = step; i < array.length; i++) {
int
temp = array[i];
int
j =
0
;
// 跟插入排序的区别就在这里
for
(j = i - step; j >=
0
&& temp < array[j]; j -= step) {
array[j + step] = array[j];
}
array[j + step] = temp;
}
step /=
2
;
}
return
array;
}
|
7.堆排序算法
本质就是先构造一个大顶堆,parent比children大,root节点就是最大的节点 把最大的节点(root)与尾节点(最后一个节点,比较小)位置互换，剩下最后的尾节点,现在最大,其余的,从第一个元素开始到尾节点前一位,构造大顶堆递归。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
|
/**
* @param int[] 未排序数组
* @return int[] 排完序数组
*/
public
int
[] sortHeap(
int
[] array) {
buildHeap(array);
// 构建堆
int
n = array.length;
int
i =
0
;
for
(i = n -
1
; i >=
1
; i--) {
swap(array,
0
, i);
heapify(array,
0
, i);
}
return
array;
}
private
void
buildHeap(
int
[] array) {
int
n = array.length;
// 数组中元素的个数
for
(
int
i = n /
2
-
1
; i >=
0
; i--)
heapify(array, i, n);
}
private
void
heapify(
int
[] A,
int
idx,
int
max) {
int
left =
2
* idx +
1
;
// 左孩子的下标（如果存在的话）
int
right =
2
* idx +
2
;
// 左孩子的下标（如果存在的话）
int
largest =
0
;
// 寻找3个节点中最大值节点的下标
if
(left < max && A[left] > A[idx])
largest = left;
else
largest = idx;
if
(right < max && A[right] > A[largest])
largest = right;
if
(largest != idx) {
swap(A, largest, idx);
heapify(A, largest, max);
}
}
}
// 建堆函数，认为【s，m】中只有 s
// 对应的关键字未满足大顶堆定义，通过调整使【s，m】成为大顶堆=====================================================
public
static
void
heapAdjust(
int
[] array,
int
s,
int
m) {
// 用0下标元素作为暂存单元
array[
0
] = array[s];
// 沿孩子较大的结点向下筛选
for
(
int
j =
2
* s; j <= m; j *=
2
) {
// 保证j为较大孩子结点的下标，j < m 保证 j+1 <= m ，不越界
if
(j < m && array[j] < array[j +
1
]) {
j++;
}
if
(!(array[
0
] < array[j])) {
break
;
}
// 若S位较小，应将较大孩子上移
array[s] = array[j];
// 较大孩子的值变成S位的较小值，可能引起顶堆的不平衡，故对其所在的堆进行筛选
s = j;
}
// 若S位较大，则值不变；否则，S位向下移动至2*s、4*s、。。。
array[s] = array[
0
];
}
|