判断对称矩阵

最新推荐文章于 2021-12-28 23:21:49 发布
最新推荐文章于 2021-12-28 23:21:49 发布
阅读量663 收藏
点赞数
分类专栏： 剑指offer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/szl_lxy/article/details/47396515
版权

题目描述

请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。 

#include <iostream>
#include "BinaryTree.h"

using namespace std;

bool isSymmetrical(BinaryTreeNode* pRoot1,BinaryTreeNode* pRoot2)
{
	if(pRoot1 == NULL && pRoot2 == NULL)
		return true;
	if(pRoot1 == NULL || pRoot2 == NULL)
		return false;
	if(pRoot1 ->m_nValue != pRoot2 ->m_nValue)
		return false;

	return isSymmetrical(pRoot1->m_pLeft,pRoot2->m_pRight) && isSymmetrical(pRoot1->m_pRight,pRoot2->m_pLeft);
}

bool isSymmetrical(BinaryTreeNode* pRoot)
{
	return isSymmetrical(pRoot, pRoot);
}
测试用例 
// ==================== Test Code ====================
void Test(char* testName, BinaryTreeNode* pRoot, bool expected)
{
    if(testName != NULL)
        printf("%s begins: ", testName);

    if(isSymmetrical(pRoot) == expected)
        printf("Passed.\n");
    else
        printf("FAILED.\n");
}

//            8
//        6      6
//       5 7    7 5
void Test1()
{
    BinaryTreeNode* pNode8 = CreateBinaryTreeNode(8);
    BinaryTreeNode* pNode61 = CreateBinaryTreeNode(6);
    BinaryTreeNode* pNode62 = CreateBinaryTreeNode(6);
    BinaryTreeNode* pNode51 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode71 = CreateBinaryTreeNode(7);
    BinaryTreeNode* pNode72 = CreateBinaryTreeNode(7);
    BinaryTreeNode* pNode52 = CreateBinaryTreeNode(5);

    ConnectTreeNodes(pNode8, pNode61, pNode62);
    ConnectTreeNodes(pNode61, pNode51, pNode71);
    ConnectTreeNodes(pNode62, pNode72, pNode52);

    Test("Test1", pNode8, true);

    DestroyTree(pNode8);
}

//            8
//        6      9
//       5 7    7 5
void Test2()
{
    BinaryTreeNode* pNode8 = CreateBinaryTreeNode(8);
    BinaryTreeNode* pNode61 = CreateBinaryTreeNode(6);
    BinaryTreeNode* pNode9 = CreateBinaryTreeNode(9);
    BinaryTreeNode* pNode51 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode71 = CreateBinaryTreeNode(7);
    BinaryTreeNode* pNode72 = CreateBinaryTreeNode(7);
    BinaryTreeNode* pNode52 = CreateBinaryTreeNode(5);

    ConnectTreeNodes(pNode8, pNode61, pNode9);
    ConnectTreeNodes(pNode61, pNode51, pNode71);
    ConnectTreeNodes(pNode9, pNode72, pNode52);

    Test("Test2", pNode8, false);

    DestroyTree(pNode8);
}

//            8
//        6      6
//       5 7    7
void Test3()
{
    BinaryTreeNode* pNode8 = CreateBinaryTreeNode(8);
    BinaryTreeNode* pNode61 = CreateBinaryTreeNode(6);
    BinaryTreeNode* pNode62 = CreateBinaryTreeNode(6);
    BinaryTreeNode* pNode51 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode71 = CreateBinaryTreeNode(7);
    BinaryTreeNode* pNode72 = CreateBinaryTreeNode(7);

    ConnectTreeNodes(pNode8, pNode61, pNode62);
    ConnectTreeNodes(pNode61, pNode51, pNode71);
    ConnectTreeNodes(pNode62, pNode72, NULL);

    Test("Test3", pNode8, false);

    DestroyTree(pNode8);
}

//               5
//              / \
//             3   3
//            /     \
//           4       4
//          /         \
//         2           2
//        /             \
//       1               1
void Test4()
{
    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode31 = CreateBinaryTreeNode(3);
    BinaryTreeNode* pNode32 = CreateBinaryTreeNode(3);
    BinaryTreeNode* pNode41 = CreateBinaryTreeNode(4);
    BinaryTreeNode* pNode42 = CreateBinaryTreeNode(4);
    BinaryTreeNode* pNode21 = CreateBinaryTreeNode(2);
    BinaryTreeNode* pNode22 = CreateBinaryTreeNode(2);
    BinaryTreeNode* pNode11 = CreateBinaryTreeNode(1);
    BinaryTreeNode* pNode12 = CreateBinaryTreeNode(1);

    ConnectTreeNodes(pNode5, pNode31, pNode32);
    ConnectTreeNodes(pNode31, pNode41, NULL);
    ConnectTreeNodes(pNode32, NULL, pNode42);
    ConnectTreeNodes(pNode41, pNode21, NULL);
    ConnectTreeNodes(pNode42, NULL, pNode22);
    ConnectTreeNodes(pNode21, pNode11, NULL);
    ConnectTreeNodes(pNode22, NULL, pNode12);

    Test("Test4", pNode5, true);

    DestroyTree(pNode5);
}


