算法

最近看了写文章,发现自己的算法了解的比较少,于是开始找教程开始彻底的学习一下算法<<韩顺平-图解java数据结构和算法>>。

1.算法的时间复杂度

1.1.时间频度:一个算法花费的时间与算法中语句执行次数成正比例,那个算法中语句执行次数多,它花费时间就多。一个算法的语句执行次数称为语句频度或者时间频度。记为T(n)

表达式有三个特点:忽略常数项,忽略低次项,忽略系数

1.2时间复杂度

   推算过程:a.一般情况下,算法中的基本操作语句的重复执行次数是问题规模n的某个函数,用T(n)表示,若有某个辅助函数f(n),使得当n趋近于无穷大的时候,T(n)/f(n)的极限值为不等于0的常数,则称f(n)是T(n)的同数量级函数。记做T(n)=O(f(n)),称O(f(n))为算法的渐进时间复杂度,简称时间读咋读。

   b.T(n)不同,但是时间复杂不到可能相同。如T(n)=n2+7n+6 与 T(n)=3n2+2n+2他们的T(n)不同,但是时间复杂度相同,都是O(n2)

   c.计算时间复杂度的方法:

   用常数1代替运行时间中的所有加法常数

   修改后的运行次数函数中,只保留最高阶项

     去除最高阶项的系数

  常见时间复杂度

   常数阶 O(1)

   对数阶 O(log2n)

   线性阶O(n)

     线性对数阶O(log2n)

     平方阶 O(n2)

     立方阶O(n3)

     k次方阶O(n^k)

   指数阶O(2^n)

 

 

 

排序算法:

1.冒泡排序 时间复杂度(O(n^2)):

  通过对待排序下序列从前往后(从下标娇小的元素开始),依次比较相邻元素的值,若发现逆序则交换,使值较大的元素逐渐从前移向后部,就像水底下的气泡一样逐渐往上冒。因为排序的过程中,各元素不断的接近自己的位置,如果一趟比较下来没有进行过交换,说明序列有序,因此要在排序过程中设置一个标志flag判断元素是否进行交换,从而减少不必要的比较。

 

 1 public class BubbleSort {
 2     public static void main(String[] args) {
 3         int[] arr = {9,-1,22,10,33,45};
 4         int temp = 0;
 5         for (int i = 0; i < arr.length - 1; i++) {
 6             boolean flag = true; // 优化标识,当一次循环时所有位置没有发生变化,则标识该序列已经时有序的,可以跳出循环
 7             for (int j = 0; j < arr.length-1-i; j++) {
 8                 if(arr[i]>arr[i+1]){
 9                     temp = arr[i+1];
10                     arr[i+1]=arr[i];
11                     arr[i]=temp;
12                     flag=false;
13                 }
14                 if(flag){
15                     break;
16                 }
17             }
18         }
19         System.out.println(Arrays.toString(arr));
20     }
21 }

 

2.选择排序 时间复杂度(O(n^2)):

  第一次从arr[0]-arr[n-1]中选择最小值,与arr[0]交换,第二次从arr[1]-arr[n-1]中选择最小值,与arr[1]进行交换,....总共通过n-1次没到一个排序从最小到最大的排序

 public static void selectSott(int[] arr) {
        int min = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            min = arr[i];
            int minIndex = i;
            for (int j = i; j < arr.length - 1; j++) {
                if (min > arr[j + 1]) {
                    min = arr[j+1];
                    minIndex=j+1;
                }
            }
            arr[minIndex]=arr[i];
            arr[i] = min;
        }
    }

3.插入排序

  插入式排序属于内部排序发,是对于欲排序的元素以插入的方式找寻该元素的适当位置,以达到排序的目的。把n个待排序的元素看成为一个有序表和一个无序表,开始时有序表中包含一个元素,无序表中包含n-1个元素,排序过程中每次从无序表中选取第一个元素,把它与有序表中的每个元素进行比较,将它插入到有序表中适当的位置,使之成为新的有序表

    public static void inertSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int insertIndex = i;
            int insertVal = arr[i + 1];
            while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
            if (insertIndex + 1 != i) {
                arr[insertIndex + 1] = insertVal;
            }
        }

    }

  

4.希尔算法

   在直接插入排序算法中,每次插入一个数,使有序序列只增加1个节点,并且对插入下一个数没有提供任何帮助。如果比较相隔较远距离(称为增量)的数,使得数移动时能跨过多个元素,则进行一次比较就可能消除多个元素交换。D.L.shell于1959年在以他名字命名的排序算法中实现了这一思想。算法先将要排序的一组数按某个增量d分成若干组,每组中记录的下标相差d.对每组中全部元素进行排序,然后再用一个较小的增量对它进行,在每组中再进行排序。当增量减到1时,整个要排序的数被分成一组,排序完成。下面的函数是一个希尔排序算法的一个实现,初次取序列的一半为增量,以后每次减半,直到增量为1。希尔排序是不稳定的。

// 希尔排序法一:交换法
   // 首先分为5组数据,每组2个数据 9,7 2,8 3,6 4,5 1,0 // 排序之后在分为2组, 每组5个数据 public static void shellSort(int[] arr) { int temp = 0; for (int i = arr.length / 2; i > 0; i = i / 2) { for (int j = i; j < arr.length; j++) { for (int k = j - i; k >= 0; k = k - i) { if (arr[k] > arr[k + i]) { temp = arr[k]; arr[k] = arr[k + i]; arr[k + i] = temp; } } } } }

