冒泡排序
排序原理：
- 比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。
- 对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值
代码实现：
import java.util.Arrays;
public class BubbleSort {
public static void main(String[] aaa) {
int[] a=new int[]{5,2,4,3,1,8,6,7};
sort(a);
System.out.print(Arrays.toString(a));
}
public static void sort(int[] a) {
for(int i=0;i<a.length-1;i++)
{
for(int j=0;j<a.length-1-i;j++)
{
if(a[j]>a[j+1])
{
int temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
}
}
时间复杂度分析：
冒泡排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，所以，
我们分析冒泡排序的时间复杂度，主要分析一下内层循环体的执行次数即可。
在最坏情况下，也就是假如要排序的元素为{6,5,4,3,2,1}逆序，那么：
- 元素比较的次数为： (N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;
- 元素交换的次数为： (N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;
总执行次数为：(N^2/2-N/2)+(N^2/2-N/2)=N^2-N;
按照大O推导法则，保留函数中的最高阶项那么最终冒泡排序的时间复杂度为O(N^2)
选择排序
排序原理：
- 每一次遍历的过程中，都假定第一个索引处的元素是最小值，和其他索引处的值依次进行比较，如果当前索引处的值大于其他某个索引处的值，则假定其他某个索引出的值为最小值，最后可以找到最小值所在的索引
- 交换第一个索引处和最小值所在的索引处的值
代码实现：
import java.util.Arrays;
public class SearchSort {
public static void main(String[] aaa) {
int[] a=new int[]{5,2,4,3,1,8,6,7};
sort(a);
System.out.print(Arrays.toString(a));
}
public static void sort(int[] a) {
//第一层循环，控制遍历次数
for(int i=0;i<a.length-1;i++)
{
//min记录最小的数
int min=a[i];
//minNum记录最小的数的下标，用于下面的交换
int minNum=i;
//第二层循环，遍历比较出最小值
for(int j=i+1;j<a.length;j++)
{
if(min>a[j])
{
min=a[j];
minNum=j;
}
}
//将最小值移动到最前面
a[minNum]=a[i];
a[i]=min;
}
}
}时间复杂度分析：
选择排序使用了双层for循环，其中外层循环完成了数据交换，内层循环完成了数据比较，所以我们分别统计数据交换次数和数据比较次数：
- 数据比较次数：(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;
- 数据交换次数：N-1
总执行次数为：N^2/2-N/2+（N-1）=N^2/2+N/2-1;
根据大O推导法则，保留最高阶项，去除常数因子，时间复杂度为O(N^2)
插入排序
排序原理：
- 把所有的元素分为两组，已经排序的和未排序的；
- 找到未排序的组中的第一个元素，向已经排序的组中进行插入；
- 倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入元素，那么就把待插入元素放到这个位置，其他的元素向后移动一位；
代码实现：
import java.util.Arrays;
public class InsertSort {
public static void main(String[] aaa) {
int[] a=new int[]{1,3,12,5,3,123,5,4676,54};
System.out.println(Arrays.toString(a));
sort(a);
System.out.println(Arrays.toString(a));
}
public static void sort(int[] a)
{
for(int i=1;i<a.length;i++)
{
for(int j=i;j-1>=0;j--)
{
if(a[j-1]>a[j])
{
int temp=a[j-1];
a[j-1]=a[j];
a[j]=temp;
}
else break;
}
}
}
}时间复杂度分析：
插入排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，所以，我们分析插入排序的时间复杂度，主要分析一下内层循环体的执行次数即可。
最坏情况，也就是待排序的数组元素为{12,10,6,5,4,3,2,1}，那么：
- 比较的次数为： (N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;
- 交换的次数为： (N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;
总执行次数为：(N^2/2-N/2)+(N^2/2-N/2)=N^2-N;
按照大O推导法则，保留函数中的最高阶项那么最终插入排序的时间复杂度为O(N^2)
快速排序
快速排序是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
排序原理：
- 首先设定一个分界值，通过该分界值将数组分成左右两部分。
- 将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边。此时左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值。
- 然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
- 重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。
切分原理：
把一个数组切分成两个子数组的基本思想：
- 找一个基准值，用两个指针分别指向数组的头部和尾部；
- 先从尾部向头部开始搜索一个比基准值小的元素，搜索到即停止，并记录指针的位置；
- 再从头部向尾部开始搜索一个比基准值大的元素，搜索到即停止，并记录指针的位置；
- 交换当前左边指针位置和右边指针位置的元素；
- 重复2,3,4步骤，直到左边指针的值大于右边指针的值停止；
代码实现：
import java.util.Arrays;
public class QuickSort {
public static void main(String[] args) {
int[] a=new int[]{50,23,88,35,65,53,90,13,52,42,16,18,73,25,77,66};
System.out.println(Arrays.toString(a));
sort(a,0,a.length-1);
System.out.println(Arrays.toString(a));
}
public static void sort(int[] a,int b,int e)
{
if(b>=e) return;
int i=b;
int j=e;
while(i<j) {
if(a[i]>a[i+1]) {
int temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;
i++;
}else {
int temp=a[j];
a[j]=a[i+1];
a[i+1]=temp;
j--;
}
}
sort(a,b,i-1);
sort(a,i+1,e);
}
}时间复杂度分析：
快速排序的一次切分从两头开始交替搜索，直到left和right重合，因此，一次切分算法的时间复杂度为O(n),但整个快速排序的时间复杂度和切分的次数相关。
最优情况：每一次切分选择的基准数字刚好将当前序列等分。
如果我们把数组的切分看做是一个树，那么上图就是它的最优情况的图示，共切分了logn次，所以，最优情况下快速排序的时间复杂度为O(nlogn);
最坏情况：每一次切分选择的基准数字是当前序列中最大数或者最小数，这使得每次切分都会有一个子组，那么总共就得切分n次，所以，最坏情况下，快速排序的时间复杂度为O(n^2);
平均情况：每一次切分选择的基准数字不是最大值和最小值，也不是中值，这种情况我们可以用数学归纳法证明，快速排序的时间复杂度为O(nlogn);
希尔排序
排序原理：
- 选定一个增长量h，按照增长量h作为数据分组的依据，对数据进行分组；
- 对分好组的每一组数据完成插入排序；
- 减小增长量，最小减为1，重复第二步操作；
代码实现：
import java.util.Arrays;
public class ShellSort {
public static void main(String[] args) {
int[] a=new int[]{5,2,4,35,13,1,8,6,32,7,543};
System.out.println(Arrays.toString(a));
sort(a);
System.out.println(Arrays.toString(a));
}
public static void sort(int[] a)
{
for(int gap=a.length/2;gap>0;gap/=2)
{
for(int i=gap;i<a.length;i++)
{
for(int j=i;j-gap>=0;j--)
{
if(a[j-gap]>a[j])
{
int temp=a[j-gap];
a[j-gap]=a[j];
a[j]=temp;
}
else break;
}
}
}
}
}时间复杂度分析：
在希尔排序中，增长量h并没有固定的规则，有很多论文研究了各种不同的递增序列，但都无法证明某个序列是最好的，因此对于希尔排序不做时间复杂度分析
归并排序
排序原理：
- 尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是1为止；
- 将相邻的两个子组进行合并成一个有序的大组；
- 不断的重复步骤2，直到最终只有一个组为止；
归并原理：
代码实现：
import java.util.Arrays;
public class MergeSort1 {
public static void main(String[] args) {
int[] a=new int[]{50,23,88,35,65,53,90,13,52,42,16,18,73,25,77,66};
System.out.println(Arrays.toString(a));
sort(a,0,a.length-1);
System.out.println(Arrays.toString(a));
}
public static void sort(int[] a,int l,int r)
{
if(l==r) return;
int mid=(l+r)/2;
sort(a,l,mid);
sort(a,mid+1,r);
int[] temp=new int[r-l+1];
int i=0;
int s1=l;
int s2=mid+1;
while(s1<=mid && s2<=r)
{
if(a[s1]<a[s2])
{
temp[i]=a[s1];
s1++;
i++;
}else {
temp[i]=a[s2];
s2++;
i++;
}
}
while(s1<=mid)
{
temp[i]=a[s1];
s1++;
i++;
}
while(s2<=r)
{
temp[i]=a[s2];
s2++;
i++;
}
for(int i1=0;i1<temp.length;i1++)
{
a[l+i1]=temp[i1];
}
}
}时间复杂度分析：
用树状图来描述归并，如果一个数组有8个元素，那么它将每次除以2找最小的子数组，共拆log8次，值为3，所以树共有3层,那么自顶向下第k层有2^k个子数组，每个数组的长度为2^(3-k)，归并最多需要2^(3-k)次比较。因此每层的比较次数为 2^k * 2^(3-k)=2^3,那么3层总共为 3*2^3。
假设元素的个数为n，那么使用归并排序拆分的次数为log2(n),所以共log2(n)层，那么使用log2(n)替换上面3*2^3中的3这个层数，最终得出的归并排序的时间复杂度为：log2(n)*2^(log2(n))=log2(n)*n,根据大O推导法则，忽略底数，最终归并排序的时间复杂度为O(nlogn);
堆排序
堆可以分为大根堆，小根堆
大根堆:每个节点的值都大于或者等于他的左右孩子节点的值
小根堆:每个结点的值都小于或等于其左孩子和右孩子结点的值0
堆是用数组完成数据元素的存储的，由于数组的底层是一串连续的内存地址，所以我们要往堆中插入数据，我们只能往数组中从索引0处开始，依次往后存放数据，但是堆中对元素的顺序是有要求的，每一个结点的数据要大于等于它的两个子结点的数据，所以每次插入一个元素，都会使得堆中的数据顺序变乱，这个时候我们就需要通过一些方法让刚才插入的这个数据放入到合适的位置。
以大根堆的调整为例：
同样，删除元素也需要进行堆调整：
对于大根堆，索引1处的元素，也就是根结点是最大的元素，当我们把根结点的元素删除后，需要有一个新的根结点出现，这时我们可以暂时把堆中最后一个元素放到索引1处，充当根结点，但是它不满足大根堆的有序性需求，这个时候我们就需要通过一些方法，让这个新的根结点放入到合适的位置。
堆排序实现步骤（使用大根堆，实现从小到大排序）：
- 构造大根堆；
- 得到堆顶元素，这个值就是最大值；
- 交换堆顶元素和数组中的最后一个元素，此时所有元素中的最大元素已经放到合适的位置；
- 对堆进行调整，重新让除了最后一个元素的剩余元素中的最大值放到堆顶；
- 重复2~4这个步骤，直到堆中剩一个元素为止；
public class HeapSort {
public static void main(String[] args) {
int[] a=new int[]{5,32,4,23,1,8,64,67,35,85,12,123,543,45,23,10};
System.out.println(Arrays.toString(a));
int l=a.length;
for(int i=0;i<a.length-1;i++)
{
for(int p=l-1;p>=0;p--)
{
sort(a,p,l);
}
int temp=a[0];
a[0]=a[l-1];
a[l-1]=temp;
l--;
}
System.out.println(Arrays.toString(a));
}
public static void sort(int[] a,int p,int l)
{
int c=2*p+1;
if(c<l)
{
int rc=c+1;
if(rc<l && a[c]<a[rc]) c=rc;
if(a[p]<a[c])
{
int temp=a[p];
a[p]=a[c];
a[c]=temp;
p=c;
sort(a,p,l);
}
}
}
}
