指针进阶，（左旋转字符，杨式矩阵）

下面程序的结果是（）

int main() {
    int aa[2][5] = { 10,9,8,7,6,5,4,3,2,1 };
    int* ptr1 = (int*)(&aa + 1);
    int* ptr2 = (int*)(*(aa + 1));
    printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));
    return 0;
}

A.1,6
B10,5
C.1,5
D,10,6
正确答案：A

第二题：

实现一个函数，可以左旋字符串中的k个字符
列如：
ABCD 左旋一个字符得到BCDA
ABCD 左旋二个字符得到CDAB

第一种算法

void left_move(char * srt , int k) {
    //良好的编程习惯，判断数组srt是否为null
    assert(srt != NULL);
    int len = strlen(srt);
    int i = 0;
    for (i = 0; i < k; i++) {
        //左旋转第一个字符,创建一个临时变量tmp存放它
        char tmp = *srt;
        //后面的元素往前挪动
        int j = 0;
        for (j = 0; j < len - 1; j++) {
            *(srt + j) = *(srt + j + 1);
        }
        //把之前存放的需要旋转的值，存放到最后

        *(srt + len - 1) = tmp;

    }
}
int main() {
    char arr[] = "abcdef";
    left_move(arr, 2);
    printf("%s\n", arr);
    return 0;
}

第二种算法

三步翻转法

abcdef        //第一步，前两个字符先逆序
bafedc        //第二步，后面的字符逆序
cdefab       //第三步，从左至右逆序

void reverser(char * left, char* right) {
    assert(left != NULL);
    assert(right != NULL);
    while (left < right) {
        char tmp = *left;
        *left = *right;
        *right = tmp;
        left++;
        right--;
    }
}
void left_move(char * arr, int k) {
    assert(arr);
    int len = strlen(arr);
    assert(k <= len);
    reverser(arr,arr+k-1);//逆序左边
    reverser(arr+k,arr+len-1);//逆序右边
    reverser(arr,arr+len-1);//逆序整体
}

int main() {
    char arr[] = "abcdef";
    left_move(arr, 2);
    printf("%s\n", arr);
    return 0;
}

第三种算法：

问！s1=abcdef  s2=cdefab s2是否是s1逆序后的字符串？
#include <assert.h>
void reverser(char * left, char* right) {
    assert(left != NULL);
    assert(right != NULL);
    while (left < right) {
        char tmp = *left;
        *left = *right;
        *right = tmp;
        left++;
        right--;
    }
}
void left_move(char * arr, int k) {
    assert(arr);
    int len = strlen(arr);
    assert(k <= len);
    reverser(arr,arr+k-1);//逆序左边
    reverser(arr+k,arr+len-1);//逆序右边
    reverser(arr,arr+len-1);//逆序整体
}
int is_left_move(char* s1, char* s2) {
    assert(s1 != NULL);
    assert(s2 != NULL);
    int len = strlen(s1);  //计算s1的大小，因为要对s1进行逆序。
    int i = 0;
    for (i = 0; i < len; i++) {
        left_move(s1, 1);//调用left_move函数，s1每次向左旋转一个字符
        int ret = strcmp(s1, s2);//判断s1和s2是否相等
        if (ret == 0) { //相等 返回1
            return 1;

        }

    }
    return 0;  //不相等，返回0
}

int main() {
    char arr[] = "abcdef";
    char arr2[] = "cdefab";
    int ret = is_left_move(arr, arr2);
    if (ret == 1) {
        printf("yes");
    }
    else {
        printf("NO");
    }
    return 0;
}

第四种算法

char s1[]=abcdef

char s2[]=cdefab

我们追加s1

abcdefabcdef

然后s2从这里面去找，如果找到了，就代表s2是s1逆序来的

int is_left_move(char* s1, char* s2) {

    int len = strlen(s1);
    int len2 = strlen(s2);
    if (len != len2) {            //s1 和s2的长度要相等！！！
        return 0;
    }
    //在str1字符串中追加一个str1字符串
    //strncat
    strncat(s1, s1,6);//abcdefabcdef
    //判断str2指向的字符串是否是str1指向的字符串的字串。
    //strstr找字符串
    char* ret=strstr(s1, s2);//在str1中找str2
    if (ret == NULL) { 
        return 0;        //如果没有找到， 就返回0
    }
    else
        return 1;//如果找到了，就返回1
}
int main() {
    char arr[30] = "abcdef";
    char arr2[] = "cdefab";
    int ret = is_left_move(arr, arr2);
    if (ret == 1) {
        printf("yes");
    }
    else {
        printf("NO");
    }
}

第三题

杨式矩阵，找一个数，是否在这个矩阵中。
123
456
789
行从左到右递增，列从上到下递增
不能一一遍历数组。

int FindNum(int arr[3][3], int k, int row, int col) {
    int x = 0;
    int y = col - 1;
    while (x <= row - 1 && y >= 0) {
        if (arr[x][y]>k) {
            y--;
        }
        else if (arr[x][y]< k) {
            x++;
        }
        else {

            return 1;
        }
    }
    return 0;
}
int main() {
    int arr[3][3] = { {1,2,3},{4,5,6},{7,8,9} };
    int k = 7;
    int ret = FindNum(arr, k, 3, 3);
    if (ret == 0) {
        printf("not find\n");
    }
    else {
        printf("find\n");
    }
    return 0;
}

指针进阶，（左旋转字符，杨式矩阵）

原文：https://blog.51cto.com/u_15100290/2709525