Java简单算法（数组）

 找出数组中的最大值

//找出数组中的最大值
    static void getMax() {
        int a[] = {15, 35, 18, 87, 48, 6, 84, 57, 98};
        int max = a[0];
        for (int i = 1; i < a.length; i++) {
            if (max < a[i]) {
                max = a[i];
            }
        }
        System.out.println(max);
    }

 算出数组中数据的平均值

//算出数组中数据的平均值
    static void getArray() {
        int b[] = {15, 35, 18, 87, 48, 6, 84, 57, 98};
        int sum = b[0];
        int array;
        for (int j = 1; j < b.length; j++) {
            sum = sum + b[j];
        }
        array = sum / b.length;
        System.out.println(array);
    }

 把数组倒序并遍历

//把数组倒序并遍历
    static void getSunxu() {
        int c[] = {15, 35, 18, 87, 48, 6, 84, 57, 98};
        int d[] = new int[c.length];
        for (int i = 0; i < c.length; i++) {
            d[c.length - 1 - i] = c[i];
        }
        for (int j : d
        ) {
            System.out.println(j);
        }
    }

 拷贝数组

//拷贝数组
    static void arrayCopy() {
        int a[] = {1, 2, 3, 4, 5};
        int b[] = {6, 7, 8, 9, 10};
        System.arraycopy(a, 1, b, 2, 3);//拷贝哪个数组，从第几个开始，拷到哪个数组，从第几个开始
        for (int i : b
        ) {
            System.out.println(i);
        }
    }

 搜索key在数组的哪个位置

//搜索key在数组的哪个位置
    static void Search() {
        int a[] = {6, 5, 4, 3, 2, 1};
        int key = 1;
        Arrays.sort(a);
        System.out.println(Arrays.binarySearch(a, key));
    }

 二分查找

//二分查找
    static int erfen(int key) {
        int[] a = {9, 8, 7, 6, 5, 4, 3, 2, 1};
        int lo = 0;
        int hi = a.length - 1;
        Arrays.sort(a);//1,2,3,4,5,6,7,8,9
        while (lo <= hi) {
            int mid = (hi + lo) / 2;
            if (key < a[mid]) {
                hi = mid - 1;
            } else if (key > a[mid]) {
                lo = mid + 1;
            } else {
                return mid;
            }
        }
        return -1;
    }

 遍历二维数组

//遍历二维数组
    static void Test() {
        int[][] a = {{1, 2, 3, 4, 5}, {6, 7, 8}};
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.print(a[i][j]);
            }
        }
        System.out.println();
        for (int[] i : a) {
            for (int j : i) {
                System.out.print(j);
            }
        }
    }

 遍历三维数组

//遍历三维数组
    static void go() {
        int[][][] a = {{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}}};
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                for (int k = 0; k < a[i][j].length; k++) {
                    System.out.print(a[i][j][k]);
                }
            }
        }
        System.out.println();
        for (int i[][] : a
        ) {
            for (int j[] : i
            ) {
                for (int k : j
                ) {
                    System.out.print(k);
                }
            }
        }
    }
}

 判断是否为闰年，以及年龄段

//判断是否为闰年，以及年龄段
    public static void half() {
        int year = 2000;
        int age = 45;
        if ((year % 4 == 0) && (year % 100 != 0) || (year % 400 == 0)) {
            System.out.println("闰年");
        } else {
            System.out.println("不是闰年");
        }
        if ((20 < age) && (age <= 40)) {
            System.out.println("青年人");
        } else if ((40 < age) && (age <= 60)) {
            System.out.println("中年人");
        } else if (60 < age) {
            System.out.println("老年人");
        }
    }

 用switch输出春夏秋冬

//用switch输出春夏秋冬
    static void nice() {
        int month = 1;
        switch (month) {
            case 12:
            case 1:
            case 2:
                System.out.println("冬天");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("春天");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏天");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋天");
                break;
        }
    }

 按分数输出等级

//按分数输出等级
    static void rng() {
        int grade = 85;
        int level = grade / 10;
        switch (level) {
            case 9: {
                System.out.println("5");
                break;
            }
            case 8: {
                System.out.println("4");
                break;
            }
            case 7: {
                System.out.println("3");
                break;
            }
            case 6: {
                System.out.println("2");
                break;
            }
            case 5: {
                System.out.println("1");
                break;
            }
        }
    }

输出特定格式 

