第一周 指针

最新推荐文章于 2023-04-26 19:03:20 发布
最新推荐文章于 2023-04-26 19:03:20 发布
阅读量2.6k 收藏 41
点赞数 11
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55913730/article/details/118941831
版权

1.程序要求：实现对5个数（a[0]～a[4]，数组元素从键盘读入）进行从大到小起泡法排序。输入第一组数据：1 2 3 4 5；输入第二组数据：3 5 4 1 2；验证程序的正确性。

#include <stdio.h>
int main()
{
int a[5],i,j,temp;
for(i=0;i<5;i++)
scanf("%d",&a[i]);
for(i=0;i<5-1;i++)
{
for(j=0;j<5-1-i;j++)
{
if(a[j]<a[j+1])
{
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}

}
}
for(i=0;i<5;i++)
printf("%d ",a[i]);
printf("\n");
return 0;
}

2.程序要求：实现三阶方阵转置，并打印转置后的方阵。

测试主函数为：

int main()

{

 int a[3][3]={1,2,3,4,5,6,7,8,9};

...//实现三阶方阵a的转置，并打印出来

return 0;}

5.用指针（首地址偏移法）实现将存放在数组中的一组数据按逆序重排，并打印重排后的数组。

测试主函数为：

#define N 7

int main( )

{int a[N]={1, 2, 3, 4, 11, 12, 13};

...

return 0;

}

#include <stdio.h>
#define N 7
int main()
{
    int a[N]={1,2,3,4,11,12,13},i,temp;
    for(i=0;i<N/2;i++)
    {
        temp=*(a+i);
        *(a+i)=*(a+N-i-1);
        *(a+N-i-1)=temp;
    }
    for(i=0;i<N;i++)
    printf("%d ",*(a+i));
    printf("\n");
    return 0;
}

6.用指针移动法实现将存放在数组中的一组数据按逆序重排，并打印重排后的数组。

测试主函数为：

#define N 7

int main( )

{int a[N]={1, 2, 3, 4, 11, 12, 13};

...

return 0;

}

#include <stdio.h>
#define N 7
int main()
{
    int a[N]={1,2,3,4,11,12,13},temp;
    int *i=a,*j=a+N-1;
    for(;i<a+N/2;i++,j--)
    {
        temp=*i;
        *i=*j;
        *j=temp;
    }
    for(i=a;i<=a+N-1;i++)
    printf("%d ",*i);
    printf("\n");
    return 0;
}

7.用元素指针实现输出二维数组中的全部元素。

测试主函数为：

int main( ) 

{ int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23}; 

...

  return 0;} 

自己理解：元素指针就是例如&a[0][0],某一个元素的指针;行指针就是例如&a[0],某一行的指针;

#include <stdio.h>
#define N 7
int main() 
{
    int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23}; 
    int *p=a[0];
    for(;p<a[0]+12;p++)
    printf("%d ",*p);
    printf("\n");
    return 0;
}

8.用行指针实现输出二维数组中的全部元素。

测试主函数为：

int main( ) 

{ int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23}; 

...

  return 0;} 

#include <stdio.h>
#define N 7
int main() 
{
    int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23}; 
    int (*p)[4];
    p=a;
    for(int i=0;i<3;i++)
    {
        for(int j=0;j<4;j++)
        printf("%d ",(*(p+i))[j]);//也可以写成*(*(p+i)+j)
    }
    printf("\n");
}

9.程序功能：fac函数通过指针返回n！，主函数定义指针，调用fac函数，打印结果。分别用两种方法实现fac，程序要求如下：

1）定义fac为有返回值函数，结果通过return语句返回主函数；

2）定义fac为无返回值函数，结果通过指针间接访问法访问主函数中的变量。

测试主函数为：

void main( )

{ int m;

  float k;

  printf("input m:");

  scanf("%d",&m);

  ...fac(...);//要求fac函数实现k=m!

  printf("result=%f",k);

}

1）

#include <stdio.h>
#define N 7
int fac(int m)
{
    if(m==1)
    return 1;//函数的递归必须有边界条件，这样才不会一直递归下去，也就是函数递归才会终止
    m=m*fac(m-1);
    return m;
}
void main( )
{
    int m;
    float k;
    printf("input m:");
    scanf("%d",&m);
    k=fac(m);//要求fac函数实现k=m!
    printf("result=%f",k);
    printf("\n");
}

