java入门小练习（杨辉三角，线性查找，二分查找，冒泡）

这里使用二维数组来生成一个10行的杨辉三角

根据杨辉三角的定义，我们可以得到如下规律：

a[i][j] = a[i-1][j-1] + a[i-1][j]
//一个元素等于该元素上边与左上方两个元素之和
a 可以看做杨辉三角矩阵

实现方法如下：

public class YangHui{
    public static void main(String[] args){
        //声明二维数组-动态初始化
        int[][] array = new int[10][];
        //给二维数组赋值
        for(int i = 0;i < array.length;i++){
            array[i] = new int[i + 1];

            array[i][0] = array[i][i] = 1;
            
            for(int j = 1;j<array[i].length-1;j++){
                 array[i][j] = array[i-1][j-1] + array[i-1][j];
                
            }
        }

        //遍历二维数组
        for(int i = 0;i<array.length;i++){
            for(int j = 0;j<array[i].length;j++){
                System.out.print(array[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

1	
1	1	
1	2	1	
1	3	3	1	
1	4	6	4	1	
1	5	10	10	5	1	
1	6	15	20	15	6	1	
1	7	21	35	35	21	7	1	
1	8	28	56	70	56	28	8	1	
1	9	36	84	126	126	84	36	9	1	

Process finished with exit code 0

定义一个一维数组，随机赋值（10-99），并计算该数组中的最大值和所有元素的和

主要在于赋值的使用

公式如下

arr[i] = (int)(Math.random() * (99 - 10 + 1) + 10);
//+10是从10-99，+0则为0-99的随机赋值

package com.helloworld.java;
public class HelloWorld{
    public static void main(String[] args){
        int[] arr = new int[10];
        //定义一个sum存放总和
        int sum = 0;
        for(int i = 0;i < arr.length;i++){
            //实现随机赋值
            arr[i] = (int)(Math.random() * (99 - 10 + 1) + 10);
        }
        int maxValue = arr[0];
        for(int i =0;i < arr.length;i++){
            //求总和
            sum+=arr[i];
            //求最大值
            if(maxValue<arr[i]){
                maxValue = arr[i];
            }
        }
        System.out.println("the max of array is: " + maxValue);
        System.out.println("the sum of array is: " + sum);
    }
}

数组的反转

//数组的反转,不是反着遍历
    int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
    int temp = 0;
    for(int i =0; i < arr.length / 2;i++){
        temp = arr[i];
        arr[i] = arr[arr.length - i - 1];
        arr[arr.length - i -1] = temp;
     }

//方法二
 int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
    int temp = 0;
    for(int i = 0, j = arr.length-1; i < j ;i++,j--){
        temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

线性查找

直接遍历搜索就完事

 int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};

    //线性查找
    int desc = 4;
    for(int i = 0;i < arr.length;i++){
        if(arr[i] == desc){
            System.out.println("已找到，位置为：" + (i+1));
            break;
        }
    }

二分法查找

使用二分法前提是一个有序数组，因此如何对一个数组进行排序也是必要的知识

 //二分法查找(适合于有序数组）
    int desc = 66;
    //初始的首索引
    int head = 0;
   //初始的末索引
    int end = arr.length-1;
    boolean isFlag = true;
    while(head <= end){
        int middle = (head + end) / 2;
        if(desc == arr[middle]){
            System.out.println("find it ,the location is:" + (middle + 1));
            isFlag = false;
            break;
        }else if(arr[middle] > desc){
            end = middle -1;
        }else{
            head = middle + 1;
        }
    }
    if(isFlag){
        System.out.println("sorry,no find it");
    }

时间复杂度：分析关键字的比较次数和记录的移动次数

空间复杂度：分析排序算法中需要多少辅助内存

十大排序算法：（先了解一下）

• 选择排序：直接选择排序，堆排序
• 交换排序：冒泡排序，快速排序
• 插入排序：直接插入排序，折半插入排序，Shell排序
• 归并排序
• 桶式排序
• 基数排序

冒泡排序

基本思想：通过对排序序列从前向后，依次比较相邻元素的排序码，若发现逆序则交换，使排序码较大的元素逐渐从前部移向后部。

int[] arr = new int[]{1, -4, 5, 2, 35, 16, 34, -42, 16};
    //冒泡排序
    for(int i = 0;i<arr.length - 1;i++){
        for(int j = 0; j < arr.length - i - 1;j++){
            if(arr[j] > arr[j + 1]){
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    //遍历
    for(int i = 0;i<arr.length;i++){
        System.out.print(arr[i] + "\t");
    }

接下来开始准备面向对象的学习！！！