C语言--指针练习

---

一、字符串逆序

#include<stdio.h>
void reverse(char* a)
{
	assert(a);
	int len = my_strlen(a);
	int left = 0;
	int right = len - 1;
	char tmp;
	while (left < right)
	{
		tmp = a[left];
		a[left] = a[right];
		a[right] = tmp;
		left++;
		right--;
	}
}

int my_strlen(char* a)
{
	int count = 0;
	while (*a != '\0')
	{
		count++;
		a++;
	}
	return count;
}

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

二、打印菱形

#include<stdio.h>
int main()
{
	int line = 0;
	int i = 0;
	int j = 0;
	scanf("%d", &line);
	for (i = 0; i < line; i++)
	{
		for (j = 0; j < line - i - 1; j++)
		{
			printf(" ");
		}
		for (j = 0; j < 2*i + 1; j++)
		{
			printf("*");
		}
		printf("\n");
	}
	for (i = 0; i < line - 1; i++)
	{
		for (j = 0; j < i + 1; j++)
		{
			printf(" ");
		}
		for (j = 0; j < 2*(line-i-1)-1; j++)
		{
			printf("*");
		}
		printf("\n");
	}
	return 0;
}
//   *
//  ***
// *****
//*******
// *****
//  ***
//   *

三、数组与指针

1.程序的结果是什么

int main()
{
	int a[5] = {1,2,3,4,5};
	int* ptr = (int*)(&a + 1);
	(&a+1)是整个数组的地址，它的类型是数组指针类型，不能存到整型指针类型内
	(int*)把(&a+1)强制类型转换为整型指针类型
	printf("%d,%d",*(a + 1),*(ptr-1));
	2 5
	ptr代表首元素地址-1得到a[4]的地址
	return 0;
}

2.程序的结果是什么

由于还没学习结构体，这里告知结构体的大小是20个字节
struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}*p;		结构体指针
假设p的值为0x00100000，如下表表达式的值分别是多少
int main()
{
	printf("%p\n",p + 0x1);
p是结构体的指针，结构体由20个字节
整个结构体的地址+1即+20个字节
	printf("%p\n",(unsigned long)p + 0x1);
0x00100001
	printf("%p\n",(unsigned int*)p + 0x1);
把结构体指针p强制类型转化为无符号整型指针，4个字节
0x00100004
	return 0;
}

3.程序的结果是什么

