常用的Java算法

个人总结的一些算法：冒泡算法，排序算法，数组反转算法，String反转算法

String str=”a'b'ca “; //创建一个字符串变量str
char[] c; //创建一个字符数组c
c = str.toCharArray(); //将字符串变量转换为字符数组
str= String.valueOf(c ); //将字符数组转换为字符串

/**
 * ClassName: Algorithm
 * Description:
 * date: 2021/8/17 12:44
 *
 * @author zwt
 * @since JDK 1.8
 */
public class Algorithm {
    public static void main(String[] args) {
        Algorithm algorithm =new Algorithm();
        int[] arry ={5,1,7,10,8,3,100,50,11};
        for(int a :algorithm.order2(arry))
            System.out.print(a+"-");
//        algorithm.reverse();
//        algorithm.reverses("asdsajfadhfkdahfkahfhn");
    }

    /**
     * 冒泡算法，把下面的值按照大小排序  int[] arry ={5,1,7,10,8,3};
     * 原理：用前面的数字和后面的数字进行比较，当前面的值大于后面的值的时候，两个互换位置，直到遇到比他大的值的时候就停下来
     * 第一趟排序
     *      第一次排序：1和5比较，1<5,不用换位置，最后结果：{1,5,7,10,8,3};
     *      第二次排序：5和7比较，5<7,不用换位置，最后结果：{1,5,7,10,8,3};
     *      第三次排序：7和10比较，7<10,不用换位置，最后结果：{1,5,7,10,8,3};
     *      第四次排序：10和8比较，10>8,用换位置，最后结果：{1,5,7,8,10,3};
     *      第五次排序：10和3比较，10>3,用换位置，最后结果：{1,5,7,8,3,10};
     * 第二趟排序
     *       第一次排序：1和5比较，1<5,不用换位置，最后结果：{1,5,7,8,3,10};
     *       第二次排序：5和7比较，5<7,不用换位置，最后结果：{1,5,7,8,3,10};
     *       第三次排序：7和8比较，7<8,不用换位置，最后结果：{1,5,7,8,3,10};
     *       第四次排序：8和3比较，8>3,用换位置，最后结果：{1,5,7,3,8,10};
     * ......
     * 第n趟排序
     *       第一次排序：1和3比较，1<3,不用换位置，最后结果：{1,5,7,10,8,3};
     *
     * @param arry
     * @return
     */
    public int[] order1(int[] arry) {
        int a = 0;
        for (int i = 0; i < arry.length - 1; i++) {
            for (int j = 0; j < arry.length - i - 1; j++) {
                if (arry[j+1] < arry[j]) {
                    a = arry[j];
                    arry[j] = arry[j+1];
                    arry[j+1] = a;
                }
            }
        }
        return arry;
    }

    /**
     * 选择排序算法
     * int[] arry ={5,2,8,4,9,1};
     * 第一趟排序： 原始数据：5  2  8  4  9  1
     * 最小数据1，把1放在首位，也就是1和5互换位置，
     * 排序结果：1  2  8  4  9  5
     * 第二趟排序：
     * 第1以外的数据{2  8  4  9  5}进行比较，2最小，
     * 排序结果：1  2  8  4  9  5
     * 第三趟排序：
     * 除1、2以外的数据{8  4  9  5}进行比较，4最小，8和4交换
     * 排序结果：1  2  4  8  9  5
     * 第四趟排序：
     * 除第1、2、4以外的其他数据{8  9  5}进行比较，5最小，8和5交换
     * 排序结果：1  2  4  5  9  8
     * 第五趟排序：
     * 除第1、2、4、5以外的其他数据{9  8}进行比较，8最小，8和9交换
     * 排序结果：1  2  4  5  8  9
     * 由此可以看出，N个数据，要进行N-1趟排序，把0索引的元素，和索引1以后的元素都进行比较，第一次完毕，最小值出现在了0索引。同理，其他的元素就可以排好。
     * 外层控制总共要排序的趟数，内层表示要和下标为X的数据比较数组值
     * @return
     */
    public int[] order2(int[] arry){
        for (int i = 0; i <arry.length-1 ; i++) {
            for (int j = i+1; j < arry.length; j++) {

                if(arry[i]> arry[j]){
                    int a =arry[j];
                    arry[j]=arry[i];
                    arry[i]=a;
                }
            }

        }
        return arry ;
    }

    /**
     * 反转算法：将最后一个数和第一个数的值进行交换
     * @return
     */
    public int[] reverse(){
        int[] array ={1,5,7,10,8,3};
        for (int i = 0, j=array.length-1, k=0; i < j ;i++,j--) {
            k =  array[i];
            array[i] = array[j];
            array[j] = k;


        }
        for (int b:array)
            System.out.println(b);
        return array;

    }

    /**
     *字符串的反转算法
     * @return
     */
    public String reverses(String str){
        if(str==null){
            return "参数为空值";
        }else {
            char[] chars = str.toCharArray() ;
            char a='中';
            for (int i = 0,j=str.length()-1; i < j; j--,i++) {
                a=chars[j];
                chars[j] = chars[i];
                chars[i]=a;
            }
            str=String.valueOf(chars);
            System.out.println(str);
            return str;
        }
    }


}