C语言指针——练习

简介: C语言指针——练习

第一题.strlen函数的模拟实现


strlen函数用于计算字符串的长度,以下是一个模拟实现:


int strlen(char *str)
 {
    int len = 0;
    while (*str != '\0')
 {
        len++;
        str++;
 }
    return len;
}

该函数通过一个while循环来遍历字符串,每遍历一个字符,计数器len就加1。当遍历到字符串的结尾字符'\0'时,循环结束,函数返回计数器的值,即字符串的长度。


第二题 模拟实现strcpy


strcpy是C语言标准库中的函数,用于将字符串复制到另一个字符串中。


以下是模拟实现strcpy的代码:


char* strcpy(char* dest, const char* src) {
    char* p_dest = dest;
    while (*src != '\0') {
        *p_dest++ = *src++;
    }
    *p_dest = '\0'; // 添加字符串结尾符
    return dest;
}

strcpy的工作原理是遍历源字符串,逐个字符地复制到目标字符串中,遇到字符串结尾符\0时停止复制并在目标字符串末尾添加一个\0。在模拟实现中,使用指针p_dest指向目标字符串,每复制一个字符,就将指针后移一位;使用指针src指向源字符串,每读取一个字符,就将指针后移一位。最后返回指向目标字符串的指针dest。


第三题.模仿qsort的功能实现一个通用的冒泡排序


void swap(char* buf1, char* buf2, size_t size)
{
  int i = 0;
  for (i = 0; i < size; i++)
  {
    char tmp = *buf1;
    *buf1 = *buf2;
    *buf2 = tmp;
    buf1++;
    buf2++;
  }
}
void bubble_sort(void* base, size_t num, size_t size, int (*cmp)(const void* e1, const void*e2))
{
  //冒泡排序的趟数
  int i = 0;
  for (i = 0; i < num - 1; i++)
  {
    //一趟冒泡排序
    int j = 0;
    for (j = 0; j < num - 1 - i; j++)
    {
    
      if(cmp((char*)base + j * size, (char*)base + (j + 1) * size)<0)
      {
        //交换
        swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
      }
    }
  }
}

第四题.实现一个函数,可以左旋字符串中的k个字符。


例如:ABCD左旋一个字符得到BCDA


          ABCD左旋两个字符得到CDAB


设计循环使其可以旋1次,然后让他执行n次是一个最简单的思路:


void leftRound(char * src, int time)
{
  int i, j, tmp;
  int len = strlen(src);
  time %= len; //长度为5的情况下,旋转6、11、16...次相当于1次,7、12、17...次相当于2次,以此类推。
  for (i = 0; i < time; i++) //执行k次的单次平移
  {
    tmp = src[0];
    for(j = 0; j < len - 1; j++) //单次平移
    {
      src[j] = src[j + 1];
    }
    src[j] = tmp;
  }
}

改进一:


这个思路当然可以,但是一次一次转毕竟太麻烦,就不能一次到位么?


当然可以,我们可以选择拼接法,一次到位:


void leftRound(char * src, int time)
{
  int len = strlen(src);
  int pos = time % len; //断开位置的下标
  char tmp[256] = { 0 }; //更准确的话可以选择malloc len + 1个字节的空间来做这个tmp
  
  strcpy(tmp, src + pos); //先将后面的全部拷过来
  strncat(tmp, src, pos); //然后将前面几个接上
  strcpy(src, tmp); //最后拷回去
}

改进二:


这个方法要用到一个数组形成的辅助空间,让人觉得有点不爽,还可以有更好的选择,例如ABCDEFG,左旋3次后变成DEFGABC,有一个特殊的操作方式:


先将要左旋的前三个家伙逆序(CBADEFG),然后将后半段也逆序(CBAGFED),最后整体逆序(DEFGABC)即可。这样只需要做数值交换即可,可以写一个函数帮我们完成局部逆序,代码如下:


void reverse_part(char *str, int start, int end) //将字符串从start到end这一段逆序
{
  int i, j;
  char tmp;
 
  for (i = start, j = end; i < j; i++, j--)
  {
    tmp = str[i];
    str[i] = str[j];
    str[j] = tmp;
  }
}
 
void leftRound(char * src, int time)
{
  int len = strlen(src);
  int pos = time % len;
  reverse_part(src, 0, pos - 1); //逆序前段
  reverse_part(src, pos, len - 1); //逆序后段
  reverse_part(src, 0, len - 1); //整体逆序
}

第五题.写一个函数,判断一个字符串是否为另外一个字符串旋转之后的字符串。


