java中几种基本算法思想

1、累加算法

方法一：

int num = 1;//记录每次参与运算的变量
int sum = 0;//记录每次加完的和
while (num <= 100){
    sum = sum + num;
    num++;
}
System.out.print(sum);

方法二：
int sum = 0;
for (int i = 0; i <101 ; i++) {
    sum = sum +i;
}
System.out.println(sum);
两种写法的特点：
for和while的特点：
1、for和while可以互换
2、格式上的不同，在使用上有一点小区别 
    如果 需要通过 变量来对循环进行控制 ，该变量只作为循环增量存在时，区别 就体现出来 了
    for循环完后，变量就会被内存释放 ，while不会被释放 ，循环完后还可以对变量进行操作。

2.    计数器思想

int x = 1;//记录每次参与运算的变量
int count = 0;//记录每次加完的次数
while (x < 100) {
    if (x % 3 == 0) {
        count++;
    }
    x++;
}
System.out.print(count);

3、双层for循环思想 
     
    for(int i = 0,i<3,i++){//外循环控制行数，
       
        for(int j = 0,j<4,j++){//内循环控制每 一行的个数（列数）

        }
     }

\n:回车
\t:制表符
\b:退格
\r:按下回车键
windows系统 中回车符其实是由两个符号组成 的\r\n
linux中回车符是\n 

4、获取最大值
//获取最大值  方法一
public static int getMax(int[] arr) {
    int maxElement = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] > maxElement) {
            maxElement = arr[i];
        }
    }
    return maxElement;
}
//获取最大值  方法二
public static int getMax_2(int[] arr) {

    int maxIndex = 0;
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] > arr[maxIndex]) {
            maxIndex = i;
        }
    }
    return arr[maxIndex];
}

5、选择排序

 //选择排序一
    public static void selectSrot(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                swap(arr, i, j);//与下边这个是一样的方法
//                if (arr[i] > arr[j]) {
//                    int temp = arr[i];
//                    arr[i] = arr[j];
//                    arr[j] = temp;
//                }
            }
        }
    }

/**
     * 选择排序方法二，提高了效率
     *
     * @param arr 思路，每次比较时，用一个变量来记录它的最小值 ，
     *            用另一个变量来记录它的最小值 的下标，
     *            当比完后，把最小值 的下标赋值给数组 的0角标元素，
     *            这样比较完再进行赋值
     *            这样提高了代码的换位次数，提高效率
     */
    public static void selectSrot_2(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {

            int num = arr[i];//用于记录最小值
            int index = i;  //用于记录最小值 的索引
            for (int j = i + 1; j < arr.length; j++) {
                if (num > arr[j]) {
                    num = arr[j];
                    index = j;
                }
            }
            if (index != i) {
//                swap(arr, i, index);
                if (arr[i] > arr[index]) {
                    int temp = arr[i];
                    arr[i] = arr[index];
                    arr[index] = temp;
                }
            }
        }
    }

//冒泡排序
/*
* 内循环
*  -1  为了避免下标越界
*  -i   为了让外循环增加一次，内循环参数与比较的元素个数递减
* */
public static void BubbleSrot(int[] arr) {
   
//方法一
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {

//               swap(arr,j,j+1);
                if (arr[j] > arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }

        //方法二
//        for (int i = arr.length - 1; i > 0; i--) {
//            for (int j = 0; j < i; j++) {
//
//                swap(arr, j, j + 1);
//                if (arr[j] > arr[j+1]) {
//                    int temp = arr[j];
//                    arr[j] = arr[j+1];
//                    arr[j+1] = temp;
//                }
//            }
//        }
}
    
//方法提取，封装
//交换位置
public static void swap(int[] arr, int a, int b) {
    if (arr[a] > arr[b]) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}