// 希尔排序法二  移动插入(效率比一高)
public static void shellSort2(int[] arr) {
for (int i = arr.length / 2; i > 0; i = i / 2) {
for (int j = i; j < arr.length; j++) {
int index = j;
int indexValue = arr[index];
while (index - i >= 0 && indexValue < arr[index - i]) {
arr[index] = arr[index - i];
index = index - i;
}
arr[index] = indexValue;
}
}
}

 

5.快速排序

  是对冒泡排序的改进,通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后在按此方法分对两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。

 public static void quickSort(int[] arr, int left, int right) {
        int l = left;
        int r = right;
        int pivot = arr[(left + right) / 2];
        int temp = 0;
        while (l < r) {
            while (arr[l] < pivot) {
                l++;
            }
            while (arr[r] > pivot) {
                r--;
            }
            if (l >= r) {
                break;
            }
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;
            if (arr[l] == pivot) {
                r--;
            }
            if (arr[r] == pivot) {
                l++;
            }
        }
        if (l == r) {
            l++;
            r--;
        }
        if (left < r) {
            quickSort(arr, left, r);
        }
        if (right > l) {
            quickSort(arr, l, right);
        }
    }

  

6.归并排序

  是利用归并的思想实现排序方法,该算法采用经典的分治策略(将问题分成一些小的问题然后递归求解,而治的阶段则将分的阶段得到的各答案修补在一起,即分而治之)

public static void mergeSort(int arr[],int left,int right,int[] temp){
        if(left< right){
            int mid = (left + right) / 2;
            mergeSort(arr,left,mid,temp);
            mergeSort(arr,mid+1,right,temp);
            merge(arr,left,mid,right,temp);
        }
    }


    // 合并
    public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        int i = left; // 初始化i,左边有序序列的初始索引
        int j = mid + 1; // 初始化j,右边有序序列的初始索引
        int t = 0;//指向temp数组的当前索引

        while (i <= mid && j <= right) {
            if (arr[i] < arr[j]) {
                temp[t] = arr[i];
                t += 1;
                i += 1;
            } else {
                temp[t] = arr[j];
                t += 1;
                j += 1;
            }
        }
        while (i <= mid) {
            temp[t] = arr[i];
            t += 1;
            i += 1;
        }
        while (j <= right) {
            temp[t] = arr[j];
            j += 1;
            t += 1;
        }

        t=0;
        int tempLeft = left;
        while (tempLeft<=right){
            arr[tempLeft] = temp[t];
            t+=1;
            tempLeft+=1;
        }
    }

  

7.基数排序

  将所有待比较数值统一为同样的数位长度,数位较短的数前面补零。然后,从最低位开始,依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。 

 public static void radixSort(int[] arr) {
        //1. 得到数组中最大的数的位数
        int max = arr[0]; //假设第一数就是最大数
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        //得到最大数是几位数
        int maxLength = (max + "").length();
        //定义一个二维数组,表示 10 个桶, 每个桶就是一个一维数组
        //说明
        //1. 二维数组包含 10 个一维数组
        //2. 为了防止在放入数的时候,数据溢出,则每个一维数组(桶),大小定为 arr.length //3. 名明确,基数排序是使用空间换时间的经典算法
        int[][] bucket = new int[10][arr.length];
        //为了记录每个桶中,实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数 //可以这里理解
        //比如:bucketElementCounts[0] , 记录的就是 bucket[0] 桶的放入数据个数
        int[] bucketElementCounts = new int[10];
        //这里我们使用循环将代码处理
        for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
            //(针对每个元素的对应位进行排序处理), 第一次是个位,第二次是十位,第三次是百位..
            for (int j = 0; j < arr.length; j++) {
                //取出每个元素的对应位的值
                int digitOfElement = arr[j] / n % 10;
                //放入到对应的桶中
                bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
                bucketElementCounts[digitOfElement]++;
            } //按照这个桶的顺序(一维数组的下标依次取出数据,放入原来数组)
            int index = 0;
            //遍历每一桶,并将桶中是数据,放入到原数组
            for (int k = 0; k < bucketElementCounts.length; k++) {
                //如果桶中,有数据,我们才放入到原数组
                if (bucketElementCounts[k] != 0) {
                    //循环该桶即第 k 个桶(即第 k 个一维数组), 放入
                    for (int l = 0; l < bucketElementCounts[k]; l++) {
                        //取出元素放入到 arr
                        arr[index++] = bucket[k][l];
                    }
                }
                //第 i+1 轮处理后,需要将每个 bucketElementCounts[k] = 0 !!!!
                bucketElementCounts[k] = 0;
            }
        }
    }

 

常用算法比较:

  1. )  稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面;

  2. )  不稳定:如果a原本在b的前面,而a=b,排序之后a可能会出现在b的后面;

  3. )  内排序:所有排序操作都在内存中完成;

  4. )  外排序:由于数据太大,因此把数据放在磁盘中,而排序通过磁盘和内存的数据传输才能进行;

  5. )  时间复杂度:一个算法执行所耗费的时间。

  6. )  空间复杂度:运行完一个程序所需内存的大小。

  7. )  n: 数据规模

  8. )  k: “桶”的个数

  9. )  In-place: 不占用额外内存

  10. ) Out-place: 占用额外内存

posted @ 2019-10-22 10:42  喜中5000万  阅读(177)  评论(0编辑  收藏  举报