目录
1.冒泡排序
1.比较相邻的元素，如果前一个元素比后一个元素大，则交换这两个元素的位置。
2.每一对相邻元素如此反复，从开始的第一对元素到结尾的最后一对元素。最终最后的位置就是元素的最大值。
过程示例：
首先将4和5进行比较，4比5小，不需要交换元素，然后比较5和6，同理，然后是6和3比较，6比3大需要交换元素，然后是6和2，6和1比较，最后第一次冒泡结束，元素6放到了最后面。那么第二次冒泡就不需要与最后一个元素进行比较，将外层循环元素次数-1.
代码：
public class MaoPaoSort {
public static void main(String[] args) {
Integer a[]={1,3,4,5,7,2};
sort(a);
System.out.println("排序后元素为");
System.out.println(Arrays.toString(a));
}
//冒泡排序
public static void sort(Comparable [] arr){
for (int i = arr.length-1; i>0; i--) { //表示循环元素的个数 子循环循环完毕一次后 表示已经有一个最大元素已经排好序 那么就不需要参加下一次循环
for (int j = 0; j < i; j++) {
if(compare(arr[j],arr[j+1])){ //将大的放后面 小的放前面
change(arr,j,j+1);
}
}
}
}
public static boolean compare(Comparable i, Comparable j){
return i.compareTo(j)>0; //i>j 返回正数 结果为true 小于结果为false
}
//比较交换
public static void change(Comparable arr[],int i,int j){
Comparable temp= arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
2.选择排序
1.在每一次遍历的时候都假设第一个元素为最小值，记录最小元素索引值，然后和后面元素进行比较，当比较发现更小的值后，将最小索引值改为小的值，然后依次继续往后面遍历，遍历完毕后就找到了最小元素的索引值，然后将该值与第一个元素交换
代码：
public class XuanZeSort {
public static void main(String[] args) {
Integer a[]={1,3,4,5,7,2};
sort(a);
System.out.println("排序后元素为");
System.out.println(Arrays.toString(a));
}
public static void sort(Comparable [] a){
for (int i = 0; i <= a.length - 2; i++) { //最后一次不需要排序 也就是倒数第二个元素排好序后 此时不再需要和最后一个元素排序了
int minIndex=i; //默认第一个元素为最小值
for (int j = i+1; j < a.length; j++) {
if (compare(a[minIndex],a[j])){
minIndex=j;
}
}
change(a,i,minIndex);
}
}
public static boolean compare(Comparable i,Comparable j){
return i.compareTo(j)>0;
}
public static void change(Comparable [] a,int i, int j){
Comparable temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
3.插入排序
1.把所有的元素分为两组，已经排序的和未排序的；
2.找到未排序的组中的第一个元素，向已经排序的组中进行插入；
3.倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入元素，那么就把待
插入元素放到这个位置，其他的元素向后移动一位；
代码
public class InsertSort {
public static void main(String[] args) {
Integer a[]={1,3,4,5,7,2};
sort(a);
System.out.println("排序后元素为");
System.out.println(Arrays.toString(a));
}
public static void sort(Comparable [] arr){
for (int i = 1; i < arr.length; i++) { //默认从下标为1的元素开始比较 那么下标0元素就可以看做是已经排序的 然后依次类推
for (int j = i; j >0; j--) { //将 j和j-1处元素比较 知道与第一个元素 也就是下标为0处 比较完毕跳出循环
if (compare(arr[j-1],arr[j])){ //如果j-1大于j处元素 那么就需要交换
change(arr,j-1,j);
}else { //如果j-1 不大于j了 代表j已经在它最小的位置
break;
}
}
}
}
public static boolean compare(Comparable i,Comparable j){
return i.compareTo(j)>0;
}
public static void change(Comparable [] a,int i, int j){
Comparable temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
4.希尔排序
希尔排序是插入排序的一种，又称"缩小增量排序"，是插入排序算法的一种更高效的改进版本。
1.选定一个增长量h，按照增长量h作为数据分组的依据，对数据进行分组
2.对分好组的每一组数据完成插入排序；
3.减小增长量，最小减为1，重复第二步操作。
过程示例：
1.假设一个长度为10的数组，那么第一次增量确定为7，也就是从下标为7开始比较，
public static void sort(Comparable[] arr){
int N=arr.length; //确定增长量的最大值
int h=1; //初始化增长量
while (h<N/2){
h=h*2+1;
}
//当增量小于1时 排序结束
while (h>=1){
//找到待插入元素
for (int i = h; i < arr.length; i++) {
//a[i]就是待插入的元素 需要将其查到a[i-h] a[i-2h] .....
for (int j = i; j >=h; j-=h) {
//a[j]就是待插入元素，依次和a[j-h] a[j-2h]....比较，如果a[j]比a[j-h]小 则交换位置 否则跳出循环 表示插入完成
if (compare(arr[j-h],arr[j])){
change(arr,j,j-h);
}else {
break;
}
}
}
h/=2;
}
}
public static boolean compare(Comparable i, Comparable j){
return i.compareTo(j)>0; //i>j 返回正数 结果为true 小于结果为false
}
//比较交换
public static void change(Comparable arr[],int i,int j){
Comparable temp= arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
5.递归
定义方法时，在方法内部调用方法本身，称之为递归
它通常把一个大型复杂的问题，层层转换为一个与原问题相似的，规模较小的问题来求解。递归策略只需要少量的
程序就可以描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。
在递归中，不能无限制的调用自己，必须要有边界条件，能够让递归结束，因为每一次递归调用都会在栈内存开辟
新的空间，重新执行方法，如果递归的层级太深，很容易造成栈内存溢出
代码实现
public class DiguiSort {
public static void main(String[] args) {
int factorial = factorial(5);
System.out.println(factorial);
}
public static int factorial(int n){
if (n==1){
return 1;
}
return n*factorial(n-1);
}
}
6.归并排序
归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治法的一个非常典型的应用。将已有序的子 序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序 表，称为二路归并。
排序原理：
1.尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是 1为止。
2.将相邻的两个子组进行合并成一个有序的大组；
3.不断的重复步骤2，直到最终只有一个组为止。
流程演示：
代码实现：
public class Merge {
private static Comparable[] assist;//辅助数组 用于最后分治合并
public static void sort(Comparable[] arr){ //对数组内元素进行排序
//初始化辅助数组
assist=new Comparable[arr.length];
//定义两个变量 分别表示数组索引起始0 和数组最后一个索引
int length=arr.length-1;
sort(arr,0,length);
}
public static void sort(Comparable[]arr ,int head,int last){ //对数组索引first 到last之间进行排序
if (head>=last){ //安全校验
return;
}
//1.将这个数组分成两组
int first=head;
int mid=head+(last-head)/2; //这样做是防止栈溢出
//2.分组后对每一组进行排序
//对左子数组排序
sort(arr,first,mid);
//对右子数组排序
sort(arr,mid+1,last);
//3.将分组好的进行合并
merge(arr,first,mid,last);
}
public static void merge(Comparable[]arr ,int first,int mid,int last){//此处是将两个子数组进行合并成有序的大组 first-mid为一个数组 mid+1-last为一个数组
//需要三个指针 一个指针是移动 左子数组的 一个指针是右子数组的 另一个指针是新的合并数组
int p1=first; //左子数组初始节点
int p2=mid+1; //右子数组初始节点
int newArrPoint=first; //合并新数组初始节点
while (p1<=mid&&p2<=last){
if (less(arr[p1],arr[p2])){ //如果左边第一个元素比右边第一个元素小
assist[newArrPoint++]=arr[p1++]; //新数组和就数组指针+1
}else {
assist[newArrPoint++]=arr[p2++];
}
}
//上面循环条件结束 表示着 左子数组或者右子数组中有一个已经循环完毕 但不知道是左还是右 所以要将剩下的那个子数组 按顺序放到新数组中
//如果是 p1<=mid 不成立 表示左子数组排序完毕 那么循环右子数组即可
while (p2<=last){
assist[newArrPoint++]=arr[p2++];
}
while (p1<=mid){
assist[newArrPoint++]=arr[p1++];
}
//到此数组中所有数据已经全部有序 拷贝到原数组中
for (int i = first; i <=last; i++) {
arr[i]=assist[i];
}
}
private static boolean less(Comparable v,Comparable w){
return v.compareTo(w)<0; //如果v比w小 返回true
}
private static void exchange(Comparable []a ,int i,int j){
Comparable temp=a[i];
a[i]=a[j];
a[j]=temp;
}
public static void main(String[] args) throws Exception {
Integer[] arr = {8, 4, 5, 7, 1, 3, 6, 2};
Merge.sort(arr);
System.out.println(Arrays.toString(arr));
}
}
归并排序时间复杂度分析：
归并排序是分治思想的最典型的例子，上面的算法中，对a[lo...hi]进行排序，先将它分为a[lo...mid]和a[mid+1...hi]
两部分，分别通过递归调用将他们单独排序，最后将有序的子数组归并为最终的排序结果。该递归的出口在于如果
一个数组不能再被分为两个子数组，那么就会执行merge进行归并，在归并的时候判断元素的大小进行排序。
用树状图来描述归并，如果一个数组有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);
归并排序的缺点：
需要申请额外的数组空间，导致空间复杂度提升，是典型的以空间换时间的操作。
7.快速排序
快速排序是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一 部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序 过程可以递归进行，以此达到整个数据变成有序序列。
排序原理：
1.首先设定一个分界值，通过该分界值将数组分成左右两部分；
2.将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边。此时左边部分中各元素都小于 或等于分界值，而右边部分中各元素都大于或等于分界值；
3.然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两 部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
4.重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当 左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。
切分原理：
把一个数组切分成两个子数组的基本思想：
1.找一个基准值，用两个指针分别指向数组的头部和尾部；
2.先从尾部向头部开始搜索一个比基准值小的元素，搜索到即停止，并记录指针的位置（需要注意的是：若选择最左边的数据作为key，则需要end先走；若选择最右边的数据作为key，则需要bengin先走）。；
3.再从头部向尾部开始搜索一个比基准值大的元素，搜索到即停止，并记录指针的位置；
4.交换当前左边指针位置和右边指针位置的元素；
5.重复2,3,4步骤，直到直到begin和end最终相遇，此时将相遇点的内容与key交换即可。
代码实现：
public class QuickSort {
//对数组内元素进行排序
public static void sort(Comparable []a){
int left=0;
int right=a.length-1;
sort(a,left,right);
}
private static void sort(Comparable a[],int left,int right){ //对数组中left至right之间的元素进行排序
//安全校验
if (right<=left){
return;
}
//需要进行分组 返回的是分组的分界值的索引
int partition = partition(a, left, right);
//将左子组进行排序
sort(a,left,partition-1);
//右自组进行排序
sort(a,partition+1,right);
}
public static int partition(Comparable []a, int left,int right){ //进行分组 并返回分组界限对应的索引
//确定分界值 默认是待切分数组的第一个元素
Comparable key=a[left];
//定义两个指针 指向最小索引处和最大索引处+1
int head=left;
int last=right+1; //指向最大索引处的下一个位置
//进行切分
while (true){
//先从右往左找 移动右指针 直到找到比分界值小的元素后停止
while (less(key,a[--last])){ //循环停止说明找到了比分届值小的元素
if (last==left){ //说明已经找到最左边了
break;
}
}
//然后从左开始往右找,移动左指正 直到找到比分界值大的元素后停止
while (less(a[++head],key)){
if (head==right){
break; //如果左指针到了最后一个元素 跳出循环
}
}
//先进行指针判断 如果head>=last表示此时已经排序完毕了 退出循环即可 否则交换元素即可
if (head>=last){
break;
}else {
exchange(a,head,last); //此时左指针 和右指针都定位到了元素 进行交换
}
}
//交换分界基准值
exchange(a,left,last);
return last; //last就是切分的界限
}
private static boolean less(Comparable v,Comparable w){
return v.compareTo(w)<0; //如果v比w小 返回true
}
private static void exchange(Comparable []a ,int i,int j){
Comparable temp=a[i];
a[i]=a[j];
a[j]=temp;
}
public static void main(String[] args) throws Exception {
Integer[] arr = {6, 1, 2, 7, 9, 3, 4, 5, 8};
QuickSort.sort(arr);
System.out.println(Arrays.toString(arr));
}
}
快速排序和归并排序的区别：
快速排序是另外一种分治的排序算法，它将一个数组分成两个子数组，将两部分独立的排序。快速排序和归并排序 是互补的：归并排序将数组分成两个子数组分别排序，并将有序的子数组归并从而将整个数组排序，而快速排序的 方式则是当两个数组都有序时，整个数组自然就有序了。在归并排序中，一个数组被等分为两半，归并调用发生在 处理整个数组之前，在快速排序中，切分数组的位置取决于数组的内容，递归调用发生在处理整个数组之后。
快速排序时间复杂度分析：
快速排序的一次切分从两头开始交替搜索，直到left和right重合，因此，一次切分算法的时间复杂度为O(n),但整个 快速排序的时间复杂度和切分的次数相关。
最优情况：每一次切分选择的基准数字刚好将当前序列等分。
排序的稳定性
稳定性的定义：
数组arr中有若干元素，其中A元素和B元素相等，并且A元素在B元素前面，如果使用某种排序算法排序后，能够保 证A元素依然在B元素的前面，可以说这个该算法是稳定的。
常见排序算法的稳定性：
冒泡排序：
只有当arr[i]>arr[i+1]的时候，才会交换元素的位置，而相等的时候并不交换位置，所以冒泡排序是一种稳定排序算法。
选择排序:
选择排序是给每个位置选择当前元素最小的,例如有数据{5(1)，8 ，5(2)， 2， 9 },第一遍选择到的最小元素为2， 所以5(1)会和2进行交换位置，此时5(1)到了5(2)后面，破坏了稳定性，所以选择排序是一种不稳定的排序算法。
插入排序：
比较是从有序序列的末尾开始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其 后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的，那么把要插入的元素放在相等 元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。
希尔排序：
希尔排序是按照不同步长对元素进行插入排序 ,虽然一次插入排序是稳定的，不会改变相同元素的相对序，但在 不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以希尔排序是不 稳定的。
归并排序：
归并排序在归并的过程中，只有arr[i]<arr[i+1]的时候才会交换位置，如果两个元素相等则不会交换位置，所以它 并不会破坏稳定性，归并排序是稳定的。
快速排序：
快速排序需要一个基准值，在基准值的右侧找一个比基准值小的元素，在基准值的左侧找一个比基准值大的元素， 然后交换这两个元素，此时会破坏稳定性，所以快速排序是一种不稳定的算法