【写在前面】
前言
大O记法（ 步数）=时间复杂度、速度、性能，大O技法关注点是长期增长率，所以有以下几个注意点
大O记法：
-
忽略常数，不包括一般数字，除非是指数，例如O(N²/2)=O(N²)
-
只关注最高阶，因为随着数据量的增大，最主要的影响因素是最高阶的数据，所以O(N²+N)=O(N²)
1. 冒泡排序
- 思路：两两交换，较大的数值放后，第一次排序后最大已经在末尾
- 算法动图•ᴗ•
- 特点：需要n－1趟，比如10个数字，需要9次。for嵌套：时间复杂度是O(n²)
代码实现要点：
- 两个for循环，外层控制排序趟数，内层控制比较次数，因为每趟排序完成都会把最大的推到后面，所以每次趟数过后比较数都要减1
- 优化：如果一次排序后没有交换位置那么该数组已经有序。
int[] list=new int[]{1,4,3,2,9,7,8};
//事先申明免得每次换的时候都要实例化新的对象占用内存,设置参省防止没有循环导致的错误
int tem;
boolean isChange;
for(int i=0;i<list.length;i++)
{
isChange=false;
for(int j=0;j<list.length-1-i;j++)
{
if(list[j]>list[j+1])
{
tem=list[j];
list[j]=list[j+1];
list[j+1]=tem;
isChange=true;
}
}
//如果一趟下来没有排序，则说明已经排好了，不需要再执行后面排序
if(isChange==false)
{
break;
}
}
【补充】算法是否稳定判定方法：一个数组里相同的值，例如有两个4，结果经过排序之后，原来的第一个4排到了第二个4后面，那么就是不稳定的，反之则还是稳定的。
2. 选择排序
- 思路原理：找出等待排序的数组里最小（最大）的数，与待排序最前（最后）的数字替换，然后逐次将未排序完的循环排序，就能得到正确的数组顺序。
- 算法动图•ᴗ•
- 特点：不稳定，for嵌套：时间复杂度是O(n²)，但其实是冒泡循环的一半左右
//选择排序
int[] list=new int[]{1,4,3,2,5,10,6,9,7,8};
//事先申明免得每次换的时候都要实例化新的对象占用内存,设置参省防止没有循环导致的错误
//存放临时变量和下标
int temp,pos;
for(int i=0;i<list.length-1;i++)
{
pos=i;
for(int j=i+1;j<list.length;j++)
{
if(list[i]>list[j])
{
pos=j;
}
}
if(pos!=i)
{
temp=list[i];
list[i]=list[pos];
list[pos]=temp;
}
System.out.println("每次输出结果："+Arrays.toString(list));
}
System.out.println("最后结果:"+Arrays.toString(list));
【补充】 三大经典排序可参考链接>> 含算法动图 <<
3. 插入排序
- 思路原理：将一个数据插入到已经排好序的有序数组，从而得到一个新的、个数加1的有序数组。其实就是将前面的数组慢慢排成有序的数组（第一个默认是有序的，第二个要和第一对比排序，以此类推），每次将还没排序的数插入到前面的有序数组中，最终得到一个有序的数组。
- 特点：稳定，趟数也是n－1，时间复杂度为O(N²),但其实是O(N²+N)，适用于少量数据的排序。
//插入排序
int[] list=new int[]{1,4,3,2,5,10,6,9,7,8};
//事先申明免得每次换的时候都要实例化新的对象占用内存,设置参省防止没有循环导致的错误
//存放临时变量和下标
int temp,pos;
for(int i=1;i<list.length;i++)
{
pos=i;
temp=list[i];
System.out.println("要替换的元素下标是"+i);
//循环体有自减过程，为了替换时不越界，设置为》=1
//将待排序元素前面的元素 与待排序元素比较
//如果是for循环嵌套，那么里面还需要多一个if判断，因此换成while
while (pos>=1&&list[pos-1]>=temp) {
System.out.print("i,j="+i+","+pos+" 替换："+Arrays.toString(list)+"
");
list[pos]=list[pos-1];
pos--;
}
//替换
list[pos]=temp;
System.out.println("输出结果："+Arrays.toString(list)+"
");
}
System.out.println("最后结果:"+Arrays.toString(list));
4. 快速排序
-
思路：选定某个数字为基准数，将比基准数小的数字放到左边，大的数放到右边。
-
特点：是不稳定的
实现要点：指定最左和最右为L和R指针，如果选定的是左边第一个数字作为基准数
- （步骤1）则从右边开始移动指针，如果有比基准数小的数，则将R指针与L指针所指的数交换。
- （步骤2）第一次排序完成后，再从左边指针开始扫，如果有比基准数大的数，则将指针所指数交换。
- 重复步骤1、2，直到L和R指针的位置重复，此时说明已经完成排序。
package cn.lxy;
public class Test {
public static void main(String[] args) {
int[] list = new int[] {5, 3, 8, 50, 6, 7, 20, 4, 9};
for(int j:list)
{
System.out.print("-"+j+"-");
}
System.out.println();
System.out.println("开始快速排序");
getPartition(list,0,list.length-1);
System.out.println("排序结果");
for(int j:list)
{
System.out.print("-"+j+"-");
}
}
//找到分割点并递归
public static void getPartition(int[] list, int left, int right)
{
if(left>=right)
{
return;
}
//存放临时变量
int l,r,temp;
l=left;
r=right;
//基准数
int pivot=list[left];
while (l<r)
{
//找到比基数小的数就交换,否则就一直移动下标。
//这里的left小于right是因为后面的while可能会改变left和right的下标
while(l<r&&list[r]>pivot)
{
r--;
}
//比基准数小的话就继续移动下标
while (l<r&&list[l]<pivot)
{
l++;
}
if (l<r)
{
temp=list[l];
list[l]=list[r];
list[r]=temp;
}
System.out.println("(l:"+l+",r:"+r+")");
}
list[l]=pivot;
System.out.println("－－－基准点：list["+left+"]＝"+pivot+"－－－
排序过程：");
for (int j:list)
{
System.out.print("-"+j+"-");
}
System.out.println();
getPartition(list,left,r-1);
getPartition(list,r+1,right);
}
}
5. 其他排序
to be done