Java简单算法

一、数组的复制

public void copy(){
    int[] ints = new int[]{1,2,3,4,4,5};
    int[] i2 = new int[ints.length];
    //int[] i3 =ints; 赋值

    for(int i=0;i<i2.length;i++){
        i2[i]=ints[i];
        System.out.print(i2[i]+"\t");
    }
}

二、反转

public void reversal() {
    String[] s1 = new String[]{"A","A1","A2","A3","A4"};
    for(int i=0;i<s1.length/2;i++){
        String tmp =s1[i];
        s1[i] =s1[s1.length-i-1];
        s1[s1.length-i-1] =tmp;
    }
    for(int i=0;i<s1.length;i++){
        System.out.print(s1[i]+"\t");
    }

}

三、查找

    public void find(){
    int[] i1 = {-99, -78, 0, 1, 34, 45, 899};
    int a = 34;

    //线性查找
    for(int i=0;i<i1.length;i++){
        if(a == i1[i]){
            System.out.println("找到了，位置为"+i);
            break;
        }
    }

    //二分法查找
    int b = 34;
    int frist = 0;
    int last = i1.length - 1;

    while (frist <= last){
        int mid = (frist + last)/2 ;
        if(b == i1[mid]){
            System.out.println("找到了，位置为"+mid);
            break;
        } else if (b < i1[mid]){
            last = mid -1 ;
        }else {
            frist = mid + 1;
        }
    }
}

四、排序

4.1 十大内部排序算法
选择排序：直接选择排序、堆排序
交换排序： 冒泡排序、快速排序
插入排序：直接插入排序、折半插入排序、Shell排序
归并排序
桶式排序
基数排序

4.2 排序算法的选择
(1)若n较小(如n≤50)，可采用直接插入或直接选择排序。
当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插入，应选直接选择排序为宜。
(2)若文件初始状态基本有序(指正序)，则应选用直接插入、冒泡或随机的快速排序为宜；
(3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归并排序。

4.3 冒泡排序
基本思想：
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

public void BubbleSort() {   //冒泡排序
    int[] ints = {9, -16, 21, 23, -30, -49, 21, 30};
    for (int i = 0; i < ints.length - 1; i++) {
        for (int j = 0; j < ints.length - 1 - i; j++) {
            if (ints[j] > ints[j + 1]) {
                int tmp = ints[j];
                ints[j] = ints[j + 1];
                ints[j + 1] = tmp;
            }
        }
    }
    for (int i = 0; i < ints.length; i++) {
        System.out.print(ints[i] + "\t");
    }
}

4.4 直接选择排序

public void SelectSort() {   //直接选择法
        int[] data = {9, -16, 21, 23, -30, -49, 21, 30};

        int arrayLength = data.length;
        for (int i = 0; i < arrayLength - 1; i++) {
            for (int j = i + 1; j < arrayLength; j++) {
                if (data[i] > data[j]) {
                    int temp = data[i];
                    data[i] = data[j];
                    data[j] = temp;
                }
            }

        }
        for (int i = 0; i < data.length; i++) {
            System.out.print(data[i] + "\t");
        }
    }

4.5 直接插入排序

五、递归

5.1 斐波拉契数列

//斐波那契数列
public int fb(int n){
    if(n==1 || n==2){
        return  1;
    }
 else  return fb(n-1)+fb(n-2);
}

5.2 阶乘

 // 阶乘
public int guess(int n) {
    if (n == 1) {
        return n; }
    else  return  n* guess(n-1);
}

六、字符串相关的类：String

6.1 对字符串中字符进行自然顺序排序
提示：1）字符串变成字符数组。2）对数组排序，选择，冒泡，Arrays.sort()。3）将排序后的数组变成字符串。

public void test3() {
    String str = "abcwerthelloyuiodef";
    char[] arr = str.toCharArray();
    Arrays.sort(arr);
    String newStr = new String(arr);
    System.out.println(newStr);
}

6.2 将一个字符串进行反转。将字符串中指定部分进行反转
比如将“abcdefg”反转为”abfedcg”

public void str1() {
    //2.将一个字符串进行反转。将字符串中指定部分进行反转。比如将“abcdefg”反转为”abfedcg”
    //a b c d e f g
    //0 1 2 3 4 5 6
    String str = "abcdefg";
    int start = 2;
    int end = 5;

    //System.out.println(str.toCharArray());   //字符串转为新的字符数组
    char[] c = str.toCharArray();//字符串--->字符数组

    //System.out.println(str[0]);    //调用字符串的首字母
    for(int i = start,j = end;i < j;i++,j--){
        char temp = c[i];
        c[i] = c[j];
        c[j] = temp;
    }
    System.out.println(c);
    System.out.println(str.substring(0,2));
}

6.3 获取一个字符串在另一个字符串中出现的次数
比如：获取“ ab”在 “abkkcadkabkebfkabkskab” 中出现的次数

public void test1(){
    String str = "abkkcadkabkebfkabksk";
    String s = "ab";

    if (str.length() >= s.length()) {
            int count = 0;  //记数
            int index = 0;  //索引
             while((index = str.indexOf(s)) != -1){
             count++;
                 str = str.substring(index + s.length());
             }
            System.out.println(count);
        }

}

七、设计模式

//1. 单例设计模式_饿汉式
class Singleton {
    // 1.私有化构造器
    private Singleton() {
    }
    // 2.内部提供一个当前类的实例
    // 4.此实例也必须静态化
    private static Singleton single = new Singleton();
    // 3.提供公共的静态的方法，返回当前类的对象
    public static Singleton getInstance() {
        return single;
    }
}

//2. 单例设计模式_懒汉式
class Singleton2 {
    // 1.私有化构造器
    private Singleton2() {
    }
    // 2.内部提供一个当前类的实例
    // 4.此实例也必须静态化
    private static Singleton2 single;
    // 3.提供公共的静态的方法，返回当前类的对象
    public static Singleton2 getInstance() {
        if(single == null) {
            single = new Singleton2();
        }
        return single;
    }
}