算法【1】

1.相关名词概念

时间复杂度：是指执行算法需要的计算工作量。（语句执行次数）

空间复杂度：是指执行算法需要的内存空间。（存储空间）

2.计算方式

时间复杂度的计算方式：

空间复杂度的计算方式：

3.算法的分类

比较排序：冒泡排序，选择排序，插入排序，归并排序，堆排序，快速排序等

非比较排序：计数排序，基数排序，桶排序等

4.算法的详细解释

4.1选择排序

选择排序每次比较的是数组中特定索引的值与全数组中每个值的大小比较，每次都选出一个最小(最大)值，如果当前索引的值大于之后索引的值，则两者进行交换

public class select {
    public static void main(String[] args) {
        Integer[] arr = {1, 4, 5, 2, 3, 9, 0, 7, 6};
        Integer temp;
        for (int i = 0; i < arr.length; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                    for (int a:arr){
                        System.out.print(a);
                    }
                    System.out.println();
                }
            }

        }
    }
}

输出结果：

045239176
025439176
015439276
014539276
013549276
012549376
012459376
012359476
012349576
012345976
012345796
012345697
012345679

4.2 冒泡排序

冒泡排序每次从数组的最开始索引处与后一个值进行比较，如果当前值比较大，则交换位置。这样一次循环下来，最大的值就会排入到最后的位置。

 Integer[] arr = {1, 4, 5, 2, 3, 9, 0, 7, 6};
        int t;

        for (int m = 0; m < arr.length; m++) {
            for (int n = 0; n < arr.length - m; n++) {
                if (arr[n] > arr[n + 1]) {
                    t = arr[n + 1];
                    arr[n + 1] = arr[n];
                    arr[n] = t;
                    for (int a:arr){
                        System.out.print(a);
                    }
                    System.out.println();
                }
            }
        }

小总结：选择排序和冒泡排序 在初次了解时会感觉两个算法差不多。那我就在这里 比较一下两个算法的异同。也可以帮助我对这两个算法有更深的理解。

首先，既然是排序算法。那最后一定是最大的在一端，其次的位置的次于最大的，以此类推。那其实排序算法的中心就是找出元素中最大的（又或者是最小的）

排序算法是和相邻元素进行对比，判断大小，如果和想要的大小顺序不一致就和相邻元素互换。当此行一个一个的互换结束后，那此行的一端一定是你想要的最大或者最小的元素。

快速算法是直接找到此行最大（或者最小）的元素的下标，然后进行互换。

其实这样看来也不是明显的比较出来两次算法有什么区别。

但其实 差别在于执行的动作，比如 在java中 互换位置这一操作 执行动作的次数是3次。设置一个 temp，将temp = a ; a=b;b =  temp.这才完成了一次互换动作

举个小例子 ：1 2 3 要求从左向右依次减小的排列

冒泡排序的做法是：

1. 1 和 2 比较，互换位置 顺序换为 2 1 3  执行了3次动作
2. 1和3比较，互换位置 顺序换为 2 3 1     执行了3次动作
3. 2和3比较，互换位置 3 2 1                     执行了3次动作

快速排序的做法是：

1. 1和2比较，记录下 最大的数字下标是 2                                   执行了1次动作
2. 拿到下标为2的元素 和3比较 发现 最大的数字下标是3 　　    执行了1次动作
3. 将3 和1互换　　                                                                       执行了3次动作
4. 将2和1进行比较 得到结果

这就看出了两个算法的区别 ，快速算法对于 更大的元素执行的操作是记录，冒泡排序执行的操作是互换。这就是快速排序和冒泡排序最大的区别。且我们看出，快速排序更高效一些