冒泡排序
冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求，如果不满足就让它俩互换。
稳定性：冒泡排序是稳定的排序算法。
空间复杂度：冒泡排序是原地排序算法。
时间复杂度：
-
最好情况（满有序度）：O(n)。
-
最坏情况（满逆序度）：O(n^2)。
package com.Arithmetic;
public class Maopao {
//冒泡排序
public void sort(int [] array) {
System.out.print("排序前");
this.print(array);
int p=0;
for(int i=0;i<array.length;i++) {
//对每个元素进行对比
for(int j=0;j<array.length-1-i;j++) {
//每次把最大的置于底层，共需对比length-1-i次
if(array[j]>array[j+1]) {
p=array[j];
array[j]=array[j+1];
array[j+1]=p;
}
}
}
System.out.print("排序后");
this.print(array);
}
public void print(int[] array) {
for(int i=0;i<array.length;i++) {
System.out.print(array[i]+" ");
}
System.out.println("");
}
public static void main(String args[]) {
int[] a = {2,4,12,64,11,59,37,24};
Maopao n = new Maopao();
n.sort(a);
}
}
在排序函数中，实际上就是两个嵌套循环，里面的循环是为了将上下两个进行大小比较，并将大的移到下面，外面的循环是为了保证从上到下每一位都相互比较过了。
插入排序
插入排序将数组数据分成已排序区间和未排序区间。初始已排序区间只有一个元素，即数组第一个元素。在未排序区间取出一个元素插入到已排序区间的合适位置，直到未排序区间为空。
空间复杂度：插入排序是原地排序算法。
时间复杂度：
- 最好情况：O(n)。
- 最坏情况：O(n^2)。
- 平均情况：O(n^2)（往数组中插入一个数的平均时间复杂度是O(n)，一共重复n次）。
稳定性：插入排序是稳定的排序算法。
package com.Arithmetic;
public class Charu {
public void sort(int[] array) {
System.out.println("排序前");
this.print(array);
int p;
for(int j=1;j<array.length;j++) {
//第一个数据默认有序
int flag=j;
for(int i=j;i>=0;i--) {
//i是j的倒序开始
if(array[flag]<array[i]) {
//对于前面的数据，由后向前开始比较
p=array[flag];
array[flag]=array[i];
array[i]=p;
flag=i;
}
}
}
System.out.println("排序后");
this.print(array);
}
public void sort_G(int [] array) {
System.out.println("排序前");
this.print(array);
int current;
for(int i=0;i<array.length-1;i++) {
current = array[i+1];
int preindex = i;
//因为保证了前面的数据都是已排好序的数据，只要遇到一个不满足的就表明已找到正确位置
//此时可以停止向前循环，否则继续向前找，并将数据后移
//每次循环，保证了数据轮流后移
while(preindex>=0 && current <array[preindex]) {
array[preindex+1]=array[preindex];
preindex--;
}
//将数据赋值给最终的位置，在此之前，已经把其余的数据向后移动完了
array[preindex+1]=current;
}
System.out.println("排序后");
this.print(array);
}
public void print(int[] array) {
for(int i=0;i<array.length;i++) {
System.out.print(array[i]+" ");
}
System.out.println("");
}
public static void main(String[] args) {
Charu m = new Charu();
int[] a = {2,4,12,64,11,59,37,24};
//m.sort(a);
m.sort_G(a);
}
}
整个插入排序的基础就是保证有序，所以在这样的情况下，由后向前进行对比，比较完判断是插入还是继续移动，因为在一开始就规定了有序所以插入的时候逻辑就很清晰
选择排序
选择排序将数组分成已排序区间和未排序区间。初始已排序区间为空。每次从未排序区间中选出最小的元素插入已排序区间的末尾，直到未排序区间为空。
空间复杂度：选择排序是原地排序算法。
时间复杂度：（都是O(n^2)）
1. 最好情况：O(n^2)。
2. 最坏情况：O(n^2)。
3. 平均情况：O(n^2)。
稳定性：选择排序不是稳定的排序算法。
package com.Arithmetic;
public class Xuanze {
public void sort(int [] array) {
System.out.print("排序前");
this.print(array);
for(int j=0;j<array.length;j++) {
int min=j;
//从j之后选出最小的数据
for(int i=j;i<array.length;i++) {
if(array[min]<array[i]) {
min=i;
}
}
//将最小的数据，放入到已排好序的数组最后
int p=array[j];
array[j]=array[min];
array[min]=p;
}
System.out.print("排序后");
this.print(array);
}
public void print(int[] array) {
for(int i=0;i<array.length;i++) {
System.out.print(array[i]+" ");
}
System.out.println("");
}
public static void main(String[] args) {
int[] a = {2,4,12,64,11,59,37,24};
Maopao n = new Maopao();
n.sort(a);
}
}
选择排序也是需要进行两个for的嵌套，内部嵌套是为了找出目前最小的数字，然后将其添加到有序数组中，外部循环是为了遍历一遍原数组，挨个找出最小数字