冒泡排序
冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较,看是否满足大小关系要求,如果不满足就让它俩互换。
稳定性:冒泡排序是稳定的排序算法。
空间复杂度:冒泡排序是原地排序算法。
时间复杂度:
-
最好情况(满有序度):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的嵌套,内部嵌套是为了找出目前最小的数字,然后将其添加到有序数组中,外部循环是为了遍历一遍原数组,挨个找出最小数字