1-算法与数据结构(Algorithm and Data Structure )

##1-算法与数据结构(Algorithm and Data Structure )
在任何语言的程序中：算法与数据结构不能完全分开，Algorithm + Data Structure=program(程序)研究算法并
不能记住所有的算法，在学习的过程中把一些总结出来的算法进行分析理解，最后在我们自己的大脑中形成一种解决问题
的中将从简单到复杂逐渐深入；
线性算法-----》树------》图论

---

本周第一节记录线性算法【O(n^2)】:并不是越复杂的算法就越通用，我们在解决实际问题时，需要根据实际问题取舍；
这些算法是基础：
   --编码简单，易于实现，是一些简单情景的首选
   --在一些特殊情况下，简单的排序算法更有效
   --简单的排序算法思想衍生出复杂的排序算法
   --作为子过程，改进更复杂的排序算法

---

---

1、 选择排序
选择排序算法思想非常简单，遍历每一个值，遍历到某个值是查看他后面的所有值，记录最小（大）值的位置最后交换，遍历完成排序也就完成了

    //排序算法
    public static void sort(Comparable [] arr){
        for(int i=0;i0){
                    minIndex=j;
                }
            }
            SelectionSortHelp.swap(arr,i,minIndex);
        }
//        SelectionSortHelp.printArray(arr);
    }
    
    //SelectionSortHelp的swap就是一个交换值的过程
     //交换值
    public static void swap(Object [] arr,int i,int minIndex){
        Object o=arr[i];
        arr[i]=arr[minIndex];
        arr[minIndex]=o;
    }

2、 插入排序：每次插入都会交换，优化与选择排序类似将位置记录，最后将值插入
插入排序有多中写法，但是都大同小异，思想是一样的，都是遍历数组，将此时的值与前面的值比较，直到找到这个值在前面内容中该放入的位置为止

public static void sort(Comparable[] arr){
        for(int i=1;i0 && arr[j].compareTo(arr[j-1])<0;j--){
//                SelectionSortHelp.swap(arr,j,j-1);
//            }

            //第二种写法:  ---十万数据50s
            //            ---同样数据选择排序59s
//            for(int j=i;j>0;j--){
//                if(arr[j].compareTo(arr[j-1])<0){
//                    SelectionSortHelp.swap(arr,j,j-1);
//                }else{
//                    break;//跳出循环，不再往前再比较
//                }
//            }

//第三种写法：上面两种方法内部每比较一次就交换；
//效率改进---十万个学生排序12s (略有改进) 100万数据1366s
//---同样数据选择排序45s          100万数据 10179s
            Comparable arrI=arr[i];//记录最后此时i位置的值放入的位置
            for(int j=i;j>0;j--){
                if(arrI.compareTo(arr[j-1])<0){
                    arr[j]=arr[j-1];
                }else{
                    arr[j]=arrI;
                    break;
                }
            }
        }
    }

3、 冒泡排序
SelectionSortHelp.swap方法同样是一个交换方法

//冒泡排序
    public static void sort(Comparable [] arr){
        int n=arr.length;
        Boolean cycle=true;
        while (cycle){
            cycle=false;//默认进来后就不再继续循环
            for(int i=1;i0){
                    SelectionSortHelp.swap(arr,i-1,i);
                    cycle=true;//如果此次遍历中有值交换则说明应该继续循环下次遍历；
                }
            }
            n--;
        }
    }

4、shell排序:
其实shell排序时间复杂度是比较难计算的，这是刘宇波老师的写法（是O(n^3/2)级别的算法）：GitHub网址-https://github.com/liuyubobobo/Play-with-Algorithms/tree/master/02-Sorting-Basic/Course Code (Java)/Optional-02-Shell-Sort/src/bobo/algo

public static void sort(Comparable[] arr){

        int n = arr.length;//10

        // 计算 increment sequence: 1, 4, 13, 40, 121, 364, 1093...
        int h = 1;
        while (h < n/3) h = 3*h + 1;//h=1  h=4

        while (h >= 1) {
            // h-sort the array
            for (int i = h; i < n; i++) {
                // 对 arr[i], arr[i-h], arr[i-2*h], arr[i-3*h]... 使用插入排序
                Comparable e = arr[i];
                int j = i;
                for ( ; j >= h && e.compareTo(arr[j-h]) < 0 ; j -= h)
                    arr[j] = arr[j-h];
                arr[j] = e;
            }
            h /= 3;
        }
    }

---

不喜勿喷，侵权请至邮：[email protected]
请多指教—待续。。。

---