int main()
{
	int a[4] = {1,2,3,4};
	int* ptr1 = (int *)(&a + 1);
	int* ptr2 = (int *)((int)a + 1;
	printf("%x,%x",ptr1[-1],*ptr2);
	return 0;
}
&a是整个元素的地址，相当于指针，&a+1运用到指针+-整数，移动一个数组的距离
(int*)强制转换类型，把数组指针转换为整型指针
ptr1[-1]等价于 *(ptr1 - 1)

a是数组首元素地址，(int)a强制类型转换，把地址转换为整型，(int)a+1相当于整数+1
(int*) ((int)a+1)		强制类型转换为整型指针，相较于原来的地址，移动了一个字节
答案是 4    2000000

4.程序的结果是什么

int main()
{
	int a[5][5];
	int(*p)[4];
	p = a;
	printf("%p,%d\n",  &p[4][2] - &a[4][2],&p[4][2] - &a[4][2]);
	return 0;
}
&a[4][2]是第五行第三个元素的地址
int(*p)[4]是一个存放四个元素的数组指针
p = a，二维数组的数组名代表一维数组地址即首行地址，共由5个元素
而p只能存放4个元素，将首行地址强行赋给p，p是包含4个元素的地址
p[4]等价于*(p+4)，p存放的是整个数组的地址，向后移动4个数组的距离
[p[4][2]等价于*( *(p+4)+2),*(p+4)代表一个元素，再加2，代表这个元素的地址+2
指针+-指针表示两个指针之间的元素。

5.程序的结果是什么

int main()
{
	int aa[2][5] = {1,2,3,4,5,6,7,8,9,10};
	int *ptr1 = (int *)(&aa +1);
&aa是整个二维数组的地址 +1即跳过这个二维数组
(int*)将这个数组指针强制类型转换为整型指针
	int *ptr2 = (int *)(*(aa + 1);
aa是一维数组的数组即首行数组的地址 +1即跳过这个数组到下一个数组即第二行
数组名代表首元素的地址，(*(aa+1))即解引用首元素的地址，6
	printf("%d,%d",*(ptr1 - 1),*(ptr2 -1));
*(ptr1-1)的结果是10
*(ptr2 - 1)的结果是5
	return 0;
} 	

四、字符串与指针

int main()
{
	char* a[ ] = {"work","at","alibaba"};
	常量字符串指针存储的是首元素的地址
	char* p = "abcdef"存储的是a的地址
	char* [ ]代表类型	指针数组
	a是数组，存储的是w a a的地址
	a是数组名代表首元素地址
	char* *pa = a;
	char*代表类型，*pa代表指针，二级指针，a代表首元素地址
	pa++;
	a内存储的每一个类型都是char*，关于指针+-整数，涉及到移动的字节
	这里++即跳到下一个char*类型即at
	printf("%s\n",*pa);
	return 0;
}
打印结果为at

int main()
{
	char* c[ ] = {"ENTER","NEW","POINT:,"FIRST"};
char* [ ]是指针数组，存放指针的数组，字符串存放的是第一个字符的地址
	char**cp[] = {c+3,c+2,c+1,c};
c代表首元素地址"ENTER"的地址，char*类型
char**是元素类型，存放char* c+3，c+2，c+1，c的地址
	char* **cpp = cp;
cp是char* *类型的的数组名，cp是首元素地址
char* **是三级指针，cp是char**类型的的数组名
	printf("%s\n",**++cpp);
cpp+1得到cp的第二个元素的地址
*(cpp+1)拿到c+2
*(c+2)拿到c的第三个元素POINT
	printf("%s\n",*--*++cpp+3);
	printf("%s\n",*cpp[-2]+3);
	printf("%s\n",cpp[-1][-1]+1);
	return 0;
}	

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

1.暴力破解法

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<assert.h>
void left_move(char* a, int k)
{
	int len = strlen(a);
	int right = len - 1;
	int left = 0;
	int i = 0;
	int j = 0;
	for (i = 0; i < k; i++)
	{
		char tmp = a[left];
		for (j = 0; j < len-1; j++)
		{
			a[j] = a[j + 1];
		}
		a[right] = tmp;
	}
}

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

2.三步反转法
先反转前k个，再反转后k个，在进行整体的翻转

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<assert.h>
void reverse(char* left,char* right)
{
	while (left < right)
	{
		char tmp = *left;
		*left = *right;
		*right = tmp;
		left++;
		right--;
	}
}

int main()
{
	char arr[] = "abcdef";
	int len = strlen(arr);
	int k = 2;
	reverse(arr, arr + k - 1);
	reverse(arr + k, arr + len - 1);
	reverse(arr, arr + len - 1);
	printf("%s\n", arr);
	return 0;
}

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

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<assert.h>
void reverse(char* left,char* right)
{
	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);
	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 len = strlen(arr1);
	int i = 0;
	for (i = 0; i < len; i++)
	{
		left_move(arr1, 1);
		int ret = strcmp(arr1, arr2);
		if (ret == 0)
			return 1;
	}
	return 0;
}

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "cdefab";
	int ret = is_left_move(arr1, arr2);
	if (ret == 1)
		printf("相同");
	else
		printf("不同");
	return 0;
}

7.杨氏矩阵中寻找一个数是否存在

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
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
		{
			*row = x;
			*col = 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;
	int y = 3;
	int ret = Findnum(arr, k, &x, &y);
	if (ret == 1)
		printf("找到了,下标是%d %d\n", x, y);
	else
		printf("找不到\n");
	return 0;
}