//输出特定格式
    static void rw() {
        for (int i = 1; i < 4; i++) {
            for (int j = 1; j < 10; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }

//结果：
*********
*********
*********
-----------------------------------------------------------------------------------------
    static void jd() {
    int s = 2;
    for (int i = 1; i < 5; i++) {
        for (int j = 0; j < s; j++) {
            System.out.print(s);
        }
        s = s + 2;
        System.out.println();
    }
}
//结果：
22
4444
666666
88888888
-----------------------------------------------------------------------------------------
    static void sn() {
        String sb = "*";
        for (int i = 1; i < 5; i++) {
            for (int j = 0; j < 10-i; j++) {
                System.out.print(" ");
            }
            sb = sb+"*";
            System.out.println(sb);
        }
    }
//结果：
         **
        ***
       ****
      *****
-----------------------------------------------------------------------------------------
    static void start(){
        for (int i=1;i<10;i++){
            for (int j=1;j<i+1;j++){
                System.out.print(i+"*"+j+"="+i*j+" ");
            }
            System.out.println();
        }
    }
//结果：
1*1=1 
2*1=2 2*2=4 
3*1=3 3*2=6 3*3=9 
4*1=4 4*2=8 4*3=12 4*4=16 
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25 
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81 
-----------------------------------------------------------------------------------------
//小明想攒100元钱，妈妈每天给2.5元，每五天小明花6元，多少天能攒到100元钱？
    static void skt() {
        int day = 0;
        int moneyday = 0;
        double summoney = 0.0;
        double money = 2.5;
        while (summoney <= 100) {
            summoney = summoney + money;
            day++;
            moneyday++;
            if (moneyday % 5 == 0) {
                summoney = summoney - 6;
            }
        }
        System.out.println(day);
    }
//结果：
74

 ##冒泡排序##

//##冒泡排序##
//特点：效率低，实现简单
//思想：每一趟将待排序序列中最大元素移到最后，剩下的为新的待排序序列，重复上述步骤直到排完所有元素。 
//这只是冒泡排序的一种，当然也可以从后往前排。
public void bubbleSort(int array[]) {
		int t = 0;
		for (int i = 0; i < array.length - 1; i++)
			for (int j = 0; j < array.length - 1 - i; j++)
				if (array[j] > array[j + 1]) {
					t = array[j];
					array[j] = array[j + 1];
					array[j + 1] = t;
				}
	}

 ##选择排序##

//##选择排序##
//特点：效率低，容易实现。
//思想：每一趟从待排序序列选择一个最小的元素放到已排好序序列的末尾，剩下的为待排序序列，
//重复上述步骤 直到完成排序。
public void selectSort(int array[]) {
		int t = 0;
		for (int i = 0; i < array.length - 1; i++){
			int index=i;
			for (int j = i + 1; j < array.length; j++)
				if (array[index] > array[j])
					index=j;
			if(index!=i){ //找到了比array[i]小的则与array[i]交换位置
				t = array[i];
				array[i] = array[index];
				array[index] = t;
			}
		}
	}

 ##插入排序##

//##插入排序##
//特点：效率低，容易实现。
//思想：将数组分为两部分，将后部分元素逐一与前部分元素比较，如果前部分元素比array[i]小，
//就将前部分元素往后移动。当没有比array[i]小的元素，即是合理位置，在此位置插入array[i]
public void insertionSort(int array[]) {
		int i, j, t = 0;
		for (i = 1; i < array.length; i++) {
			if(a[i]<a[i-1]){
				t = array[i];
				for (j = i - 1; j >= 0 && t < array[j]; j--)
					array[j + 1] = array[j];
				//插入array[i]
				array[j + 1] = t;
			}
		}
}

 ##快速排序##

//快速排序
//特点：高效，时间复杂度为nlogn。
//采用分治法的思想：首先设置一个轴值pivot，
//然后以这个轴值为划分基准将待排序序列分成比pivot大和比pivot小的两部分，
//接下来对划分完的子序列进行快排直到子序列为一个元素为止。
public void quickSort(int array[], int low, int high) {// 传入low=0，high=array.length-1;
		int pivot, p_pos, i, t;// pivot->位索引;p_pos->轴值。
		if (low < high) {
			p_pos = low;
			pivot = array[p_pos];
			for (i = low + 1; i <= high; i++)
				if (array[i] > pivot) {
					p_pos++;
					t = array[p_pos];
					array[p_pos] = array[i];
					array[i] = t;
				}
			t = array[low];
			array[low] = array[p_pos];
			array[p_pos] = t;
			// 分而治之
			quickSort(array, low, p_pos - 1);// 排序左半部分
			quickSort(array, p_pos + 1, high);// 排序右半部分
		}