杨氏矩阵，字符串左旋，字符串旋转结果

杨氏矩阵

有一个数字矩阵，矩阵的每行从左到右是递增的，矩阵从上到下是递增的，请编写程序在这样的矩阵中查找某个数字是否存在。

要求：时间复杂度小于O(n)

解题思路

这是一个杨氏矩阵：

查找一个数在矩阵中是否存在，当然映入脑海的，是遍历数组，当然这不失为一种方法，而这道题有一个要求：时间复杂度小于O(n) 显然遍历数组这种方法已经超过了要求的时间复杂度，所以只能另辟蹊径。

细读题目，发现有个条件：矩阵的每行从左到右是递增的，矩阵从上到下是递增的。那是否可以通过这个条件找到一种方法使得时间复杂度达到题目要求呢？

下面是我的具体思路

仔细看我们发现，一行中最右边的数是一行中最大的，一列中最小的，利用这个特点，我们就可以减少查找次数。举个例子，我们要找数字7，我们只需判断3是否比7大，那当然否，那么3的左边不可能有比3大的数字，我们往下找，找到6，判断是否比7大，那当然否，那么6的左边就不肯有比6大的字，然后再往下找，找到9，9比7大，所以9的左边可能存在数字7，然后一直往左边找，直到越界了还没找到那就是不存在。

（当然从左下角开始找也可以，过程和从右上角开始找大差不差，我就不过多赘述）

代码实现

#include <stdio.h>
int find_k(int arr[3][3], int *px, int *py, int k)
{
    int x = 0;
    int y = *py - 1;
    while (x<=*px-1 && y>=0)
    {
        if (arr[x][y] < k)
        {
            x++;
        }
        else if (arr[x][y] > k)
        {
            y--;
        }
        else
        {
            *px = x;
            *py = y;
            return 1;
        }
    }
    return 0;
}

int main()
{
    int arr[3][3] = { 1,2,3,4,5,6,7,8,9 };
    int k = 7;//查找的值
    int x = 3;//代表行，也代表返回的下标x
    int y = 3;//代表列，也代表返回的下标y
    int ret = find_k(arr, &x, &y, k);//此处为传址调用，为了在函数内部改变x，y的值
    if (ret == 0)
        printf("找不到\n");
    else
        printf("找到了，下标是:%d %d", x, y);

    return 0;
}

字符串左旋

实现一个函数，可以左旋字符串中的k个字符。

例如：

ABCD左旋一个字符得到BCDA

ABCD左旋两个字符得到CDAB

方法一：拼接法

解题思路

新开辟一份空间，将需要左旋的字符后面的复制到新开辟的空间，然后再将前面的字符拼接到新开辟的空间。

代码实现

#include <stdio.h>
#include <string.h>
int main()
{
    char a[] = "abcd";
    int time = 0;
    printf("请输入你要左旋转的个数\n");
    scanf("%d", &time);
    int len = strlen(a);
    int pos = time % len; //断开位置的下标
    char tmp[100] = { 0 }; //更准确的话可以选择malloc len + 1个字节的空间来做这个tmp

    strcpy(tmp, a + pos); //先将后面的全部拷过来
    strncat(tmp, a, pos); //然后将前面几个接上

    printf("%s", tmp);
}

方法一的时间复杂度为O（n）,但是新开辟了空间。

运行结果：

方法二：逐个左旋法

解题思路

设计循环使其可以旋1次，然后让他执行n次。创建一个临时变量储存首元素，然后将后面的元素逐个左旋，最后将临时变量放到数组最后为左旋一次。

代码实现

#include <stdio.h>
#include <string.h>
void left_move(char arr[], int k)
{
    int i = 0;
    int len = strlen(arr);
    k %= len;
    for (i = 0; i < k; i++)
    {
        //旋转1个字符
        //1
        char tmp = arr[0];
        //2
        int j = 0;
        for (j = 0; j < len - 1; j++)
        {
            arr[j] = arr[j + 1];
        }
        //3
        arr[len - 1] = tmp;
    }
}
int main()
{
    char arr[] = "abcdef";
    int k = 0;
    scanf("%d", &k);
    left_move(arr, k);
    printf("%s\n", arr);
    return 0;
}