//               5
//              / \
//             3   3
//            /     \
//           4       4
//          /         \
//         6           2
//        /             \
//       1               1
void Test5()
{
    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode31 = CreateBinaryTreeNode(3);
    BinaryTreeNode* pNode32 = CreateBinaryTreeNode(3);
    BinaryTreeNode* pNode41 = CreateBinaryTreeNode(4);
    BinaryTreeNode* pNode42 = CreateBinaryTreeNode(4);
    BinaryTreeNode* pNode6 = CreateBinaryTreeNode(6);
    BinaryTreeNode* pNode22 = CreateBinaryTreeNode(2);
    BinaryTreeNode* pNode11 = CreateBinaryTreeNode(1);
    BinaryTreeNode* pNode12 = CreateBinaryTreeNode(1);

    ConnectTreeNodes(pNode5, pNode31, pNode32);
    ConnectTreeNodes(pNode31, pNode41, NULL);
    ConnectTreeNodes(pNode32, NULL, pNode42);
    ConnectTreeNodes(pNode41, pNode6, NULL);
    ConnectTreeNodes(pNode42, NULL, pNode22);
    ConnectTreeNodes(pNode6, pNode11, NULL);
    ConnectTreeNodes(pNode22, NULL, pNode12);

    Test("Test5", pNode5, false);

    DestroyTree(pNode5);
}

//               5
//              / \
//             3   3
//            /     \
//           4       4
//          /         \
//         2           2
//                      \
//                       1
void Test6()
{
    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode31 = CreateBinaryTreeNode(3);
    BinaryTreeNode* pNode32 = CreateBinaryTreeNode(3);
    BinaryTreeNode* pNode41 = CreateBinaryTreeNode(4);
    BinaryTreeNode* pNode42 = CreateBinaryTreeNode(4);
    BinaryTreeNode* pNode21 = CreateBinaryTreeNode(2);
    BinaryTreeNode* pNode22 = CreateBinaryTreeNode(2);
    BinaryTreeNode* pNode12 = CreateBinaryTreeNode(1);

    ConnectTreeNodes(pNode5, pNode31, pNode32);
    ConnectTreeNodes(pNode31, pNode41, NULL);
    ConnectTreeNodes(pNode32, NULL, pNode42);
    ConnectTreeNodes(pNode41, pNode21, NULL);
    ConnectTreeNodes(pNode42, NULL, pNode22);
    ConnectTreeNodes(pNode21, NULL, NULL);
    ConnectTreeNodes(pNode22, NULL, pNode12);

    Test("Test6", pNode5, false);

    DestroyTree(pNode5);
}

// Only one node
void Test7()
{
    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);
    Test("Test7", pNode1, true);

    DestroyTree(pNode1);
}

// No nodes
void Test8()
{
    Test("Test8", NULL, true);
}

// All nodes have the same value
//               5
//              / \
//             5   5
//            /     \
//           5       5
//          /         \
//         5           5
void Test9()
{
    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode21 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode22 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode31 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode32 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode41 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode42 = CreateBinaryTreeNode(5);

    ConnectTreeNodes(pNode1, pNode21, pNode22);
    ConnectTreeNodes(pNode21, pNode31, NULL);
    ConnectTreeNodes(pNode22, NULL, pNode32);
    ConnectTreeNodes(pNode31, pNode41, NULL);
    ConnectTreeNodes(pNode32, NULL, pNode42);
    ConnectTreeNodes(pNode41, NULL, NULL);
    ConnectTreeNodes(pNode42, NULL, NULL);

    Test("Test9", pNode1, true);

    DestroyTree(pNode1);
}