2）自己的理解：想要通过调用函数来改变主函数中变量的值，可以通过传递主函数中变量的指针来实现。

在求阶乘时，如果调用的函数没有返回值，则此时不用函数的递归来求，而是用最简单的循环来求。

#include <stdio.h>
#define N 7
void fac(int *p,float *q)
{
    int i=*p;
    *q=1;
    for(;i>=1;i--)
    {
        *q=*q*i;
    }
}
void main( )
{ 
    int m;
    float k;
    printf("input m:");
    scanf("%d",&m);
    int *p=&m;
    float *q=&k;
    fac(p,q);//要求fac函数实现k=m!
    printf("result=%f",k);
    printf("\n");
}

10.编写函数strcat，实现两个字符串的连接，返回值为连接后字符串的首地址。

测试主函数为：

void main()

{    char str1[30] = "I learn ", *str2 = "C language.";

      char *s;

      s = strcat(str1,str2);//strcat函数的返回值是指针      printf("%s\n", s);  }

#include <stdio.h>
#define N 7
char *strcat(char *str1,char *str2)
{
    char *p=str1;
    for(;;p++)
    {
        if(*p=='\0')
        for(;*str2!='\0';p++,str2++)
        *p=*str2;
        if(*str2=='\0')
        break;
    }
    return str1;
}
void main()
{   
    char str1[30]="I learn ",*str2="C language.";
    char *s;
    s=strcat(str1,str2);//strcat函数的返回值是指针     
    printf("%s\n",s);  
}

11.一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为“Start”）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。问总共有多少条不同的路径？

示例 :

输入: m = 3, n = 2

输出: 3

解释:

从左上角开始，总共有 3 条路径可以到达右下角。

1. 向右 -> 向右 -> 向下

2. 向右 -> 向下 -> 向右

3. 向下 -> 向右 -> 向右

测试主函数：

int uniquePaths(int m, int n) {

...//补充函数，返回路径数

}

int main(){

int m=3,n=2;

int k=uniquePaths(m,n);

printf("共有%d条路径",k);

return 0;

}

#include <stdio.h>
int uniquePaths(int m, int n)
{
    if (m == 0 || n == 0)
        return 0;
    else if ((m == 2 && n == 1) || (m == 1 && n == 2))
        return 1;
    else
        return uniquePaths(m - 1, n) + uniquePaths(m, n - 1);
}
int main()
{
    int m = 4, n = 3;
    int k = uniquePaths(m, n);
    printf("共有%d条路径", k);
    printf("\n");
    return 0;
}

自己的理解：​​​​​​​函数的递归，要有返回值，并且要有递归出口。（递归出口可以直接是return返回以结束递归。）

12.一个机器人位于一个 m x n 网格的左上角，机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角。现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

网格中的障碍物和空位置分别用 1 和 0 来表示。

说明：m 和 n 的值均不超过 100。

示例 1:

输入:

[

  [0,0,0],

  [0,1,0],

  [0,0,0]

]

输出: 2

解释:

3x3 网格的正中间有一个障碍物。

从左上角到右下角一共有 2 条不同的路径：

1. 向右 -> 向右 -> 向下 -> 向下

2. 向下 -> 向下 -> 向右 -> 向右

参考答案：

int uniquePathsWithObstacles(int* obstacleGrid, int obstacleGridRowSize, int obstacleGridColSize){

...//补充函数，返回路径数 

}

int main(){

int a[3][3]={0,0,0,0,1,0,0,0,0};

int k=uniquePathsWithObstacles(a[0],3,3);

printf("共有%d条路径",k);

return 0;

}

#include <stdio.h>
int Pathnumber(int *p, int m, int n)
{
    int q[m][n]; //新建一个二维数组，用这个二维数组来存放每到达一个地方，一共可以有的路径数
    q[0][0] = 1;
    //下面来看到达二维数组中每一步可以有的路径数，那么数组的最后一个元素（也就是终点的路径数就是我们要求的路径数
    for (int i = 0; i < m; i++)
        for (int j = 0; j < n; j++)
        {
            if (i == 0 && j == 0)
                continue; //第0行第0列（也就是我们的起点，到达他的路径数为1，所以就不再进行别的循环，直接continue，否则会进入后面的if
            else if (*(p + i * n + j) == 1)
                q[i][j] = 0; //原数组元素为1，也就是有障碍物，则能到达它的路径数为0
            else if (i == 0)
                q[i][j] = q[i][j - 1]; //第0行除了第0列以外的元素，都和它前面那个元素的路径数相同
            else if (j == 0)
                q[i][j] = q[i - 1][j]; //第0列除了第0行
            else
                q[i][j] = q[i - 1][j] + q[i][j - 1]; //不是第0行也不是第0列也不是障碍的点，到达它的路径数为前面和上面路径数的和
        }
    return q[m - 1][n - 1];
}
int main()
{
    int a[3][3] = {0, 0, 0, 0, 1, 0, 0, 0, 0};
    int k = Pathnumber(a[0], 3, 3);
    printf("共有%d条路径", k);
    printf("\n");
    return 0;
}

13.给定一个 n × n 的二维矩阵表示一个图像，将图像顺时针旋转 90 度。

说明：

你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要使用另一个矩阵来旋转图像。

示例 1:

给定 matrix = 

[

  [1,2,3],

  [4,5,6],

  [7,8,9]

],

原地旋转输入矩阵，使其变为:

[

  [7,4,1],

  [8,5,2],

  [9,6,3]

]

参考答案：

void rotate(int* matrix, int matrixRowSize, int matrixColSize){

...//补充函数，实现原地旋转功能

}

int main(){

int a[3][3]={1,2,3,4,5,6,7,8,9};

rotate(a[0],3,3);

  

int *p; 

for(p=a[0];p<a[0]+9;p++) 

    { 

if((p-a[0])%3==0) printf("\n"); 

printf("%4d",*p); 

     } 

return 0;

}

#include <stdio.h>
void rotate(int *p, int m, int n) //整体思路：先上下颠倒，再转置
{
    int temp;
    for (int i = 0; i < m / 2; i++)
        for (int j = 0; j < n; j++)
        {
            temp = *(p + i * n + j);
            *(p + i * n + j) = *(p + (m - 1 - i) * n + j);
            *(p + (m - 1 - i) * n + j) = temp;
        }//上下颠倒
    for (int i = 0; i < m; i++)
        for (int j = 0; j <= i; j++)
        {
            temp = *(p + n * i + j);
            *(p + n * i + j) = *(p + n * j + i);
            *(p + n * j + i) = temp;
        }//转置
}
int main()
{
    int a[3][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
    rotate(a[0], 3, 3);
    int(*p)[3];
    for (p = a; p < a + 3; p++)
    {
        for (int j = 0; j < 3; j++)
            printf("%4d", (*p)[j]);
        printf("\n");
    }
    return 0;
}

14.给定一个包含 m x n 个元素的矩阵（m 行, n 列），请按照顺时针螺旋顺序，返回矩阵中的所有元素。

示例:

输入:

[

 [ 1, 2, 3 ],

 [ 4, 5, 6 ],

 [ 7, 8, 9 ]

]

输出: [1,2,3,6,9,8,7,4,5]

参考答案：

int* spiralOrder(int* matrix, int matrixRowSize, int matrixColSize){

...//补充函数，返回结果（一维数组）的首元素指针

}

int main(){

int a[3][3]={1,2,3,4,5,6,7,8,9};

int matrixRowSize=3,matrixColSize=3;

int *returnnum=spiralOrder(a[0], matrixRowSize, matrixColSize);

int *p;

for(p=returnnum;p<returnnum+9;p++) 

    { 

printf("%4d",*p); 

     } 

return 0;

}

//给定一个包含 m x n 个元素的矩阵（m 行, n 列），请按照顺时针螺旋顺序，返回矩阵中的所有元素。

#include <stdio.h>

int res[100];
int *spiralOrder(int* matrix, int matrixRowSize, int matrixColSize)
{
    ;
    int cl=0,rl=0,ch=matrixColSize-1,rh=matrixRowSize-1, count=0;
    int i;

    while(1)
    {
        for(i=cl; i<=ch; i++)res[count++] = *(matrix+rl*matrixColSize+i);//从左往右
        if(++rl > rh) break; //若超出边界，退出
        for(i=rl; i<=rh; i++) res[count++] = *(matrix+i*matrixColSize+ch);//从上往下
        if(--ch < cl) break;
        for(i=ch; i>=cl; i--) res[count++] = *(matrix+rh*matrixColSize+i);//从右往左
        if(--rh < rl) break;
        for(i=rh; i>=rl; i--) res[count++] = *(matrix+i*matrixColSize+cl);//从下往上
        if(++cl > ch) break;
    }

    int *q=res;

    return q;
}

int main()
{
    int a[3][3]= {1,2,3,4,5,6,7,8,9};
    int matrixRowSize=3,matrixColSize=3;
    int *returnnum=spiralOrder(a, matrixRowSize, matrixColSize);
	
	
	int *p;
	for(p=returnnum;p<returnnum+9;p++) 
    { 
		printf("%4d",*p); 
    } 



    return 0;
}

鱼条一
关注
  • 11
    点赞
  • 踩
  • 41
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
3阶矩阵转置
06-16
编写并测试3*3矩阵转置函数，使用数组保存3*3矩阵，在使用循环语句实现矩阵元素的行列对调，注意在循环语句中究竟需要对哪些元素进行操作。
学习笔记（23.4.11）指针基础学习
eihh23333的博客
04-11 89
当我们用int连续定义几个变量的时候他们的内存空间事实上是相邻的，但是使用new int(x)开辟的地址是存储在heap里面，也就是与之前的几个变量名存储的空间并不连续。内存的每个每个字节有一个自己的编号叫做地址，而相关的数据和代码会被储存在一段连续的内存内，因此我们可以通过访问首地址然后根据数据类型从而得到该数据的全部内容。//&i相当于是对i的一个引用，也可以看作是一种取地址的运算符，p存储了i的内存地址。//*p是对p存储内存地址的访问，*也可以看作一个运算符，用于对地址的访问。
厦大2021届大一小学期C语言作业1 数组+字符串+指针+位操作
Dys_debug的博客
08-18 6418
存一下
C语言地址偏移
Wu_Liu_Qi的博客
12-10 2356
C语言地址偏移
数组指针和偏移地址
So_discrepancy的博客
11-06 1795
C语言偏移地址
第一周算法总结1
08-08
在第一周的算法学习中，我们主要聚焦于基础的数据结构和解题策略。数据结构是算法的基石，它决定了如何高效地存储和处理数据。以下是本周学习的知识点概览： 1. **数据结构**：数据结构是用来组织和管理数据的方式...
第一周学习总结1
08-03
【第一周学习总结】 在第一周的学习中，我们聚焦了几个关键的编程概念和技术，主要集中在数组、链表以及算法优化。以下是对这些主题的详细解释： 1. 一维数组坐标变换： 数组是一种线性数据结构，用于存储同类型...
第一周
02-13
在“第一周”的学习主题中，我们主要关注的是Java编程语言的基础知识。Java是一种广泛使用的、面向对象的编程语言，由Sun Microsystems（现为Oracle公司）于1995年推出，它的设计目标是具有良好的可移植性、高效性和...
第四周实习内容1
08-08
第一个作业要求你编写一个函数，根据输入的n值是偶数还是奇数，计算相应的等差序列的和。第二个作业涉及结构体，你需要创建一个结构体来存储学生的学号、姓名和成绩，然后计算平均分和排名。最后一个作业要求从键盘...
第一周.dockkkkkkkk
02-28
在这个例子中，`bubsort`函数接收一个字符串指针数组和其长度，然后用两个嵌套循环实现排序。外层循环控制遍历的次数，内层循环负责比较和交换相邻元素。 - `strcmp()` 函数用于比较两个字符串。当`strcmp(str[i],...
用多种指针方法访问数据元素(数组)，实现逆序输出
Half-up的博客
02-16 930
C语言指针-用多种指针方法访问数据元素，实现逆序输出 总结有四种引用数组元素的方法 1. 数组名/下标法 a[i] 2. 数组名/偏移量 *(a+i) 3. 指针/偏移量 *(ptr+i) 4. 指针/下标法 ptr[i] / *ptr[i]
C++数组元素逆序排列
TianKelly的博客
08-10 4938
#include<iostream> using namespace std; int main() { //元素逆序排列，正好实现关于中心对称反转变换 int arr[5] = { 1,3,2,5,4 }; //其实元素下标位置 int start = 0; //末尾元素下标位置（数组长度）- 1 int end = (sizeof(arr) / sizeof(arr[0]) - 1); //这里注意最好记录一下数组真正的长度，因为后面对end进行加减操作后，end的数.
C语言基础入门——指针
浪漫的诗人博客
04-26 1912
内存区域中的每字节都对应一个编号，这个编号就是“地址”。如果程序中定义了一个变量，那么在对程序进行编译时，系统就会给这个变量分配内存单元。按变量地址存取变量值的方式称为直接访问，如printf(“%d”,i)；另一种存取变量值的方式称为间接访问，即变量i的地址存放到另一个变量中。指针变量是一种特殊的变量，它用来存放变量地址。基类型 * 指针变量名;指针与指针变量是两个概念，一个变量的地址称为该变量的“指针”。
c语言-指针
qq_47944751的博客
09-03 486
c语言——指针
C语言二级第7套试题
huanhuan59的博客
02-15 325
1. 题目 代码 #include &lt;stdlib.h&gt; #include &lt;stdio.h&gt; #define N 20 void fun( int *a) { int i, x, n=0; x=rand()%20;//x的随机值0~19 /**********found**********/ while (n&lt;N) { fo...
【C语言】函数的调用和参数说明
Mr_star_galaxy的博客
12-02 1148
本篇继续进行函数的讲解，代码均来自于VS环境下。
c语言——结构体偏移
e891377的专栏
05-18 4135
目录c语言——结构体偏移整数类型浮点类型例子结构体成员偏移量test01test02test03参考资料 c语言——结构体偏移 学习结构体偏移前，我们先复习一下c语言的数据类型 整数类型 下表列出了关于标准整数类型的存储大小和值范围的细节： 类型 存储大小 值范围 char 1 字节 -128 到 127 或 0 到 255 unsigned char 1 字节 0 到 255 signed char 1 字节 -128 到 127 int 2 或 4 字节 -32,768 到
C语言：模拟实现一个offsetof宏，计算结构体中某变量相对于起始地址的偏移
KamikazePilot的博客
03-05 874
offsetof定义： size_t offsetof( structName, memberName ); 这个宏实现传结构体类型，还有成员变量名，计算结果以size_t类型返回。 这里的实现本质上是直接将指针的偏移量强制转化成整形来计算。 首先需要知道的是：指针每偏移一位，跳过的是一个字节byte，即8bit。 那么计算偏移量，可以直接不计算结构体中每个成员的大小，内存分配等问题，直接计算指针偏移量就可以。 具体实现： 1、定义一个常量0。 2、将这个0强制类型转换位结构体指针类型(st
Python第二次学习之函数
Skyniliuershang的博客
11-12 1130
Python初学
大连理工大学c语言慕课第六周
最新发布
10-15
大连理工大学的C语言慕课第六周内容主要涵盖了指针和内存管理的相关知识。在这一周的学习中，我们首先对指针进行了详细的介绍和讲解。 指针是C语言中非常重要的概念之一，它可以用来存储变量的地址。通过指针，我们可以实现对变量的直接访问和操作，从而能够更加灵活地处理数据。在慕课中，我们学习了如何声明指针变量、如何使用指针进行内存地址的引用和解引用等基本操作。 在理解了指针的基本概念后，我们进一步学习了指针的高级应用，比如指针与数组之间的关系。通过指针与数组结合使用，我们能够实现更加高效的数组遍历和操作，减少了程序的运行时间和空间开销。 同时，慕课中还介绍了指针的指针和指针的数组的概念。这些概念的学习使得我们能够更加灵活地处理多维数组和多级指针的情况，拓宽了我们的编程思路和解决问题的能力。 与指针相关的知识点之一就是内存管理。在慕课中，我们学习了动态内存分配的相关函数，比如malloc、calloc和realloc等。这些函数使得我们能够在程序运行过程中动态地分配和释放内存空间，提高了程序的灵活性和效率。 在大连理工大学的C语言慕课第六周中，我们不仅学习了指针的基本概念和操作，还深入了解了指针的高级应用和内存管理的知识。通过学习这些内容，我们能够更加熟练地运用指针进行编程，提高程序的性能和效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值