Java实现杨辉三角形、回型树、快排、数组的反转

1.杨辉三角形

/**
 *   杨辉三角形
 *     1.只有一个或者两个数时，都是1
 *     2.每行第一个和最后一个都是1
 *     3.arr[i][j] = arr[i-1][j-1] + arr[i-1][j]
 * */

//1.初始化
int[][] arr = new int[10][10];

//2.将一维数组里的 一维数组赋初始默认值
for (int i = 0; i < arr.length ; i++) {
    //内存元素个数等于行数
    arr[i] = new int[i + 1];  

    //初始化首部和尾部
    arr[i][0] = 1;
    
    //arr[i][i]  当i = 2 时， arr[2][2] = 1 即最后一个为1
    arr[i][i] = 1;

    //从第三行开始 
    //arr[i][j] = arr[i-1[j-1] + arr[i-1][j];
    if(i > 1){
        //从第二列开始arr[i][1],以arr[i].length-1结尾
        for (int j = 1; j < arr[i].length - 1; j++) {
            arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
        }
    }
}

//3.遍历数组
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j <arr[i].length ; j++) {
        System.out.print(arr[i][j] + " ");
    }
    System.out.println();
}

2.拓展,随机数在数组中不重复

/** 拓展题 数组中有6个数 随机生成且不能重复*/
int[] arr =new int[6];
for (int i = 0; i < arr.length ; i++) {
    int num = (int) (Math.random() * 10 + 1);
    arr[i] = num;
    
    //判断当前数是否和前面的数重复，如果当前数与之前的数重复 i-
    for (int j = 0; j < i ; j++) {
        if(arr[i] == arr[j]){
            i--;
            break;
        }
    }
}

for (int i = 0; i < arr.length ; i++) {
    System.out.println(arr[i]);
}

3.回型数

Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
int[][] arr = new int[num][num];
int total = 1;
int minH = 0; // 初始行坐标
int maxH = arr.length -1; // 最大行坐标
int minL = 0;  //列坐标
int maxL = arr.length - 1; //最大列坐标

while (total != num * num + 1){
    //1.先向右移动--列移动
    for (int i = minL; i <= maxL ; i++) {
        arr[minH][i] = total;
        total++;
    }
    //行数加1
    minH++;

    //2.向下移动--行移动
    for (int i = minH; i <= maxH; i++) {
        arr[i][maxL] = total;
        total++;
    }
    //移动完后改变列方向
    maxL--;

    //3.向左移动--列移动
    for (int i = maxL; i >= minL; i--){
        arr[maxH][i] = total;
        total++;
    }
    maxH--;

    //4.向上移动--行移动
    for (int i = maxH; i >= minH ; i--) {
        arr[i][minL] = total;
        total++;
    }
    //一轮走完，进行下一轮的赋值
    minL++;
}

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

4.数组的反转

/** 数组的反转 
 *   1，2，3，4，5，6，7，8，9，10
 *   1&10,2&9,3&8 ... 进行对调
 *   1 : arr[0] 10: arr[arr.length(10)-1]  i=0, i++
 *   2 : arr[1]  9: arr[arr.length(10)-1 - i(1)]             i=1, i++
 * */
int[] arr = new int[]{1,2,3,4,5,6,7,8,9,10};

for (int i = 0; i < arr.length / 2 ; i++) {
    int temp = arr[i];
    arr[i] = arr[arr.length - 1 -i];
    arr[arr.length - 1 - i] = temp;
}

for (int i = 0; i < arr.length ; i++) {
    System.out.print(arr[i]);
}

5.快速排序

/**
 * 快速排序
 *    如果最左边为基准数，则从右检索把比自己小的放在自己左边，比自己大的不动，从左边检索把自己的大的往右边放
 *    如果最右边为基准数，则从左边检索把比自己大的放在自己右边，从右边检索比自己小的不动
 *
 *    找到一个基准数，例如 22,11,53,16,33,15,44
 *    一：22为基准数，先从右边向左边检索，找到比基准数小的数时，停下，否则继续检索
 *    二:当右边停下时，开始从左边检索，找到比基准数大的时候,停下并和右边停下的值进行交换
 *    三:然后将基准数和相遇的数进行交换
 * */
public static void main(String[] args) {
    int[] arr = new int[]{2,8,2,1,9,5,4};
    sort(arr,0,arr.length-1);
    System.out.println(Arrays.toString(arr));
}

public static void sort(int[] arr,int left,int right){
    if(left > right) return;
    int base = arr[left];  //记录基准数

    int i = left; //左边开始索引
    int j = right;  //右边开始索引

    //当i和j相遇时，一轮排序结束
    while (i != j){
        //从右边开始向左检索,把比基准数小的放在基准数的左边
        while (arr[j] >= base && i < j){
            j--;
        }

        //到这步，右边检索完成，找到比基准数小的
        //开始从左边开始检索，把比基准数大的放在右边
        while (arr[i] <= base && i < j){
            i++;
        }

        //当两者都满足了各自的要求，交换值
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    //当代码走到这步， i和j相遇，交换基准数和相遇数的值
    arr[left] = arr[i];
    arr[i] = base;

    //对左边进行排序
    sort(arr,left,i-1);

    //对右边进行排序
    sort(arr,i+1,right);
}