剑指 Offer 17. 打印从1到最大的n位数 剑指 Offer 21. 调整数组顺序使奇数位于偶数前面 剑指 Offer 29. 顺时针打印矩阵

目录

剑指 Offer 17. 打印从1到最大的n位数 

思路：利用 malloc 先为要返回的 列表创建一个空间

代码

 剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

思路：

代码 

 剑指 Offer 29. 顺时针打印矩阵

 思路

代码

---

 

剑指 Offer 17. 打印从1到最大的n位数 

输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。

示例 1:

输入: n = 1
输出: [1,2,3,4,5,6,7,8,9]
 

说明：

用返回一个整数列表来代替打印
n 为正整数

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/da-yin-cong-1dao-zui-da-de-nwei-shu-lcof

思路：利用 malloc 先为要返回的 列表创建一个空间

          然后循环， 利用pow函数定数列大小，

 因为按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最     大的 3 位数 999

我们接下来就挨个赋值就行，

因为第一位要放 1， 那我们就让 i = 1，然后i 做下标时就减 1，p[0] = 1 

 这句一定不能丢哦

代码

int* printNumbers(int n, int* returnSize)
{
     int* p = (int*)malloc(sizeof(int) * (pow(10, n)));
     int i = 0;
     for(i = 1; i < pow(10, n); i++)//因为0位是1
     {
         p[i - 1] = i;
     }
     *returnSize = pow(10, n) - 1;//这句不能丢
     return p;
     free(p);
     p = NULL;
}

 剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数在数组的前半部分，所有偶数在数组的后半部分。

示例：

输入：nums = [1,2,3,4]
输出：[1,3,2,4] 
注：[3,1,2,4] 也是正确的答案之一。
 

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/diao-zheng-shu-zu-shun-xu-shi-qi-shu-wei-yu-ou-shu-qian-mian-lcof

 

思路：

代码都有注释，和之前写的一篇差不多 https://blog.csdn.net/iiiiiihuang/article/details/128995211?spm=1001.2014.3001.5501

代码 

int* exchange(int* nums, int numsSize, int* returnSize)
{
    int* p = (int*)malloc(sizeof(int) * numsSize);
    //创建左右下标,这种需要左右比较的最好都创建一下
    int left = 0;
    int right = numsSize - 1;
 while(left < right)
 {
    //先找到奇数和偶数，把他俩调换
    //找奇数,奇数放左边
    while(nums[right] % 2 == 0 && left < right)
    {
       right--;//要把右边的换到左边
    }
    //找偶数，偶数放右边
    while(nums[left] % 2 != 0 && left < right)
    {
        left++;
    }
    //找到后互换
    int tem = nums[left];
    nums[left] = nums[right];
    nums[right] = tem;
    right--;
    left++;//别忘
 }
 int i = 0;
 for(i = 0;i < numsSize; i++)
 {
     p[i] = nums[i];

 }
 *returnSize = numsSize;
 return p;
 free(p);
 p = NULL;
}

 剑指 Offer 29. 顺时针打印矩阵

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

示例 1：

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]
示例 2：

输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]
 

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/shun-shi-zhen-da-yin-ju-zhen-lcof

 思路

 

就是按上图循序打印的

我们先分析一下题给出的几个形参分别是什么

接下来就好说了，搞清打印顺序，从左到右，在从上到下，在从右到左，在从下到上，这时最外围的，之后在打印此外围的，以此类推，转着圈打印， 说不好说清楚，直接上代码，代码里都有注释

注意：得0 情况不要忘，*returnSize也别忘

代码

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* spiralOrder(int** matrix, int matrixSize, int* matrixColSize, int* returnSize)
{
    if (matrixSize == 0)//matrixSize是元数个数（这里算的是一个大括号是一个元素，也可以理解为行数）
    {
        *returnSize = 0;
        return NULL;
    }
    //上下左右定下来
    int up = 0;
    int down = matrixSize - 1;
    int left = 0;
    int right = *matrixColSize - 1;
    *returnSize = matrixSize * (*matrixColSize);
    int* p = (int*)malloc(sizeof(int) * (*returnSize));//放新的数组
    int pos = 0;//新数组的下标
   // *returnSize = matrixSize * (*matrixColSize);
    while (pos < *returnSize)
    {
        int i = 0;
        //先从左到右,上up
        for (i = left; i <= right && pos < *returnSize; i++)
        {
            p[pos] = matrix[up][i];
            pos++;
        }
        up++;
        //在从上到下
        for (i = up; i <= down && pos < *returnSize; i++)
        {
            p[pos] = matrix[i][right];
            pos++;
        }
        right--;
        //再从右到左
        for (i = right; i >= left && pos < *returnSize; i--)
        {
            p[pos] = matrix[down][i];
            pos++;
        }
        down--;
        //再从下到上
        for (i = down; i >= up && pos < *returnSize; i--)
        {
            p[pos] = matrix[i][left];
            pos++;
        }
        left++;
    }
    return p;
    free(p);
    p = NULL;
}

╰(*°▽°*)╯╰(*°▽°*)╯╰(*°▽°*)╯╰(*°▽°*)╯╰(*°▽°*)╯完╰(*°▽°*)╯╰(*°▽°*)╯╰(*°▽°*)╯╰(*°▽°*)╯╰(*°▽°*)╯