矩阵正定的判断，可以使用顺序主子式全部大于0

整体思路

1.输入矩阵

2.计算每一个子矩阵的值

3.判断

将问题分解就可以发现，我们需要一个切分矩阵的方法，还需要一个计算矩阵的值方法

计算矩阵

计算矩阵的值也使用传统的方法，一阶二阶直接计算，三阶以上的进行拆分

这里面就需要一个进行划出子矩阵的过程，思路也很简单

    public static int[][] getNewArr(int[][] arr,int j){
        int[][] Matrix = new int[arr.length-1][arr.length-1];
        for (int i = 0,a = 0; i < arr.length-1; i++,a++) {
            for (int k = 0,b=1; k <arr.length-1 ; k++,b++) {
                if(a==j&&a!=arr.length-1){
                    a++;
                }
                Matrix[i][k] =  arr[a][b];
            }
        }
        return Matrix;
    }

然后进行计算

    public static int get(int[][] arr,int n){
        if (n==1){
            return arr[0][0];
        }
        if (n == 2) {

            return arr[1][1]*arr[0][0]-arr[0][1]*arr[1][0];
        }
        int ans = 0;
        for (int i = 0; i < n; i++) {
            int[][] matrix = getNewArr(arr,i);
            System.out.println("子矩阵为");
            printArr(matrix);
            if((i+n+1)%2==0) {
                ans += arr[i][0] * get(matrix, n - 1);
            }else {
                ans -= arr[i][0] * get(matrix, n - 1);
            }
        }
        return ans;
    }

矩阵计算解决之后，判断是否正定就是一个循环的事情

完整代码

package project_self.JudgePositiveDefiniteMatrix;
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static int[][] getNewArr(int[][] arr,int j){
        int[][] Matrix = new int[arr.length-1][arr.length-1];
        for (int i = 0,a = 0; i < arr.length-1; i++,a++) {
            for (int k = 0,b=1; k <arr.length-1 ; k++,b++) {
                if(a==j&&a!=arr.length-1){
                    a++;
                }
                Matrix[i][k] =  arr[a][b];
            }
        }
        return Matrix;
    }
    public static int get(int[][] arr,int n){
        //arr代表矩阵，n代表矩阵阶数，j代表去除哪一行
        /*
        矩阵的计算方法
        1 2 3 4
        5 6 7 8
        8 7 6 5
        1 2 3 4
        = 1*{a}-5*{b}+8*{c}-1*{d}
        a = 6 7 8  b =  2 3 4   c = 2 3 4  d = 2 3 4
            7 6 5       7 6 5       6 7 8      6 7 8
            2 3 4       2 3 4       2 3 4      7 6 5
         */
        if (n==1){
            return arr[0][0];
        }
        if (n == 2) {

            return arr[1][1]*arr[0][0]-arr[0][1]*arr[1][0];
        }
        int ans = 0;
        for (int i = 0; i < n; i++) {
            int[][] matrix = getNewArr(arr,i);
            System.out.println("子矩阵为");
            printArr(matrix);
            if((i+n+1)%2==0) {
                ans += arr[i][0] * get(matrix, n - 1);
            }else {
                ans -= arr[i][0] * get(matrix, n - 1);
            }
        }
        return ans;
    }
    public static void printArr(int[][] arr){
        for (int[] ints : arr) {
            for (int anInt : ints) {
                System.out.print(anInt + " ");
            }
            System.out.println();
        }
    }
    public static int[][] newM(int[][] arr,int n){
        int[][] ints = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                ints[i][j] = arr[i][j];
            }
        }
        return ints;
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入矩阵的n值（n阶矩阵）");
        int N = scanner.nextInt();
        int[][] arr = new int[N][N];
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                arr[i][j] = scanner.nextInt();
            }
        }//输入矩阵
        /*
        通过顺序主子式怕判断是否正定
         */
        for (int i = 0; i < N; i++) {
            int[][] temp = newM(arr,i+1);
            if(get(temp,i+1)<0){
                System.out.println("不正定");
            }
        }
        System.out.println("ok");
    }
}