故,可以更进一步将代码改进如下:这样,不需要在每次递归的过程中尚可能增大一软
k<0 的论断

09:矩阵乘法

  • 查看
  • 提交
  • 统计
  • 提问

总时限制: 
1000ms

内存限制: 
65536kB

描述
算算两只矩阵的乘法。n*m阶的矩阵A乘以m*k阶的矩阵B得到的矩阵C
是n*k阶的,且C[i][j] = A[i][0]*B[0][j] +
A[i][1]*B[1][j] + ……
+A[i][m-1]*B[m-1][j](C[i][j]意味着C矩阵中第i尽第j列元素)。

输入
第一行为n, m, k,表示A矩阵是n行m列,B矩阵是m行k列,n, m, k都低于100
然后先后输入A和B两独矩阵,A矩阵n行m列,B矩阵m行k列,矩阵中每个元素的绝对值不见面过1000。

输出
输出矩阵C,一共n行,每行k个整数,整数之间为一个空格分开。

样例输入
3 2 3
1 1
1 1
1 1
1 1 1
1 1 1

样例输出
2 2 2
2 2 2
2 2 2

#include<iostream>
using namespace std;
int a[1001][1001];
int b[1001][1001];
int c[1001][1001];
int now=1;//记录i的值 
int tot;//记录m-1 
int main()
{
    int n,k,m;
    cin>>n>>m>>k;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            cin>>a[i][j];
        }
    }
    for(int i=1;i<=m;i++)
    {
        for(int j=1;j<=k;j++)
        {
            cin>>b[i][j];
        }
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=k;j++)
        {
            while(now<=m) 
            {
                c[i][j]=a[i][now]*b[now][j]+c[i][j];
                now++;
            }
            now=1;
        }

    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=k;j++)
        {
            cout<<c[i][j]<<" ";
        }
        cout<<endl;
    }
    return 0;
}

 

②若K等于0,第0叠就是树根,根只来一个,返回1

 1     /**
 2      * 
 3      * @param k
 4      * @return 二叉树中第K层结点的个数(根位于第0层)
 5      */
 6     public int k_nodes(int k){
 7         if(k < 0)
 8             return 0;
 9         return k_nodes(root, k);
10     }
11     private int k_nodes(BinaryNode<T> root, int k){
12         if(root == null)
13             return 0;
14         if(k == 0)
15             return 1;//根结点
16         else
17             return k_nodes(root.left, k-1) + k_nodes(root.right, k-1);
18     }

 

感觉到对二叉树被之不少操作都得以用递归来实现。因此,二叉树是明递归一个好实例。比如,二叉树的操作的统计二叉树被节点的个数

二叉树的先序遍历和后序遍历的动–输出文件以及统计目录大小

关于
C2_2_8类,参考:擅自行生成算法—生成前N个整数的均等组自由行

①若二叉树为空或K小于0,返回0

 

老三,求解第K叠结点统计个数的算法实现

 1 public class BinaryTree<T extends Comparable<? super T>> {
 2     
 3     private static class BinaryNode<T>{
 4         T element;
 5         BinaryNode<T> left;
 6         BinaryNode<T> right;
 7         
 8         public BinaryNode(T element) {
 9             this.element = element;
10             left = right = null;
11         }
12     }
13     
14     private BinaryNode<T> root;
15     
16     /**
17      * 向二叉树中插入一个元素
18      * @param element
19      */
20     public void insert(T element){
21         root = insert(root, element);
22     }
23     private BinaryNode<T> insert(BinaryNode<T> root, T element){
24         if(root == null)
25             return new BinaryNode<T>(element);
26         int r = (int)(2*Math.random());
27         //随机地将元素插入到左子树 或者 右子树中
28         if(r==0)
29             root.left = insert(root.left, element);
30         else
31             root.right = insert(root.right, element);
32         return root;
33     }
34     
35     /**
36      * 
37      * @param k
38      * @return 二叉树中第K层结点的个数(根位于第0层)
39      */
40     public int k_nodes(int k){
41         return k_nodes(root, k);
42     }
43     private int k_nodes(BinaryNode<T> root, int k){
44         if(root == null || k < 0)
45             return 0;
46         if(k == 0)
47             return 1;//根结点
48         else
49             return k_nodes(root.left, k-1) + k_nodes(root.right, k-1);
50     }
51     
52     public static void main(String[] args) {
53         BinaryTree<Integer> tree = new BinaryTree<>();
54         
55         int[] ele = C2_2_8.algorithm1(4);//构造一个随机数组,数组元素的范围为[1,4]
56         for (int i = 0; i < ele.length; i++) {
57             tree.insert(ele[i]);
58         }
59         
60         int k_nodes = tree.k_nodes(2);//第二层
61         int k_nodes2 = tree.k_nodes(-1);//第-1层
62         int k_nodes3 = tree.k_nodes(0);
63         int k_nodes4 = tree.k_nodes(1);
64         int k_nodes5 = tree.k_nodes(4);//若超过了树的高度,结果为0
65         System.out.println(k_nodes);
66         System.out.println(k_nodes2);
67         System.out.println(k_nodes3);
68         System.out.println(k_nodes4);
69         System.out.println(k_nodes5);
70     }
71 }

http://blog.csdn.net/luckyxiaoqiang/article/details/7518888

除此以外,在BinaryTree中得一定一个BinaryNode属性来代表树之根结点。

 

坐,第K重叠结点,相对于清之左子树 和 右子树 而言,就是第K-1层结点

五,参考资料

可参考:按层打印二叉树–每行打印一交汇
来测试每一样重叠是否来科学的结点个数。

实际,这是发出改善的地方:对于K<0的事态,准确地说:其不过是一个地下输入,而非是递归的收尾条件(基准条件)。可以看到,①决不把地下输入与递归的尺度条件混淆,②将黑输入的判定坐递归中判断的开是老可怜之。因为各个进行相同浅递归就需开展同样破地下输入判断。而只要以起来就管黑输入过滤掉,在递归过程中即不见面设有每一样不好递归就判断一致不好非法输入了。

季,代码实现

概念一个BinaryTree类来代表二叉树,二叉树BinaryTree
又是由于逐一结点组成的,因此用定义一个结点类BinaryNode,BinaryNode作为BinaryTree的里边类。

同样,问题讲述

率先执行是二叉树类的定义,第三实施是得了点类的概念,第20实践是二叉树根的定义。

 

2) root==null  当递归到root==null时,说明:第K重合没有结点

第二,二叉树的构建

1) k==0 当递归到K==0时,说明:第K叠是发生结点的

 

呼吁第K层结点的个数也可用递归来实现:

构建平蔸二叉树(不自然是二叉查找树),求来该二叉树被第K层中之结点个数(根结点为第0重合)

 

③若K大于0,返回左子树被第K-1层结点个数 加上 右子树被第K-1层结点的个数

递归的尺度条件就来半点单:

 1 public class BinaryTree<T extends Comparable<? super T>> {
 2     
 3     private static class BinaryNode<T>{
 4         T element;
 5         BinaryNode<T> left;
 6         BinaryNode<T> right;
 7         
 8         public BinaryNode(T element) {
 9             this.element = element;
10             left = right = null;
11         }
12     
13         public BinaryNode(T element, BinaryNode<T> left, BinaryNode<T> right){
14             this.element = element;
15             this.left = left;
16             this.right = right;
17         }
18     }
19     
20     private BinaryNode<T> root;
21 
22 //other code.....