字符指针刷题记录：杨氏矩阵、字符串左旋、字符串旋转结果etc

字符指针刷题记录

1. 下面关于"指针"的描述不正确的是:

2. 关于下面代码描述正确的是：

char* p = "hello beauty！";
const char* p = "hello beauty！";//更恰当的写法

3. 关于数组指针的描述正确的是：

4. 下面哪个是数组指针：

数组指针是指针，指向的数组

指针数组是数组，存放的是指针

5. 下面哪个代码是错误的？

int main()
{
  int *p = NULL;
  int arr[10] = {0};//arr是数组名，数组名是首元素的地址int*
 //int* p = arr;
  return 0;
}

A.p = arr;
B.int (*ptr)[10] = &arr;//指针数组
C.p = &arr[0];//与A等价
D.p = &arr;//取出数组地址放到整型指针去，两者不匹配

6. 下面代码关于数组名描述不正确的是:

int main()
{
  int arr[10] = {0};
  return 0;
}

A.数组名arr和&arr是一样的//&arr和arr的值是一样的，但意义不同
B.sizeof(arr)，arr表示整个数组
C.&arr，arr表示整个数组
D.除了sizeof(arr)和&arr中的数组名，其他地方出现的数组名arr，都是数组首元素的地址。

7. 定义数组：

//如何定义一个int类型的指针数组，数组元素个数为10个：
int * arr[10];
A.int a[10]//整型数组
B.int (*a)[10]//数组指针
C.int *a[10];
D.int (*a[10])(int);//函数指针数组

8. 下面代码的执行结果是

int main()
{
  char str1[] = "hello bit.";
  char str2[] = "hello bit.";
  char *str3 = "hello bit.";
  char *str4 = "hello bit.";
  if(str1 == str2)
    printf("str1 and str2 are same\n");
  else
    printf("str1 and str2 are not same\n");//打印
  if(str3 == str4)
    printf("str3 and str4 are same\n");//打印
  else
    printf("str3 and str4 are not same\n");
  return 0; 
}

9. 杨氏矩阵

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

要求：时间复杂度小于O(N) ---- 避免遍历数据

1 2 3

4 5 6

7 8 9

思路拓展

代码实现

void find_num_in_young (int arr[3][3],int k,int *px,int *py)
{
	int i = 0;
	int j =*py - 1;
	int flag = 0;
	while (i <=* px - 1 && j >=0)
	{
		if (arr[i][j] < k)
			i++;
		else if (arr[i][j] > k)
			j--;
		else
		{
			//找到了
			flag = 1;
			*px = i;
			*py = j;
			break;
		}
	}
	if (flag == 0)
	{
		*px = -1;
		*py = -1;
	}
}

主函数

int main()
{
	int arr[3][3] = { 1,2,3,4,5,6,7,8,9 };
	int k=0;
	scanf("%d", &k);//输入查找数字
	//遍历数组
	int x = 0;
	int y = 3;
	//返回型参数
	find_num_in_young(arr, k, &x, &y);
	if (x == 1 && y == -1)
		printf("找不到\n");
	else
		printf("找到了，下标是：");
	return 0;
}

10. 字符串左旋

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

代码实现1

缺点：有些代码会重复移动

ABCD左旋一个字符得到BCDA

ABCD左旋两个字符得到CDAB

void left_move(char arr[], int k)
{
//每次只旋转一个字符，把这个动作执行k次
	int i = 0;
	int len = strlen(arr);
	k %= len;//提高效率，使循环次数落在个位数
	for (i = 0; i < k; i++)
	{
		//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;
	}
}

代码实现2：

一个代码仅交换两次

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)
{
	//每次只旋转一个字符，把这个动作执行k次
	int i = 0;
	int len = strlen(arr);
	k %=  len;
	reverse(arr, arr + k);
	reverse(arr+k,arr+len-1);
	reverse(arr, arr + len - 1);

}

主函数：

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

11. 字符串旋转结果

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

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

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

AABCD左旋一个字符得到ABCDA

AABCD左旋两个字符得到BCDAA

AABCD右旋一个字符得到DAABC

代码实现1

int is_left_move(char arr1[], char arr2[])
{
	int len = strlen(arr1);
	int i = 0;
	for (i = 0; i < len; i++)
	{
		char tmp = arr1[0];
		int j = 0;
		for (j = 0; j < len - 1; j++)
			arr1[j] = arr1[j + 1];
		arr1[len - 1] = tmp;
		if (strcmp(arr1, arr2) == 0)
			return 1;
	}
	return 0;
}

代码实现2

int is_left_move(char arr1[], char arr2[])
{
	//strcat strstr strncat
	int len1 = strlen(arr1);
	int len2 = strlen(arr2);
	if (len1 != len2)
		return 0;
	strncat(arr1, arr1, len1);
	char* ret = strstr(arr1, arr2);
	if (ret == NULL)
		return 0;
	else
		return 1;
}

main函数

//写一个函数，判断一个字符串是否为另外一个字符串旋转之后的字串
int main()
{
	char arr1[] = "ABCDEF";
    //char arr1[20] = "ABCDEF";//注实现代码2的实现前提是arr1空间需要足够大
    char arr2[] = "CDEFAB";
	int ret = is_left_move(arr1, arr2);//判断arr2是否是arr1旋转得到的
	if (1 == ret)
		printf("Yes\n");
	else
		printf("No\n");
	return 0;
}

``c
//写一个函数，判断一个字符串是否为另外一个字符串旋转之后的字串
int main()
{
char arr1[] = “ABCDEF”;
//char arr1[20] = “ABCDEF”;//注实现代码2的实现前提是arr1空间需要足够大
char arr2[] = “CDEFAB”;
int ret = is_left_move(arr1, arr2);//判断arr2是否是arr1旋转得到的
if (1 == ret)
printf(“Yes\n”);
else
printf(“No\n”);
return 0;
}