例如:给定s1 =AABCD和s2 = BCDAA,返回1


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


AABCD左旋一个字符得到ABCDA


AABCD左旋两个字符得到BCDAA


AABCD右旋一个字符得到DAABC


解析:


本题当然可以将所有旋转后的结果放到一个数组里,然后进行查找,但是这种做法既不好操作,也太费事,但是这题有一个很简单的做法:


其实ABCDE无论怎么旋,旋转后的所有结果,都包含在了ABCDEABCD这个字符串里了。


所以做法很简单,只需要将原字符串再来一遍接在后面,然后找一找待查找的字符串是不是两倍原字符串的子集即可。


int findRound(const char * src, char * find)
{
  char tmp[256] = { 0 }; //用一个辅助空间将原字符串做成两倍原字符串
  strcpy(tmp, src); //先拷贝一遍
  strcat(tmp, src); //再连接一遍
  return strstr(tmp, find) != NULL; //看看找不找得到
}

方法二


int is_left_move(char* str1, char* str2)
{
  int len1 = strlen(str1);
  int len2 = strlen(str2);
  if (len1 != len2)
    return 0;
 
  strncat(str1, str1, len1);
  if (strstr(str1, str2) == NULL)
    return 0;
  else
    return 1;
}
 
int main()
{
  char arr1[20] = "abcdef";//abcdefabcdef
  //bcdefa
  //cdefab
  //defabc
  //efabcd
  //fabcde
  //abcdef
  char arr2[] = "cdef";
 
  int ret = is_left_move(arr1, arr2);//判断arr2是否是arr1旋转所得
 
  if (ret == 1)
    printf("Yes\n");
  else
    printf("No\n");
 
  return 0;
}

第六题.杨氏矩阵


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


要求:时间复杂度小于O(N);


#include <stdio.h>
 
int findnum(int a[][3], int x, int y, int f) //第一个参数的类型需要调整
{
  int i = 0, j = y - 1; //从右上角开始遍历
  while (j >= 0 && i < x)
  {
    if (a[i][j] < f) //比我大就向下
    {
      i++;
    }
    else if (a[i][j] > f) //比我小就向左
    {
      j--;
    }
    else
    {
      return 1;
    }
  }
  return 0;
}
 
int main()
{
  int a[][3] = { {1, 3, 5},
          {3, 5, 7}, 
          {5, 7, 9} }; //一个示例
 
  if (findnum(a, 3, 3, 2))
  {
    printf("It has been found!\n");
  }
  else
  {
    printf("It hasn't been found!\n");
  }
 
  return 0;
}

方法二,可返回所求值的坐标


int Find(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;
    }
  }
  *px = -1;
  *py = -1;
  return 0;
}
 
int main()
{
  int arr[3][3] = { 1,2,3, 4,5,6, 7,8,9 };
  int k = 0;
  int x = 3;
  int y = 3;
  scanf("%d", &k);//7
  int ret = Find(arr, &x, &y, k);//存在返回1,如果不存在返回0
  if (ret == 1)
  {
    printf("Yes\n");
    printf("%d %d\n", x, y);
  }
  else
  {
    printf("No\n");
    printf("%d %d\n", x, y);
  }
    
 
  return 0;
}

第七题.下面程序的结果是:( )


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

B.10, 5

C.10, 1

D.1, 5


&aa的类型是int (*)[2][5],加一操作会导致跳转一个int [2][5]的长度,直接跑到刚好越界的位置。减一以后回到最后一个位置1处。*(aa + 1)相当于aa[1],也就是第二行的首地址,自然是5的位置。减一以后由于多维数组空间的连续性,会回到上一行末尾的6处。故选A。


第八题.模拟实现了二维数组


方法一.静态开辟

 
int main()
{
  int arr1[] = { 1,2,3,4,5 };
  int arr2[] = { 2,3,4,5,6 };
  int arr3[] = { 3,4,5,6,7 };
 
  int* arr[3] = {arr1, arr2, arr3};
 
  int i = 0;
  for (i = 0; i < 3; i++)
  {
    int j = 0;
    for (j = 0; j < 5; j++)
    {
      //printf("%d ", *(arr[i] + j));
      printf("%d ", arr[i][j]);
    }
    printf("\n");
  }
  return 0;
}

方法二.动态开辟

