写了这么多年程序，来看看这些最基础的算法你会不会写...

串的朴素模式匹配算法，串的kmp模式匹配算法

• 串是由零个或多个字符组成的有序列，又名叫字符串
• 子串的定位操作：简单地说，就是对主串的每一个字符作为字串的头，与要匹配的字符串进行匹配
• 串的朴素模式匹配算法：对主串做大循环，每个字符开头做T的长度的小循环，直到匹配成功或全部遍历完成为止
• 串的kmp模式匹配算法：在朴素的模式匹配算法中，主串的i值是不断地回溯来完成的，KMP算法就是为了让没必要的回溯不发生

选择排序，冒泡排序

• 冒泡排序

void bubbleSort(int[] datas){
    for(int i=0;i<datas.length;i++){
        for(int j=0;j<datas.length;j++){
            if(datas[i]>datas[j]){
                int temp=datas[i];
                datas[i]=data[j];
                data[j]=temp;
            }
        }
    }
}

• 选择排序

    public static void selectionSort(int[] arr]){
        int min;
        int max;
        int count=arr.length;
        for(int i=0;i<count;i++){
             // 初始化未排序序列中最小数据数组下标
            min=i;
              // 初始化未排序序列中最大数据数组下标
            max=count-1;
            for(int j=i;j<count;j++){
                  // 在未排序元素中继续寻找最小元素，并保存其下标
                if(arr[min]>arr[j]]){
                    min=j;
                }
                 // 在未排序元素中继续寻找最大元素，并保存其下标
                if(arr[max]<=arr[j]){
                    max=j;
                }
            }
             // 将未排序列中最小元素放到已排序列头
            if(min!=i){
                  int temp = arr[i];
                  arr[i] = arr[min];
                  arr[min] = temp;
            }
              // 将未排序列中最大元素放到已排序列尾
                if(max != count - 1){
                    int temp = arr[count - 1];
                    arr[count - 1] = arr[max];
                    arr[max] = temp;
                }
                count--;
        }
    }

链表反转

• 遍历法

    Node reversal(Node node){
        Node Last;
        Node next;
        while(node!=null){
            next=node.next;
            node.next=last;
            last=node;
           node=next;
        }
    }

• 递归法

Node reserval(Node node){
        if(node==null||node.next==null){
            return node;
        }
        Node temp=node.next;
        Node newNode=reserval(node.next);
        temp.next=node;
        head.next=null;
        return newNode;
    }

裴波拉契数列：从第三项开始，每一项都是前面两项之和。

 int pblq(int n){
         if(n==1||n==2){
             return 1;
         }
         return pblq(n-2)+pblq(n-1);
     }

链表反转，冒泡排序，裴波拉契数列在面试的写手代码环节基本上是必考的，时光飞驰，转眼已经在开发这条路上走了五个年头，回想自己这一路，虚度了大好的光阴，本该具备技术沉淀的年纪，这个年纪除了留下了厚厚的脂肪，什么也没有沉淀下，在互联网这种风气下，使自己变的更加的茫然。如果看到这篇博客的你也和我一样茫然，就和我一起加油学习吧，未来的成长之路我与你一起同行。加油！