6. Z字形变换（LeetCode）——C语言

方法一：

执行用时: 76 ms，在所有 C 提交中击败了23.00%的用户
内存消耗: 6.4 MB，在所有 C 提交中击败了60.00%的用户

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char *zStr(char *str, int numRows)
{
  int k = 0;
  int len = strlen(str);
  if (numRows < 2) {
        return str;
  }
  char *resStr = (char *)malloc((len + 1) * sizeof(char));
  for (int row = 0; row < numRows; row++)
  {
    for (int i = 0; i < len; i++)
    {
      // 通过观察Z形字符串，可以发现以下规律：将其以2 * numRows - 2个数归为一组，每一组的下标对其这组数字个数求余
      // 可得到两组结果：一组与row相等（即Z形字符串的行的下标，从0开始），一组与row的和等于numRows - 2
      // 下面从第一行开始循环，将第一行符合条件的元素放置到新数组，其后每行依次进行，直到将所有元素放置到新数组
      if (i % (2 * numRows - 2) == row || i % (2 * numRows - 2) == 2 * numRows - 2 - row)
      {
        resStr[k++] = str[i];
      }
    }
  }
  resStr[len] = '\0';
  return resStr;
}

int main(void)
{
  char *str = "nfgszvcsdx";
  int numRows = 5;
  char *retStr = zStr(str, numRows);
  int i = 0;
  while (retStr[i] != '\0')
  {
    printf("%c", retStr[i]);
    i++;
  }
  printf("\n");
}

这个方法事件复杂度为O(numRows*n)，n为字符串长度，numRows为字符串长度。
空间复杂度为O(n)。
方法二：
执行用时：0 ms, 在所有 C 提交中击败了100.00%的用户
内存消耗：6.6 MB, 在所有 C 提交中击败了44.94%的用户

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char *convert(char *str, int numRows)
{
  int k = 0;
  int len = strlen(str);
  char *resStr = (char *)malloc((len + 1) * sizeof(char));
  // 特殊情况：行数小于2，或者字符串长度不大于行数，则直接返回字符串
  // 因为此时要么只有一行，要么只有一列
  if (numRows < 2 || len <= numRows)
  {
    return str;
  }
  for (int row = 0; row < numRows; row++)
  {
    // 将每一个numRows指定的行的行首字符存储到返回字符
    resStr[k++] = str[row];
    for (int i = row; i < len;)
    {
      // 在每一个numRows行，寻找原字符串中相应的元素下标

      // 每行第二个元素下标与第一个元素下标具有以下关系：j = i + 2numRows - 2 - 2row
      // 特殊情况：最后一行第一个和第二个元素是重合的，因此下面的表达式为： i += 0 -> i，即i没变
      i += 2 * (numRows - row - 1);
      // 特殊情况：最后一行第一个和第二个元素是重合的，因此，不需要计算，
      // 在这里排除最后一行：numRows - row > 1
      if (numRows - row > 1 && i < len) {
        resStr[k++] = str[i];
      }
      // 每行第二个元素和第三个元素下标具有以下关系：j = i + 2row
      // 特殊情况：最后一行第一个和第二个元素是重合的，因此第三个元素与第一个元素下标符合此关系
      i += 2 * row;
      if (row > 0 && i < len)
      {
        resStr[k++] = str[i];
      }
    }
  }
  resStr[k] = '\0';
  return resStr;
}

int main(void)
{
  char *str = "nfaskofncklasnfclas";
  int numRows = 5;
  char *retStr = convert(str, numRows);
  int i = 0;
  while (retStr[i] != '\0')
  {
    printf("%c", retStr[i]);
    i++;
  }
  printf("\n");
}

此方法时间复杂度为O(n)，n为字符串长度。虽然循环时嵌套的，但是最终循环的次数是n次，将n个字符全部放置到新数组。
空间复杂度为O(n)，n为字符串长度。

方法三

这也是官方给出的方法，和方法二很类似。都是横向遍历Z字形字符串。
通过观察Z字形字符串，可以得出下面的性质：、

• row为横向循环的行的下标，0 =< row < numRows
• 首行元素的下标为k(2numRows - 2) + row，k为偶数，从0开始
• 中间行元素的下标为k(2numRows - 2) + row，(k + 1)(2numRows - 2) - row，k为从0开始的整数。
• 尾行元素的下标为k(2numRows - 2) + row，k为偶数，从0开始

根据以上性质，进行横向循环，可以很容易就获得最终的字符串。

执行用时：0 ms, 在所有 C 提交中击败了100.00%的用户
内存消耗：6.5 MB, 在所有 C 提交中击败了58.46%的用户

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char *convert (char *str, int numRows) {
  int len = strlen(str);
  // 必须排除非Z字形的情况
  if (numRows < 2)
  {
    return str;
  }
  int k = 0;
  int loopConst = 2 * numRows - 2;
  char *retStr = (char *)malloc((len + 1) * sizeof(char));
  for (int row = 0; row < numRows; row++) {
    for (int i = 0; i + row < len; i += loopConst) {
      retStr[k++] = str[i + row];
      if (row != 0 && row != numRows - 1 && i + loopConst - row < len ) {
        retStr[k++] = str[i + loopConst - row]; 
      }
    }
  }
  retStr[k] = '\0';
  return retStr;
}

int main (void) {
  char *str = "msd";
  int numRows = 4;
  char *retStr = NULL;
  int i = 0;
  retStr = convert(str, numRows);
  while (retStr[i] != '\0')
  {
    printf("%c", retStr[i++]);
  }
  printf("\n");
}

时间复杂度： O(n)
空间复杂度： O(n)