#include <stdlib.h>
//
int main()
{
  int **arr = (int**)malloc(3*sizeof(int*));
  int i = 0;
  for (i = 0; i < 3; i++)
  {
  *(arr + i) = (int*)malloc(5*sizeof(int));
  }
  //初始化
  for (i = 0; i < 3; i++)
  {
  int j = 0;
  for (j = 0; j < 5; j++)
  {
    arr[i][j] = 1;
  }
  }
  //打印
  for (i = 0; i < 3; i++)
  {
  int j = 0;
  for (j = 0; j < 5; j++)
  {
    printf("%d ", arr[i][j]);
  }
  printf("\n");
  }
  //释放
  for (i = 0; i < 3; i++)
  {
  free(arr[i]);
  }
  free(arr);
  arr = NULL;
  return 0;
}

第六题.


/int main()
//{
//  int a[5] = { 1, 2, 3, 4, 5 };
//  int* ptr = (int*)(&a + 1);
//  printf("%d, %d", *(a + 1), *(ptr - 1));
//
//  return 0;
//}

image.png

第七题


//由于还没学习结构体,这里告知结构体的大小是20个字节
//X86 环境下演示
struct Test
{
  int Num;
  char* pcName;
  short sDate;
  char cha[2];
  short sBa[4];
} * p;
//假设p 的值为0x100000。 如下表表达式的值分别为多少?
//已知,结构体Test类型的变量大小是20个字节
//0x开头的数字是16进制的数字
int main()
{
  p = (struct Test*)0x100000;
  printf("%p\n", p + 0x1);
  printf("%p\n", (unsigned long)p + 0x1);
  printf("%p\n", (unsigned int*)p + 0x1);
 
  return 0;
}

image.png

image.png

第八题


#include <stdio.h>
int main()
{
  int a[3][2] = { (0, 1), (2, 3), (4, 5) };
  int* p;
  p = a[0];
  printf("%d", p[0]);//?
  return 0;
}
 

int a[3][2] = { (0, 1), (2, 3), (4, 5) };//实际初始化为1 3 5,为逗号表达式取两者中的最大值

image.png

第九题



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;
}

image.png

第十题


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

image.png

第十一题


#include <stdio.h>
//阿里的笔试题
int main()
{
  char* a[] = { "work","at","alibaba" };
  char** pa = a;
  pa++;
  printf("%s\n", *pa);
  return 0;
}
 

  image.png

第十二题


int main()
{
  char* c[] = { "ENTER","NEW","POINT","FIRST" };
  char** cp[] = { c + 3,c + 2,c + 1,c };
  char*** cpp = cp;
 
  printf("%s\n", **++cpp);
  printf("%s\n", *-- * ++cpp + 3);
  printf("%s\n", *cpp[-2] + 3);
  printf("%s\n", cpp[-1][-1] + 1);
  return 0;
}
相关文章
|
4天前
|
算法 Java 程序员
面向对象编程(OOP)通过对象组合构建软件,C语言虽是过程式语言,但可通过结构体、函数指针模拟OOP特性
【6月更文挑战第15天】面向对象编程(OOP)通过对象组合构建软件,C语言虽是过程式语言,但可通过结构体、函数指针模拟OOP特性。封装可使用结构体封装数据和方法,如模拟矩形对象。继承则通过结构体嵌套实现静态继承。多态可通过函数指针模拟,但C不支持虚函数表,实现复杂。C语言能体现OOP思想,但不如C++、Java等语言原生支持。
22 7
|
4天前
|
C语言
【C语言基础】:深入理解指针(终篇)
【C语言基础】:深入理解指针(终篇)
|
4天前
|
存储 C语言 C++
【C语言基础】:深入理解指针(三)
【C语言基础】:深入理解指针(三)
|
4天前
|
安全 程序员 编译器
【C语言基础】:深入理解指针(二)
【C语言基础】:深入理解指针(二)
【C语言基础】:深入理解指针(二)
|
4天前
|
存储 编译器 C语言
【C语言基础】:深入理解指针(一)
【C语言基础】:深入理解指针(一)
|
5天前
|
C语言
C语言的灵魂---指针(进阶)
C语言的灵魂---指针(进阶)
|
5天前
|
C语言
|
5天前
|
存储 C语言
C语言的灵魂---指针(基础)
C语言的灵魂---指针(基础)
|
13天前
|
存储 C语言
C语言学习记录——7000+字长文-复习&学习指针(指针、地址、指针变量、指针与数组、指针与函数、指针数组、多级指针)二
C语言学习记录——7000+字长文-复习&学习指针(指针、地址、指针变量、指针与数组、指针与函数、指针数组、多级指针)二
13 1
|
1月前
|
C语言
C语言---指针进阶
C语言---指针进阶
25 0