经典算法总结

最经典的算法莫过于选择排序和冒泡排序：

在总结之前先看了如下一篇博客：

https://blog.csdn.net/chen13579867831/article/details/78790853

Java中的选择排序和冒泡排序思想及代码实现

博主对这两种排序方法，介绍得比较清楚，不过这里我扣扣其中的细节并加上我自己的一些理解。

• 选择排序（降序）：

   // i 控制排序次数，取值从0到array.length-2，最后一个元素不用取出
        for(int i = 0 ;i<array.length-1;i++) {  

        /* j 控制每次排序比较次数，每次比较从取出来要比较的值后面第一个元素
        开始，到该数组最后一个元素比较结束，所以每次比较j从i+1开始，到
        array.length-1结束*/

            for(int j = i+1;j<array.length;j++) { 
                if(array[i]<array[j]) {
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                    count++;
                }
            }
        }
        System.out.println(Arrays.toString(array));

• 冒泡排序（降序）：

public class BubbleSort {
    public static void main(String[] args){
        //初始化一个数组
        int[] arr = {1,23,4,6,43};

        //外层for循环代表排序次数，数组长度为arr.length-1，共比较arr.length-2次；
        for(int i = 0;i<arr.length-1;i++) {

            //内层for循环代表每次排序比较的次数，每次都是从0索引开始比较；
            //第一次从0比到arr.length-1,比较arr.length-2-0次;
            //第二次从0到arr.length-2，比较arr.length-2-1次;
            //......
            for(int j = 0;j<arr.length-1-i;j++) {
                if(arr[j]<arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

选择排序和冒泡排序小结：
选择排序是把每次比出来的结果往前放，确定前面并在下轮循环中丢弃不参与；冒泡排序是把每次比出来的结果往后放，确定后面并在下轮循环中丢弃不参与。 
关于这两把排序方法，最主要的是掌握其思想，具体推理过程无须掌握，知道如何使用即可。

PS.

再研究一下，快速排序和插入排序。

https://blog.csdn.net/zyj0813/article/details/78296758

JAVA中常见的四种排序--冒泡排序、选择排序、插入排序和快速排序 详解

•  插入式排序--插入排序法

插入排序法（Insertion sort）的基本思想：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每一次从无序表中取出第一个元素，把它的排序码依次与有序表的排序码进行比较，将它插入到有序表的适当位置，使之成为新的有序表。

java实现插入排序法：

package com.insertion;
public class Demo1 {
public static void main(String[] args) {
int[] arr={9,8,7,6,5,4,3,2,1};
InsertSort ins=new InsertSort();
ins.sort(arr);
//打印结果
for(int i=0;i<arr.length;i++)
{
System.out.print(arr[i]+" ");
}
}
}
//定义一个类
class InsertSort{
public void sort(int[] arr)
{
for(int i=1;i<arr.length;i++)
{
int insertVal=arr[i];  //定义要插入的数
int index=i-1;        //定义插入数的前一个位置的脚标
while(index>=0&&insertVal<arr[index])
{
arr[index+1]=arr[index];       //将插入数的前一个数向后移一位
index--; 
}
arr[index+1]=insertVal;//不满足条件时插入数在原位不变
}
}
}

• 交换式排序法--快速排序法

基本思想：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

JAVA代码如下：

package com.insertion;
public class FastSort {
 
 
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] array={9,8,7,6,5,4,32,1,0};
QuickSort qs=new QuickSort();
qs.sort(0, array.length-1, array);
for(int i=0;i<array.length;i++)
{
System.out.print(array[i]+" ");
}
}
}
class QuickSort
{
public void sort(int left,int right,int[] array){
 
int l=left; //定义最左边的位置
int r=right; //定义最右边的位置
int pivot =array[(left+right)/2];   //找到最中间的数，作为比较数
int temp=0;
while(l<r){
while(array[l]<pivot) l++;
while(array[r]>pivot) r--;
 
if(l>=r) break;
temp=array[l];
array[l]=array[r];
array[r]=temp;
if(array[l]==pivot) --r;
if(array[r]==pivot) ++l;
}
 
if(l==r){
l++;
r--;
}
if(left<r) sort(left,r,array);//进行递归
if(right>l) sort(l,right,array);
}
}

有兴趣的，可以看一下希尔排序

https://www.cnblogs.com/chengxiao/p/6104371.html