算法系列-----矩阵（三）-------------矩阵的子矩阵

矩阵的子矩阵      注意矩阵的下标是从  0开始的到n-1和m-1

获取某一列的子矩阵：

	/**
	 * 矩阵的子矩阵函数
	 * 
	 * @param args
	 *            参数a是个浮点型（double）的二维数组，n是去掉的列号
	 * @return 返回值是一个浮点型二维数组（矩阵去掉第n列后的矩阵）
	 */
	public static double[][] zjz(double[][] a, int n) {
		int hang = a.length;
		int lie = a[0].length;
		double[][] result = new double[hang][lie - 1];

		for (int i = 0; i < hang; i++) {
			for (int j = 0; j < n; j++) {
				result[i][j] = a[i][j];
			}
			for (int j = n + 1; j < lie; j++) {
				result[i][j - 1] = a[i][j];
			}
		}

		return result;
	}

// 当去掉某一列的时候，就可以假定行不变，变成了一维的数组，去掉某一个下表，就如此简单

下面就是一维去掉某一列的子矩阵：

	public static double[] zjz(double[] a, int n) {
		int hang = a.length;
		double[] result = new double[hang - 1];
		for (int i = 0; i < hang; i++) {
			if (i < n) {
				result[i] = a[i];
			}
			if (i > n) {
				result[i - 1] = a[i];
			}
		}
		return result;
	}

</pre><pre name="code" class="html">

获取去掉某一行的子矩阵：

	/**
	 * 矩阵的子矩阵函数
	 * 
	 * @param args
	 *            参数a是个浮点型（double）的二维数组，place是去掉的行号
	 * @return 返回值是一个浮点型二维数组（矩阵去掉第place行后的矩阵）
	 */
	public static double[][] zjz_qh(double[][] a, int place) {
		double[][] b = new double[a.length - 1][a[0].length];
		for (int i = 0; i < place; i++) {
			for (int j = 0; j < a[0].length; j++) {
				b[i][j] = a[i][j];
			}
		}
		for (int i = place; i < a.length - 1; i++) {
			for (int j = 0; j < a[0].length; j++) {
				b[i][j] = a[i + 1][j];
			}
		}
		return b;
	}

// 这个过程很简单，把前面的行和后面的行分开取就可以了

获取去掉某一行和某一行的子矩阵：

</pre><pre name="code" class="java">	/**
	 * 矩阵的子矩阵函数
	 * 
	 * @param args
	 *            参数a是个浮点型（double）的二维数组，m是要去掉的行号，n是去掉的列号
	 * @return 返回值是一个浮点型二维数组（矩阵去掉第m行和n列后的矩阵）
	 */
	public static double[][] zjz(double[][] a, int m, int n) {
		int hang = a.length;
		int lie = a[0].length;
		double[][] result = new double[hang - 1][lie - 1];
		for (int i = 0; i < hang; i++) {
			for (int j = 0; j < lie; j++) {
				if (i < m && j < n) {
					result[i][j] = a[i][j];
				}
				if (i > m && j < n) {
					result[i - 1][j] = a[i][j];
				}
				if (i < m && j > n) {
					result[i][j - 1] = a[i][j];
				}
				if (i > m && j > n) {
					result[i - 1][j - 1] = a[i][j];
				}
			}
		}
		return result;
	}

测试代码：

	public static void main(String[] args) {
		double[] a = { 3, 2, 1, 4};
		double[] b = { 5, 6, 9, 8};
		double[] s_test = zjz(a,2);
		
		double[][] d_a = new double[][]{{1,2},{3,4}};
		double[][] d_b = new double[][]{{7, 8}, {6, 5}};
		double[][] d_c = new double[][]{{7, 8}, {6, 5}};
		double[][] d_testa = zjz(d_a,1);
		double[][] d_testb = zjz_qh(d_b,1);
		double[][] d_testc = zjz(d_c,0,0);
		System.out.println("一维矩阵的子矩阵");
		System.out.println("--------------------------------");
		print_array(s_test);
		System.out.println("矩阵的子矩阵");
		System.out.println("--------------------------------");
		print(d_testa);

		System.out.println("矩阵的子矩阵");
		System.out.println("--------------------------------");
		print(d_testb);
		System.out.println("矩阵的子矩阵");
		System.out.println("--------------------------------");
		print(d_testc);
	}

输入测试矩阵：

一维矩阵
--------------------------------
	3.0	2.0	1.0	4.0
矩阵a
--------------------------------
	1.0	2.0
	3.0	4.0
矩阵b
--------------------------------
	7.0	8.0
	6.0	5.0

输出结果：

一维矩阵的子矩阵
--------------------------------
	3.0	2.0	4.0
矩阵的子矩阵
--------------------------------
	1.0
	3.0
矩阵的子矩阵
--------------------------------
	7.0	8.0
矩阵的子矩阵
--------------------------------
	5.0