方法二虽然没有新开辟空间，但是时间复杂度为o(n^n),方法太繁杂.

运行结果：

方法三：巧妙的三次逆序法

解题思路

例如ABCD，左旋2次后变成CDAB，有一个特殊的操作方式：

先将要左旋的前两个字符逆序（BACD），然后将后半段也逆序（BADC），最后整体逆序（CDAB）即可。我们可以写一个函数帮我们完成逆序

代码实现

#include <stdio.h>
#include <assert.h>

void reverse(char* left, char* right)
{
    assert(left && right);
    while (left < right)
    {
        char tmp = *left;
        *left = *right;
        *right = tmp;
        left++;
        right--;
    }
}
void left_move(char arr[], int k)
{
    int len = strlen(arr);
    k %= len;
    //逆序左
    reverse(arr, arr + k - 1);
    //逆序右
    reverse(arr + k, arr + len - 1);
    //逆序整体
    reverse(arr, arr + len - 1);
}

int main()
{
    char arr[] = "abcd";
    int k = 0;
    scanf("%d", &k);
    left_move(arr, k);
    printf("%s\n", arr);
    return 0;
}

这种方法既不需要开辟新的空间，时间复杂度也为o(n)。

运行结果：

字符串旋转结果:

写一个函数，判断一个字符串是否为另外一个字符串旋转之后的字符串。

例如：给定s1 =AABCD和s2 = BCDAA，返回1

给定s1=abcd和s2=ACBD，返回0.

AABCD左旋一个字符得到ABCDA

AABCD左旋两个字符得到BCDAA

AABCD右旋一个字符得到DAABC

方法一：逐个旋转加判断

解题思路

根据上一题逐个左旋法的思路，在左旋一次后加入判断是否相等即可

代码实现

#include <assert.h>
#include <stdio.h>
#include <string.h>
void reverse(char* left, char* right)//逆序函数
{
    assert(left);
    assert(right);
    while (left < right)
    {
        char tmp = *left;
        *left = *right;
        *right = tmp;
        left++;
        right--;
    }
}

void left_move(char arr[], int k)
{
    int len = strlen(arr);
    k %= len;
    //逆序左
    reverse(arr, arr + k - 1);
    //逆序右
    reverse(arr + k, arr + len - 1);
    //逆序整体
    reverse(arr, arr + len - 1);
}
int is_left_move(char arr1[], char arr2[])
{
    int len1 = strlen(arr1);
    int len2 = strlen(arr2);
    if (len1 != len2)
        return 0;
    int i = 0;
    for (i = 0; i < len1; i++)
    {
        left_move(arr1, 1);
        if (strcmp(arr1, arr2) == 0)
        {
            return 1;
        }
    }

    return 0;
}
int main()
{
    char arr1[20] = "AABCD";
    char arr2[] = "ABCDA";
    int ret = is_left_move(arr1, arr2);
    if (ret == 1)
    {
        printf("YES\n");
    }
    else
    {
        printf("NO\n");
    }
    return 0;
}

运行结果：

方法二：重复加库函数法

解题思路

所谓重复法就是将不被旋转的字符串自己拼接自己，例如AABCD,重复之后为AABCDAABCD。然后判断需要查找的BCDAA是否为重复之后的子字符串。所谓子字符串就是在AABCDAABCD中的部分字符串。显然BCDAA为AABCDAABCD的子字符串。

代码实现：

#include <stdio.h>
#include <string.h>
int is_left_move(char arr1[], char arr2[])
{
    int len1 = strlen(arr1);
    int len2 = strlen(arr2);
    if (len1 != len2)
        return 0;
    strncat(arr1, arr1, len1);//自己拼接自己
    if (strstr(arr1, arr2) != NULL)
        return 1;
    else
        return 0;
}
int main()
{
    char arr1[20] = "AABCD";
    char arr2[] = "ABCDA";
    int ret = is_left_move(arr1, arr2);
    if (ret == 1)
    {
        printf("YES\n");
    }
    else
    {
        printf("NO\n");
    }
    return 0;
}

运行结果：

注释：本人新手，如有更优解，欢迎在评论区指教。