// All nodes have the same value
//               5
//              / \
//             5   5
//            /     \
//           5       5
//          /       /
//         5       5
void Test10()
{
    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode21 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode22 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode31 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode32 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode41 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode42 = CreateBinaryTreeNode(5);

    ConnectTreeNodes(pNode1, pNode21, pNode22);
    ConnectTreeNodes(pNode21, pNode31, NULL);
    ConnectTreeNodes(pNode22, NULL, pNode32);
    ConnectTreeNodes(pNode31, pNode41, NULL);
    ConnectTreeNodes(pNode32, pNode42, NULL);
    ConnectTreeNodes(pNode41, NULL, NULL);
    ConnectTreeNodes(pNode42, NULL, NULL);

    Test("Test10", pNode1, false);

    DestroyTree(pNode1);
}

void main(int argc, char* argv[])
{
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();
    Test6();
    Test7();
    Test8();
    Test9();
    Test10();
}

szl_lxy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java生成对称矩阵
05-09
java生成对称矩阵
C++离散数学算法判断对称矩阵
06-23
C++离散数学算法判断对称矩阵,是一个6*6的矩阵，输入时候可要仔细一点，输入错误的话矩阵就没意义了，VC++写这类矩阵程序，其实也并不复杂哦，判断是否是配对矩阵，其实是很有意思的事。
二维数组 SDUT
weixin_45726784的博客
12-11 460
对称矩阵的判定 Time Limit: 1000 ms Memory Limit: 65536 KiB Problem Description 输入矩阵的行数，再依次输入矩阵的每行元素，判断该矩阵是否为对称矩阵，若矩阵对称输出“yes"，不对称输出”no“。 Input 输入有多组，每一组第一行输入一个正整数N（N<=20），表示矩阵的行数（若N=0，表示输入结束）。 下面依次输入N行数据。...
对称矩阵的判定
zhangzhaolin12的博客
12-09 2243
Time Limit: 1000 ms Memory Limit: 65536 KiB Problem Description 输入矩阵的行数，再依次输入矩阵的每行元素，判断该矩阵是否为对称矩阵，若矩阵对称输出“yes"，不对称输出”no“。 Input 输入有多组，每一组第一行输入一个正整数N（N<=20），表示矩阵的行数（若N=0，表示输入结束）。 下面依次输入N行数据。 Output ...
问题 : 对称矩阵的判定
qq_47189506的博客
11-18 1036
题目描述 输入矩阵的行数，再依次输入矩阵的每行元素，判断该矩阵是否为对称矩阵，若矩阵对称输出yes，不对称输出no 输入 第一行输入一个正整数 NNN (N≤20)(N \le 20)(N≤20)，表示矩阵的行数。 下面依次输入 NNN 行数据。 输出 若矩阵对称输出 yes，不对称输出 no。 解答： #include<stdio.h> int main() { int count=0,n, a[20][20], x, y; scanf("%d",&n);..
C#判断一个矩阵是否为对称矩阵及反称矩阵的方法
12-31
1.判断对称矩阵 对任意i和j，有a[i,j]=a[j,i] /// /// 检查一个矩阵是否为对称矩阵 /// /// 矩阵 /// <returns>true：是对称矩阵 false：不是对称矩阵 private static bool isSymmetric(double[][] matrix) { //...
java算法——上三角、下三角、对称矩阵
07-15
本篇文章将深入探讨Java中实现上三角、下三角和对称矩阵的相关知识点。 首先，上三角矩阵是一个二维数组，其中主对角线（从左上角到右下角的线）下方的所有元素都是0。这种矩阵在解决线性代数问题、计算系统中的...
C++实现离散数学中对称矩阵的判断
03-15
在本文中，我们将深入探讨如何使用C++编程语言实现离散数学中的对称矩阵判断。对称矩阵是一种特殊的方阵，其对角线两侧的元素相同，即对于矩阵中的任意元素\(a_{ij}\)，都有\(a_{ij} = a_{ji}\)。这种性质在数学和...
问题 A: 对称矩阵的判定
Ydsb_w的博客
12-13 954
题目描述 输入矩阵的行数，再依次输入矩阵的每行元素，判断该矩阵是否为对称矩阵，若矩阵对称输出“yes"，不对称输出”no“。 输入 输入有多组，每一组第一行输入一个正整数N（N<=20），表示矩阵的行数（若N=0，表示输入结束）。 下面依次输入N行数据。 输出 若矩阵对称输出“yes"，不对称输出”no”。 样例输入 Copy 3 6 3 12 3 18 8 12 8 7 3 6 9 12 3 5 8 12 6 3 0 样例...
问题 E: 对称矩阵的判定
Ydsb_w的博客
12-28 718
题目描述 输入矩阵的行数，再依次输入矩阵的每行元素，判断该矩阵是否为对称矩阵，若矩阵对称输出“yes"，不对称输出”no“。 输入 输入有多组，每一组第一行输入一个正整数N（N<=20），表示矩阵的行数（若N=0，表示输入结束）。 下面依次输入N行数据。 输出 若矩阵对称输出“yes"，不对称输出”no”。 样例输入 Copy 3 6 3 12 3 18 8 12 8 7 3 6 9 12 3 5 8 12 6 3 0 样例输出 Copy yes no #include&l
python解zuobiaoxi方程_矩阵的特征分解（推导+手算+python计算+对称矩阵的特征分解性质）...
weixin_39737224的博客
11-20 512
1. 前言最近几天一直在学习矩阵的知识，恶补了特征分解和SVD算法，发现网上很多资料都是不全的，所以想记录一下这里面的特征分解推导过程。要学会矩阵的特征分解，可以提前看矩阵的一些基础知识： https://blog.csdn.net/qq_30232405/article/details/1045882932.矩阵的进阶知识2.1 特征分解（谱分解）=>只可以用在方阵上2.1.1 特征分解...
缩放图片 图片上的字坐标不变_从坐标变换和矩阵角度分析平移和垂直水平对称与python代码实现...
weixin_39916360的博客
11-28 176
今天的笔记为图像的平移、水平和垂直对称。前半部分是原理记录，后半部分将三种算法用python实现，定义一个便于扩展的类整合多个功能，如果有bug请帮我找出。首先要引入图像坐标系的概念，按照自己看到的资料，比如数字图像处理教材，图像坐标系应该是左上角被定义为坐标原点，这样图像的像素位置就能用坐标表示了：笔记包含两部分：第一部分：图像平移，水平和垂直对称原理第二部分：算法python实现1.1、图像平...
python 对称矩阵的判定
qq_43618642的博客
11-25 6948
Description 输入矩阵的行数，再依次输入矩阵的每行元素，判断该矩阵是否为对称矩阵，若矩阵对称输出“yes"，不对称输出”no“。 Input 输入有多组，每一组第一行输入一个正整数N（N<=20），表示矩阵的行数（若N=0，表示输入结束）。 下面依次输入N行数据。 Output 若矩阵对称输出“yes"，不对称输出”no”。 while True: n = int(input()) if n == 0: break else: lis
C语言判断对称矩阵
qq_51593632的博客
10-29 9219
输入一个M*M的矩阵，判断该矩阵是否为对称矩阵，并输出判断结果。 分析：核心是转置矩阵和原矩阵相应位置的值是否相等。 #include <stdio.h> #define M 3 int main(int argc, char **argv) { int f[M][M], g[M][M], t = 0; for(int i = 0; i < M; i++) { for(int j = 0; j < M; j++) { sc
数据结构-矩阵-对称矩阵(Java语言)
韦海涛的博客
02-02 4309
详细的代码可见github： https://github.com/AbitGo/myClassWork/tree/master/workspace_ds 对称矩阵（Symmetric Matrices）是指以主对角线为对称轴，各元素对应相等的矩阵。 具体实现类 package com.company.ch4.Matrix; import com.company.ch4.Tripl...
对称矩阵与压缩存储算法（java实现）
tanjie_123的专栏
11-02 2110
一、问题描述 实现一个对称矩阵的压缩存储 二、算法分析 对称矩阵的特点：a[i][j] = a[j][i].即所有元素关于对角线对称 所以可以将对称矩阵的下三角存储在一个数组对象SA中，存储方式是， SA[0] = a[0][0] SA[1] = a[1][0]   SA[2] = a[1][1] SA[3] = a[2][0]   SA[4] = a[2][1]   SA[5] =
华中科技大学 对称矩阵(java)
weixin_43306331的博客
02-11 450
题目描述 输入一个N维矩阵，判断是否对称。 输入描述: 输入第一行包括一个数：N(1<=N<=100)，表示矩阵的维数。 接下来的N行，每行包括N个数，表示N*N矩阵的元素。 输出描述: 可能有多组测试数据，对于每组数据， 输出"Yes!”表示矩阵为对称矩阵。 输出"No!”表示矩阵不是对称矩阵。 示例1 输入 复制 4 16 19 16 6 19 16 14 5 16 14 16...
c语言利用函数判断对称矩阵
最新发布
05-17
下面是一个利用函数判断对称矩阵的示例代码： ```c #include #define MAX_SIZE 100 int is_symmetric(int matrix[MAX_SIZE][MAX_SIZE], int n) { int i, j; // 判断是否为方阵 if (n || n > MAX_SIZE) { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值