2020-08-23

算法笔记（一）

排序算法

1.插入排序算法

平均时间复杂度O(N²)，与普通排序算的时间复杂度相同
通过交换相邻元素进行排序的任何算法的时间复杂度均为O(N²)

/*
*@author smallbaiprogramer
* algorithm study
* insert algorithm
* 算法相当于两边遍历，第一遍控制排序数组的元素数量，一开始只有一个然后依次往有序的数组里添加元素
* 注意比较时，数组要在后面进行比较要不然存放元素会和取出元素冲突
 */

public class insertSort {
    public static void algorithon(int[] Array){
        int j;
        for (int i = 1 ; i < Array.length ; i++ ){ // 数组初始放进一个数组，然后依次往里面添加元素
            int temp=Array[i]; //将下一个要添加进去的元素保存起来
            for ( j = i ;j>0 && temp<Array[j-1] ; j--){ // 将要添加的元素与之前已经添加进去的元素进行比较
                Array[j]=Array[j-1]; // 将新元素要存放的位置的所有数组向前挪一位，因为是在后面进行遍历的
            }
            Array[j] = temp; // 将新的元素放到数组里合适的位置
        }
    }
    public static void main(String[] args){
        int[] Arrays=new int[]{3,6,5,9,8,7,1,2,4,0};
        System.out.println(java.util.Arrays.toString(Arrays));
        algorithon(Arrays);
        System.out.println(java.util.Arrays.toString(Arrays));
    }
}

2.希尔排序算法

package sortAlgorithm;
/* @anthor smallbaiprogramer
*shellinsert 算法
* 该算法看似用了三次循环，其实时间复杂度是亚二次时间，时间复杂度在NlogN到N的平方之间
* 该算法在某些程度上与插入排序算法有些接近，都是利用交换元素来达到对数组进行排序的目的
* 不同之处，他们操作元素数，冒泡算法进行了很多重复的操作
* 而希尔算法改变了操作顺序，进而减少了操作的次数，从而得到了与冒泡排序算法的相比的更优的希尔排序算法
 */
public class shellSort {
    public static void algorithm(int[] Arrays){
    int j;
    for (int gap = Arrays.length/2 ;gap > 0; gap/=2){ // 给出元素比较的间距gap，不断减小，等于1的时候，与插入排序完全相同
        for (int i = gap ; i <Arrays.length ; i++){ // 对数组进行操作，比较的元素间隔为gap，
            int temp=Arrays[i];
            for (j = i ; j >= gap && temp < Arrays[j-gap] ; j-=gap) // 右边数组与左半块数组对应的元素比较，将元素值大的元素按距离右移
                Arrays[j]=Arrays[j-gap];
            Arrays[j] = temp; // 随着比较的间距越来越小， 该数组的元素值 最终完成排序
        }
    } // 该算法时间复杂度计算十分困难
        //最坏的情形 时间复杂度为O(N的平方)
    }
}

在希尔排序序列中，最重要的gap，这个增量序列，如果这个序列取的好，时间复杂度可以降低很多，在这个实例中，这个序列取的是 不断 除以2 ，若是利用更好的增量序列，时间复杂度可能会变得更好，只要增量序列的h1=1，最后当gap取一的时候，相当于重新进行了依次插入排序。

3.堆排序

堆排序是利用优先队列，取出最小元素的时间复杂度为LogN的原理做出来的，所以需要对优先队列，也就是堆掌握很熟练，就能明白堆排列，堆排列的源码主要是优先队列的方法定义的源码，所以这里不多提了。

4.归并排序

归并排序与前几个排序不一样，归并排序是将多个有序数组，进行排列，不是对单一数组进行排列。该排列很容易，在链表中常用到，

package sortAlgorithm;
/*
* @author smallbaiprogramer
* 该算法比较容易理解，就是两个有序数组，放进一个新的数组里，这个新数组在两个数组中选择，那个小，选那个，然后数组依次相加
* 很容易理解
 */
import java.util.Arrays;
public class mergeSort {
    public static int[] mergeSort(int[] Arrays1,int[] Arrays2){
            int len = (Arrays1.length+Arrays2.length);
        int[] res=new int[len];
        int i=0,j=0;
        while( i+j<len){
            if (i >= Arrays1.length){
                res[i+j] = Arrays2[j];
                j++;
            }else if (j >= Arrays2.length ){
                res[i+j] = Arrays1[i];
                i++;
            }else if (Arrays1[i] <= Arrays2[j]  ){
                res[i+j] = Arrays1[i];
                i++;
            }else if (Arrays1[i] > Arrays2[j] ) {
                res[i+j] = Arrays2[j];
                j++;
            }
        }
        return res;
    }
    public static void main(String[] args){
        int[] Arrays1=new int[]{1,5,6,8,9,10};
        int[] Arrays2=new int[]{2,4,5,6,9};
        System.out.println(Arrays.toString(mergeSort(Arrays1,Arrays2)));

    }
}

5.快速排序

JDK中Arrays类用的排序方法就是快速排序，与堆排序相同，该方法时间复杂度同样是NlogN

package sortAlgorithm;
import java.util.ArrayList;
import java.util.List;
/*
*@ author smallbaiprogramer
 */
public class fastSort {
    public static void sort(List<Integer> list){
        if (list.size() > 1){ // 判断数组中是否存在元素
            List<Integer> smaller = new ArrayList<>(); // 将数组分层，分为大 中 小 三个
            List<Integer> same = new ArrayList<>();
            List<Integer> larger = new ArrayList<>();
            Integer chosenItem = list.get(list.size()/2); // 获取中间的那个值，依次为分界点 对数组进行划分
            for (int i : list){
                if (i < chosenItem )
                    smaller.add(i);
                else if (i > chosenItem)
                    larger.add(i);
                else
                    same.add(i);
            }
            sort(smaller); // 对大数部分和小数部分就开始进行递归
            sort(larger); // same数组里面元素都是与分界点的数是相同的，所以不用划分
            list.clear(); // 分完之后清空原数组里的元素
            list.addAll(smaller);
            list.addAll(same);
            list.addAll(larger); // 将拍好的数组依次放进原数组中 就得到排序之后的数组
        }
    }
}