剑指offer_面试题20_顺时针打印矩阵（思路在一步步分解之中）

题目：输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。

例如：如果输入如下矩阵：

 1    2     3     4

 5    6     7     8

 9   10   11   12

13  14  15   16

则依次打印出数字：1、2、3、4、8、12、16、15、14、13、9、5、6、7、11、10。

思路如下：

算法如下：

#include <iostream>
#include <map>

using namespace std;

/*打印函数，这个函数传递二维数组用的形参 int arr[][columns],因此当传进来的二维函数维数变化时，就需要改动这里的columns值*/
/*可以把它改成 int ** arr，不过在传递的时候需要注意，传递指针的指针*/
void print_Matrix_InCircle(int arr[][5], int rows, int columns)   /**rows：行，columns：列*/
{
    if(NULL == arr || columns <= 0 || rows <= 0)
        return;

    int i = 0,j = 0;

    unsigned int k = 0;
    unsigned int all_number = rows * columns;
    int s[all_number];

    int n_c = columns, m_r = rows;   /**列，行*/

    map<int,int> word_count;
    for(int x = 0; x < columns; x++)
    {
        for(int y = 0; y < rows; y++)
        {
            word_count[arr[x][y]] = 0;
        }
    }

    while(n_c > 0 && m_r > 0)
    {
        /** 从左至右，剩余列数必须大于0 */
        if(n_c > 0 && i < rows && j < columns)     /**不要忘记 i、j 范围的判断*/
        {
            while(j < columns && !word_count[arr[i][j]])
            {
                s[k++] = arr[i][j];
                //cout << arr[i][j] << ' ';
                ++word_count[arr[i][j]];          /*标记已访问*/
                j++;
            }
            m_r--;  /*可供访问的行数减1*/
            j--;    /*退出之前 j 多加了一步*/
            i++;    /*i向下走一步*/
        }


        /** 从上至下，剩余行数必须大于0 */
        if(m_r > 0 && i < rows && j < columns)
        {
            while(i < rows && !word_count[arr[i][j]])
            {
                s[k++] = arr[i][j];
                //cout << arr[i][j] << ' ';
                //cout << arr[1][4] << ' ';
                ++word_count[arr[i][j]];
                i++;
            }
            n_c--;
            i--;
            j--;
        }

        /** 从右至左，剩余列数必须大于0 */
        if(n_c > 0 && i < rows && j < columns)
        {
            while(j >= 0 && !word_count[arr[i][j]])
            {
                s[k++] = arr[i][j];
                //cout << arr[i][j] << ' ';
                ++word_count[arr[i][j]];
                j--;
            }
            m_r--;
            j++;
            i--;
        }

        /** 从下至上，剩余行数必须大于0 */
        if(m_r > 0 && i < rows && j < columns)
        {
            while(i >= 0 && !word_count[arr[i][j]])
            {
                s[k++] = arr[i][j];
                //cout << arr[i][j] << ' ';
                ++word_count[arr[i][j]];
                i--;
            }
            n_c--;
            i++;
            j++;
        }
    }


    for(k = 0; k < all_number; k++)
    {
        cout << s[k] << ' ';
    }
    cout << endl;

}

int main()
{
/**
    int arr1[4][4] ={
        {1,2,3,4},
        {5,6,7,8},
        {9,10,11,12},
        {13,14,15,16}
    };

    //int ** p = (int **)&arr1;
    //cout << p[1][1];
    //int (*p1)[4] = arr1;
    print_Matrix_InCircle(arr1,4,4);
    cout << endl;
*/
/**
    int arr2[5][5] ={
        {1,2,3,4,5},
        {6,7,8,9,10},
        {11,12,13,14,15},
        {16,17,18,19,20},
        {21,22,23,24,25}
    };
    int (*p2)[5] = arr2;
    print_Matrix_InCircle(p2,5,5);
    cout << endl;
*/

    int arr3[4][5] ={
        {1,2,3,4,5},
        {6,7,8,9,10},
        {11,12,13,14,15},
        {16,17,18,19,20},
    };
    //int (*p3)[5] = arr3;
    print_Matrix_InCircle(arr3,4,5);

/**
    int arr4[1][5] ={
        {1,2,3,4,5}
    };
    print_Matrix_InCircle(arr4,1,5);
    cout << endl;
*/
/**
    int arr5[5][1] ={
        {1},
        {2},
        {3},
        {4},
        {5}
    };
    print_Matrix_InCircle(arr5,5,1);
    cout << endl;
*/
/**
    int arr6[1][1] ={
        {1}
    };
    print_Matrix_InCircle(arr6,1,1);
    cout << endl;
*/
/**
    int arr7[2][2] ={
        {1,2},
        {3,4}
    };

    print_Matrix_InCircle(arr7,2,2);
    cout << endl;
*/
    return 0;
}

结果如下：

以下是 设置 指针的指针 来指向二维数组的方法：

void Test(int columns, int rows)
{
    printf("Test Begin: %d columns, %d rows.\n", columns, rows);

    if(columns < 1 || rows < 1)
        return;

    int** numbers = new int*[rows];        /*注意这里，要给它分配空间*/
                                           /*给一个指向 含有rows个int元素数组的 指针分配了存储空间，并将这个指针，赋给了 number指针*/
    for(int i = 0; i < rows; ++i)
    {
        numbers[i] = new int[columns];     /*注意这里，number[i] 也是一个指针，指向一个数组元素，也需要给它分配空间*/
        for(int j = 0; j < columns; ++j)
        {
            numbers[i][j] = i * columns + j + 1;
        }
    }

    print_Matrix_InCircle(numbers, columns, rows);    /*传递 指针的指针*/
    printf("\n");

    for(int i = 0; i < rows; ++i)
        delete[] (int*)numbers[i];

    delete[] numbers;
}

需要注意二维数组指针的问题，如：

int arr[5][6];

int (*p)[6] = arr;     /* p 是一个指向有 6 个数组元素数组的指针，注意这是一个指向一维数组的指针 */

如果 （int **）强制转换，也不行，转换后无法操作二维数组数据。

/**点滴积累，我的一小步O(∩_∩)O~*/