图解算法笔记整理

图解算法整理（1）

第一章 算法简介

1.第一种查找算法 二分查找法

二分查找法适用的数组必须是递增的

设置参数：low初始值为0 、high初始值为数组长度减1

判断查询数值item与数组第mid位数字的大小

(Python中’/‘表示浮点数除法，’//'表示整数除法)

Python代码如下

def bSearch(list,item):
    low = 0
    high = len(list) - 1
    while low <= high:
        mid = (low + high) // 2
        gusse = list[mid]
        if item < gusse:
            high = mid
        elif item > gusse:
            low = mid
        elif item == gusse:
            return mid
        else:
            return None

Java代码如下：

public class BinarySearch {
    public static int binarySearch(int[] arr, int item){
        if(arr == null || arr.length == 0 ){
            return -1;
        }
        int low = 0;
        int high = arr.length - 1;
        while(low <= high){
            int mid = (low+high)/2;
            if(item < arr[mid]){
                high = mid;
            }else if(item > arr[mid]){
                low = mid;
            }else if(item == arr[mid]){
                return mid;
            }
        }
        return -1;
    }
}

2.大O表示法

不同的算法随着数据量的增加，算法的运行时间会有不同的增加速度，可以用大O表示法来描述算法运行的有多快。

一些常用的大O运行时间：

​ $O(logn)$ 、$O(n)$、$O(n\ast logn)$、$O(n^2)$、$O(n!)$

随着运行时间变化效率的变化图：

• 算法的速度指的并非是时间，而是操作数的增速
• 谈论算法的速度时，我们说的是随着输入的增加，其运行时间将以什么样的速度增加
• 算法运行的时间可以用大$O$表示法进行表示
• $O(logn)$比$O(n)$快，当需要搜索的元素越多是，前者比后者快的越多。

说明：大$O$表达式表示的是最糟糕的情况，但是除了最糟糕的情况时间外，还需要考虑平均时间情况，也很重要。

小结：

• 二分查找的速度($O(logn)$)比简单查找($O(n)$)要快很多
• $O(logn)$比($O(n)$快意味着，所需要搜索的元素越多，前者比后者快的就越多
• 算法运行时间不是以秒为单位
• 算法运行时间是从其增速的角度衡量的
• 算法运行时间用大$O$表示表示

图解算法整理（2）

第二章 选择排序

1.数组和链表

数组在内存中占用的是一段连续的空间。

链表在内存中的空间可以是不连续的，前一个元素中存储了后一个元素的地址。

数组有索引支持随机访问，链表只支持顺序访问

2. 选择排序

对一个数组A进行大小排序（以降序为例），先检查数组A，取出数组A中最大的元素放入数组B中，再对A进行检查，取出此时最大的元素放入数组B中，继续循环，知道A为空，循环结束，得到的数组B 就是降序数组。

因为每次取A中最大的元素需要对数组n个元素进行检查，并且循环n次，所以选择排序时间复杂度为$O(n^2)$ 。

java代码如下：

public class SelectionSort {
    public static int [] selectionSort(int [] arr){
        if(arr.length == 0 || arr == null){
            return null;
        }
        int[] narr = new int[arr.length];
        for(int i = 0 ; i < arr.length;i++){
            narr[i] = arr[findMax(arr)];
            arr[findMax(arr)] = 0;
        }
        return narr;
    }
    public static int findMax(int [] arr){
        int max = arr[0];
        int max_index = 0;
        for(int i = 0 ; i < arr.length ; i++){
            if(arr[i] > max){
                max = arr[i];
                max_index = i;
            }
        }
        return max_index;
    }
}

Python代码如下：

def selectionSearch(list):
    nlist = []
    for i in range(0,len(list)):
        max_index = findmax(list)
        nlist.append(list.pop(max_index))
    for i in nlist:
        print(i)
    return nlist

def findmax(list):
    if not list:
        return
    max = list[0]
    max_index = 0
    for i in range(0,len(list)):
        if list[i] > max:
            max = list[i]
            max_index = i
    return  max_index

小结：

• 计算机内存犹如一堆大抽屉
• 需要存储多个元素时，可以使用数组或链表
• 链表的元素是分开的，其中每个元素都存储了下一个元素的地址
• 数组的读取速度很快
• 链表的插入和删除速度很快
• 在同一个数组中，所有元素的类型都必须相同