将一个5X5的矩阵中最大的元素放在中心， 4个角分别放4个最小的元素（顺序为从左到右，从上到下一次从小到大存放）

将一个5X5的矩阵中最大的元素放在中心，
4个角分别放4个最小的元素（顺序为从左到右，从上到下一次从小到大存放），
写个一函数来实现，用main函数调用。（要求用指针来做）
输入
每组数据为5X5的矩阵，矩阵的数字为整数。
有多组测试数据，直到输入文件结束。
输出

输出按题目要求改变后的矩阵,每组结果后空一行。

样例输入
35 34 33 32 31
30 29 28 27 26
25 24 23 22 21
20 19 18 17 16
15 14 13 12 11
样例输出
11 34 33 32 12
30 29 28 27 26
25 24 35 22 21
20 19 18 17 16
13 23 15 31 14

 
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
// // 拷贝到平台的时候把my_fuction_lib.h注释掉.
//#include "my_fuction_lib.h"
 
//在此下方插入自定义函数对的声明:
/* 交换/修改 指针指所指内存里所保存的变量值. */
void swap(int *p, int *q)
{
    int temp;
    temp = *p;
    *p = *q;
    *q = temp; //change the value of the variable which is pointed by the pointer.
}
/* 求出当前矩阵的最小元素并保存到buf,同时返回最小元素在矩阵中的位置(或说是相对于源位置pq的偏移量) */
int smallest(int *pq, int n, int *buf)
{
    int smallest = *pq;
    //int *smallest_index;
    int smallest_offset;
    for (int i = 1; i < n * n; i++)
    {
        if (smallest > *(pq + i))
        {
            smallest_offset = i;
            smallest = *(pq + i); //smallest 的值也必须迭代,比较下去才有效果.
        }
    }
    buf[0] = *(pq + smallest_offset);
    //return smallest_index;
    return smallest_offset;
}
 
// int  matrix(int *pq,int n)
// {
 
//     return max_offset;
// }
/* 换行打印(只有一重for的),每行的末尾无多余的空格 */
 
/* 打印/用来监视矩阵元素被调整的情况. */
void print(int *pq, int n)
{
    for (int i = 0; i < n * n; i++)
    {
 
        printf("%d ", *(pq + i));
        if (i % 5 < 4)
        {
            //printf(" ");
        }
        if (i > 0 && i % 5 == 4)
            printf("\n"); //当然如果额外定义一个cnt来计数也可以.
    }
    printf("\n");
}
//主函数main
int main()
{
    while (1)
    {
        int *pq;
        int buf[1];
        int buf_sum[4];
        int max;
        int n = 5;
        int size_int = sizeof(int);
        pq = (int *)malloc(n * n * size_int);
 
        int max_offset = 0;
  
 
        /* 判断是否需要停止测试/读入新数据 */
        if (scanf("%d", pq) != EOF)
        {
            max = *pq;
            for (int i = 1; i < n * n; i++)
            {
                scanf("%d", pq + i);
                if (max < *(pq + i)) //compare the value.
                {
                    //max_index = (pq + i);//however,change the tag标记 of the index of the true max_value/
                    max_offset = i;
                    max = *(pq + i);
                }
            }
        }
        else
        {
            break;
        }
 
        swap(pq + 2 * n + 2, pq + max_offset);
        max = *(pq + 2 * n + 2);
        //print(pq,n);
        //left_up
        swap(pq, (pq + smallest(pq, n, buf)));
        *pq = max;
        //print(pq,n);
        buf_sum[0] = buf[0];
        //print(pq,n);
        //right_up
        swap(pq + 4, (pq + smallest(pq, n, buf)));
        *(pq + 4) = max;
        //print(pq,n);
        buf_sum[1] = buf[0];
        //print(pq,n);
        //letf_down
        swap(pq + 4 * n, (pq + smallest(pq, n, buf)));
        *(pq + 4 * n) = max;
        //print(pq,n);
        buf_sum[2] = buf[0];
        //print(pq,n);
        //right_down
        swap(pq + 4 * n + 4, (pq + smallest(pq, n, buf)));
        *(pq + 4 * n + 4) = max;
        //print(pq,n);
        buf_sum[3] = buf[0];
        //print(pq,n);
 
        /* 将保存的四角元素填充会矩阵的对应位置. */
        *pq = buf_sum[0];
        *(pq + 4) = buf_sum[1];
        *(pq + 4 * n) = buf_sum[2];
        *(pq + 4 * n + 4) = buf_sum[3];
 
        print(pq, n);
        
    }
 
    return 0;
}