冒泡排序
思路:
采用的是双循环的方法,冒泡排序按照理解是吧大的往后移,每一循环一次将最大的
移到后面,最后一个位置即固定了。当然冒泡可以冒小泡,这样就是方向排序,排出来的是逆序
代码:
/**
* 冒泡排序
* @param a
*/
protected static void bubbleSort(int[] a) {
for (int i = 1; i < a.length; i++) {
for (int j = 0; i < a.length - j; j++) {
if (a[j] > a[j + 1]) {
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}
优化:
待优化
插入排序
思路:
插入排序保证在插入的时候前面的数据是有序的(不能保证前面额数据顺序是最后的顺序)
- 插入第一个时候,在之前是没有元素的,当前元素会认为自己是最小的元素
- 后移一个元素,当前元素会和之前的元素比较(从最近的元素开始比较)
2-1. 当前元素大于之前邻近的元素,那么位置就不会改变
2-2.如果小于邻近的之前的元素,那么,就和之前的元素换位置(这样做会导致频繁的换位置,这里可以优化)
代码
/**
* 插入排序
* @param a
*/
public static void insertSort(int[] a) {
for (int i = 1; i < a.length; i++) {
for (int j = i; j > 0 && a[j] < a[j - 1]; j--) {
int temp = a[j];
a[j] = a[j - 1];
a[j - 1] = temp;
}
}
}
优化
待优化
快速排序
思路:
需要经过多次找中间值来进行排序。
- 第一次从第一个元素开始排序,从右边第一个进行比较定义temp保存当前要比较的值
1-1.如果右边一个比temp的值元素要大,那就right向左移动一个元素再进行比较
1-2.如果右边一个元素比temp的值要小,那么就将temp所在的位置的值设置为比较的那个元素
2.将temp的下表指到比较元素的那个下标 - 从左边选第一个元素来和temp的值进行比较
3-1.如果比较的值比temp的值要小,那么顺序就是对的,只需将left向右移动一位
3-2.如果比较的值比temp的值要大,那么顺序就是错的,需要将temp的位置赋值比较的那个元素
循环上面的步骤,当周到left >= right,即temp的左边一定小于temp,temp的右边一定大于temp。
如下
从上可以的知元素4的位置已经确定,再多次几次循环即可确定整个数组,上述排序每次执行完成
只会确定一个元素的位置,在从中间元素进行分组左右,进行排序。
代码:
/**
*获取中间值
**/
protected static int findPos(int[] a, int low, int high){
int temp = a[low];
while (low<high){
while (low<high && a[high]>=temp){
high--;
}
a[low] = a[high];
while (low<high && a[low]<=temp){
low++;
}
a[high] = a[low];
}
a[low] = temp;
return low;
}
//最终排序(完全顺序调用上面的quickSort方法)
protected static void quickSort(int[] a, int low, int high){
if (low>high){
return;
}
int pos = findPos(a,low,high);
quickSort(a,low,pos-1);
quickSort(a,pos+1,high);
}
优化:
有待优化
希尔排序
思路
希尔排序是优化版的插入排序,
代码
public static int[] shellSort2(int a[]) {
int step = a.length / 2;
int temp = 0;
while (step > 0) {
//分成的组数,5-2,2-5,1-10
for (int i = step; i < a.length; i++) {
for (int j = i - step; j >= 0; j -= step) {
if (a[j] > a[j + step]) {
temp = a[j];
a[j] = a[j + step];
a[j + step] = temp;
}
}
}
step = step / 2;
}
return a;
}
/*移步法,*/
public static int[] shellSort(int a[]) {
for (int grap = a.length / 2; grap >= 1; grap /= 2) {
for (int j = grap; j < a.length; j++) {
if (a[j] <= a[j - grap]) {
int temp = a[j];
int k = j - grap;
while (k >= 0 && a[k] > temp) {
a[k + grap] = a[k];
k -= grap;
}
a[k + grap] = temp;
}
}
}
return a;
}
优化