bilibili2019秋招策略算法笔试---顺时针打印数字矩阵

最新推荐文章于 2022-12-13 21:54:25 发布

原创最新推荐文章于 2022-12-13 21:54:25 发布 · 2.3k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#哔哩哔哩 #策略算法岗 #笔试 #秋招

数据结构C++ 同时被 2 个专栏收录

22 篇文章

订阅专栏

冲刺2020秋招季，刷题不停歇

19 篇文章

订阅专栏

本文介绍了一个算法问题：如何按螺旋顺序打印矩阵。通过分析剑指Offer题目的核心思想，实现了一个C++程序，该程序能够接收多个矩阵作为输入，并以螺旋形式打印矩阵元素。特别注意了输入输出格式的要求。

题目：
这里写图片描述

剑指offer上有这个题核心思想的详细分析。但必须指出有所不同的是输入和输出格式，牛客网上的试题一般情况下都是写一个solution类就可以了，大多数不要求输入输出的格式。
哔哩哔哩的这个题，要求可以连续输入多个矩阵，直到输入-1，-1时，输入终止。
并且输出时要求最后的元素不带逗号，两个矩阵的打印序列要换行。
代码：

#pragma once
#include<stdlib.h>
#include<stdio.h>
#include<iostream>
using namespace std;


int PrintMatrixInCircle(int** number, int rows, int columns, int start, int k)
{
    int endX = columns - 1 - start;

    int endY = rows - 1 - start;

    for (int i = start; i <= endX; ++i)
    {
        printf("%d", number[start][i]);
        k++;
        if (k != columns * rows)//输出时的逗号和换行操作
        {
            printf(",");
        }
        else
        {
            cout << endl;//用习惯了cin,cout
        }
    }
    if (start<endY)
    {
        for (int i = start + 1; i <= endY; ++i)
        {
            printf("%d", number[i][endX]);
            k++;
            if (k != columns * rows)
            {
                printf(",");
            }
            else
            {
                cout << endl;
            }
        }
    }

    if (start<endX &&start<endY)
    {
        for (int i = endX - 1; i >= start; --i)
        {
            printf("%d", number[endY][i]);
            k++;
            if (k != columns * rows)
            {
                printf(",");
            }
            else
            {
                cout << endl;
            }
        }
    }

    if (start<endX && start<endY - 1)
    {
        for (int i = endY - 1; i >= start + 1; --i)
        {
            printf("%d", number[i][start]);
            k++;
            if (k != columns * rows)//输出时的逗号和换行操作
            {
                printf(",");
            }
            else
            {
                cout << endl;
            }
        }
    }
    return k;
}

void PrintMatrixClockwisely(int** numbers, int columns, int rows, int k)
{
    if (numbers == NULL || columns <= 0 || rows <= 0)
    {
        return;
    }
    int start = 0;
    while (columns>start * 2 && rows>start * 2)
    {
        k = PrintMatrixInCircle(numbers, columns, rows, start, k);//判断是否是矩阵最后一个打印元素的关键一步。
        ++start;
    }
}



int main()
{
    int *m, *n;
    int k = 0;
    int temp = 0;
    m = (int*)malloc(10000);
    n = (int*)malloc(10000);
    int ***number = (int***)malloc(10000);//为了存储多个矩阵，并循环打印
    while (scanf_s("%d" "%d", &m[temp], &n[temp]) != EOF)
    {
        if (m[temp] == -1 && n[temp] == -1)
        {
            break;
        }
        number[temp] = (int**)malloc(m[temp] * sizeof(int*));
        if (number == NULL)
        {
            exit(-1);
        }
        for (int i = 0; i<m[temp]; i++)
        {
            number[temp][i] = (int*)malloc(n[temp] * sizeof(int));
            if (number[temp][i] == NULL)
            {
                exit(-1);
            }
        }

        for (int i = 0; i<m[temp]; i++)
        {
            for (int j = 0; j<n[temp]; j++)
            {
                scanf_s("%d", &number[temp][i][j]);
            }

        }
        temp++;
    }

    for (int i = 0; i < temp; i++)
    {
        PrintMatrixClockwisely(number[i], m[i], n[i], k);

        for (int j = 0; j<m[i]; j++)
        {
            free(number[i][j]);
            number[i][j] = NULL;
        }
        /*for (int j = 0; j<m[i]; j++)
        {
            free(number[j]);
            number[j] = NULL;
        }*/

    }
    free(number);
    number = NULL;
    system("pause");
    return 0;
}
/*测试用例
4 4
1 2 3 4
3 4 5 6
5 6 7 8
7 8 9 0
3 3
1 2 3
4 5 6
7 8 9
-1 -1
*/