精华内容
下载资源
问答
  • 但是,在《K&R》中并没有定义一个完整的标准C语言,后来由美国国家标准学会在此基础上制定了一个C 语言标准,于一九八三年发表。通常称之为ANSI C。 当代最优秀的程序设计语言  早期的C语言主要是用于UNIX系统。...
  • 你必须知道的495个C语言问题

    千次下载 热门讨论 2015-05-08 11:09:25
    可我找不任何方法来声明这样的函数——感觉我需要一个返回指针的函数,返回的指针指向的又是返回指针的函数……,如此往复,以至无穷。 数组大小 1.23 能否声明和传入数组大小一致的局部数组,或者由其他参数...
  • C语言训练

    2016-12-10 23:02:32
    1.对于一个字符串,和字符串中的某一位置,请设计一个算法,将包括i位置在内的左侧部分移动右边,将右侧部分移动左边。 给定字符串A和它的长度n以及特定位置p,请返回旋转后的结果。 测试样例: ...
    
    1.对于一个字符串,和字符串中的某一位置,请设计一个算法,将包括i位置在内的左侧部分移动到右边,将右侧部分移动到左边。

    给定字符串A和它的长度n以及特定位置p,请返回旋转后的结果。

    测试样例:
    "ABCDEFGH",8,4
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    char *move(char *str,int len,int loc)
    {
    	int i;
    	int j;
    	char ch;
    	
    
    	if(len <= loc)
    	{
    		printf("error\n");
    		exit(-1);
    	}
    	else
    	{
    		for(i = 0; i < len - loc -1; i++)
    		{
    			ch = str[len - 1];
    
    			for(j = len - 1;j >= 1; j--)
    			{
    				str[j] = str[j - 1];
    			}
    
    			str[0] = ch;
    		}
    
    		return str;
    	}
    }
    
    int main()
    {
    	char str[20];
    	int n;
    
    	printf("input the string!\n");
    	scanf("%s",str);
    
    	printf("input the location!\n");
    	scanf("%d",&n);
    
    	printf("%s\n",move(str,strlen(str),n));
    
        return 0;
    }
    

    展开全文
  • 《你必须知道的495个C语言问题》

    热门讨论 2010-03-20 16:41:18
    可我找不任何方法来声明这样的函数——感觉我需要一个返回指针的函数,返回的指针指向的又是返回指针的函数……,如此往复,以至无穷。 12  数组大小 13 1.23 能否声明和传入数组大小一致的局部数组,或者由...
  • 可我找不任何方法来声明这样的函数——感觉我需要一个返回指针的函数,返回的指针指向的又是返回指针的函数……,如此往复,以至无穷。 12  数组大小 13 1.23 能否声明和传入数组大小一致的局部数组,或者由...
  • 函数-C语言

    2018-06-04 11:23:57
    程序的机构 ...程序依然是按照语句顺序顺序执行,当调用函数时,在调用位置将参数值传递给函数,之后从该函数的第句代码开始执行直到执行return语句或到达这函数体的结束括号,返回调用它的位置...

    程序的机构

    一般C程序由许多函数组成,其中最重要的是main函数,他是程序的起点;
    函数中可以调用任何函数,包括它本身;
    调用一个函数时,就是执行该函数体内的代码,这个函数执行结束后,就会回到调用该函数的地方.
    程序依然是按照语句顺序顺序执行,当调用某函数时,在调用位置参数值传递给函数,之后从该函数的第一句代码开始执行直到执行到return语句或到达这个函数体的结束括号,返回调用它的位置,执行该位置后的代码.
    这里写图片描述

    函数的定义:名称,参数,返回值

    这里写图片描述

    展开全文
  • 你必须知道的495个C语言问题(PDF)

    热门讨论 2009-09-15 10:25:47
    4.4 我有个函数,它应该接受并初始化一个指针void f(int *ip) f static int dummy = 5; ip = &dummy;g 但是当我如下调用时: int *ip; f(ip); 调用者的指针却没有任何变化。. . . . . . . . . . . . . . . 18 4.5 我...
  • 单向链表的C语言实现

    2017-10-29 10:46:00
    C语言的指针实现了单向链表中的几项基本操作:新建链表,置空链表,插入节点(由于在尾部加入新节点尤为常用,故单独用一个函数实现),删除节点。为了以上操作更便捷,另分别写了返回尾节点和特定节点的函数。...

    用C语言的指针实现了单向链表中的几项基本操作:新建链表,置空链表,插入节点(由于在尾部加入新节点尤为常用,故单独用一个函数实现),删除节点。为了以上操作更便捷,另分别写了返回尾节点和某特定节点的函数。
    为了统一插入及删除节点的操作,使其不因节点位置不同而受到影响(主要是插入或删除头节点),我在真正的表头(我称之为true_head)前加入一空节点作为表头。
    另外,在特定位置插入、删除节点时必须确保此位置是有效的。想法是:在表头中储存链表的长度,在特定位置插入、删除时,将此位置与长度比较大小,如果位置大于长度,则报错;如果位置小于长度,则执行操作并更新表头中的长度信息。长度信息的更新:新建时置为1,置空时重置为0,插入成功则加1,删除成功则减1。

    用结构体定义:

    1 typedef struct Node{
    2     int i;
    3     struct Node *next;
    4 }Node;

    新建链表:这是唯一一个需要返回头指针的函数。

     1 Node *MakeList(void)//创建带有空表头节点的列表并返回表头,其中表头储存的是链表的长度
     2 {
     3     Node *head = (Node *)malloc(sizeof(Node));
     4     Node *true_head = (Node *)malloc(sizeof(Node));
     5     printf("Please type in the element of the head node:");
     6     scanf("%d", &true_head->i);
     7     head->next = true_head;
     8     true_head->next = NULL;
     9     head->i = 1;
    10     return head;
    11 }

    置空链表:

    1 void MakeNull(Node *head)
    2 {
    3     head->next = NULL;
    4     head->i = 0;
    5 }

    插入节点:

     1 void Insert(Node *head, int i)//在特定位置插入节点
     2 {
     3     if(i > (head->i + 1))//注意:在i或者i+1位置都没有问题,在i+1位置相当于Append
     4     {
     5         printf("Insertion failed because i is too big!\n");
     6     }
     7     else
     8     {
     9         Node *temp = (Node *)malloc(sizeof(Node));
    10         printf("Please type in the element of the new node:");
    11         scanf("%d", &temp->i);
    12         Node *pre = GetNode(head, i-1);
    13         Node *aft = pre->next;//刚开始以为要把在表尾的插入单独拿出来讨论,但后来发现此时aft不就是NULL了嘛♪(´▽` )
    14         temp->next = aft;
    15         pre->next = temp;
    16         head->i++;
    17     }
     1 void Append(Node *head)//在链表尾部附加节点
     2 {
     3     Node *temp = (Node *)malloc(sizeof(Node));
     4     printf("Please type in the element of the new node:");
     5     scanf("%d", &temp->i);
     6     Node *pre = GetTail(head);
     7     pre->next = temp;
     8     temp->next = NULL;
     9     head->i++;
    10 }

    删除节点:

     1 void Remove(Node *head, int i)//删除特定节点
     2 {
     3     if(i > head->i)
     4     {
     5         printf("Removal failed because i is too big!\n");
     6     }
     7     else
     8     {
     9         Node *pre = GetNode(head, i-1);//同插入,尾节点也不需要拿出来
    10         Node *temp = pre->next;
    11         pre->next = temp->next;
    12         head->i--;
    13     }
    14 }

    其他的:

     1 Node *GetNode(Node *head, int i)//传入节点位置,并返回此节点
     2 {
     3     if(i > head->i)
     4     {
     5         printf("Failed to get node i because i is too big!\n");
     6         return NULL;
     7     }
     8     else
     9     {
    10         Node *temp = head;
    11         int k;
    12         for(k = 0; k < i; k++)
    13         {
    14             temp = temp->next;
    15         }
    16         return temp;
    17     }
    18 }
    19 
    20 Node *GetTail(Node *head)//返回链表尾节点,便于在链表尾插入新节点
    21 {
    22     Node *temp = head;
    23     while(NULL != temp->next)
    24     {
    25         temp = temp->next;
    26     }
    27     return temp;
    28 }
    29 
    30 void PrintList(Node *head)//按从表头到表尾的顺序打印链表
    31 {
    32     Node *temp = head->next;//从真表头开始打印
    33     if(NULL == temp)
    34     {
    35         printf("There is no element in the list!\n");
    36     }
    37     else
    38     {
    39         int k;
    40         for(k = 0; k < head->i; k++)
    41         {
    42             printf("%d\n", temp->i);
    43             temp = temp->next;
    44         }
    45     }
    46 }

    问题们:

    由于指针掌握不好,对于一些操作有些不知所以然;增加一个指针指向尾节点,就可以把GetTail替换掉,但是在进行插入删除操作时可能会增加额外的工作;希望增加通过元素返回节点位置的操作。

    转载于:https://www.cnblogs.com/bhep/p/7749514.html

    展开全文
  • 应该注意,数组指针变量向前或向后移动一个位置和地址加1或减1 在概念上是不同的。因为数组可以有不同的类型, 各种类型的数组元素所占的字节长度是不同的。如指针变量加1,即向后移动1 个位置表示指针变量指向下一...
  • c语言编写单片机技巧

    2009-04-19 12:15:17
    所以作为一个技术全面并涉足较大规模的软件系统开发的单片机开发人员最好能够掌握基本的C语言编程。 4. 当开发一个较复杂而又开发时间短的项目时,用C还是用汇编开发好? 答:对于复杂而开发时间紧的项目时,...
  • previous up contents next C 语言常见问题集 原著:Steve Summit 翻译:朱群英, 孙 云 修订版 0.9.4, 2005年6月23日... o 8.6 我有个函数, 本该返回一个字符串, 但当它返回调用者的时候, 返回串却是垃圾信息。 ...
  • C语言教程(谭浩强)

    2008-12-16 10:35:00
    9. Quit:退出Turbo C 2.0, 返回到DOS操作系统中, 其热键为Alt+X。 说明: 以上各项可用光标键移动色棒进行选择, 回车则执行。也可用每一项的第一个大写字母直接选择。若要退到主菜单或从它的下一级菜单列表框退回均...
  • 首先将s1与t1进行比较,若不同,就将s2与t1进行比较,...,直到s的某一个字符si和t1相同,再将它们之后的字符进行比较,若也相同,则如此继续往下比较,当s的某一个字符si与t的字符tj不同时,则s返回到本趟开始字符...
  • 否则就沿着原路返回,换一个方向再继续进行试探,直到所有可能的路径均被试探完。为了保证我们可以沿着原路返回(回溯),我们可以选用栈这个先入后出的数据结构来保存从入口当前位置的路径。 首先我们建立了这样...

    迷宫问题,顾名思义就是求出从入口到出口的路径。正常情况下,我们的想法都是采用“穷举求解”的方法,即从迷宫入口出发,顺着某一方向向前试探,若能走通则继续向前走;否则就沿着原路返回,换一个方向再继续进行试探,直到所有可能的路径均被试探完。为了保证我们可以沿着原路返回(回溯),我们可以选用栈这个先入后出的数据结构来保存从入口到当前位置的路径。
    首先我们建立了这样一个8*8的迷宫,为了在一会儿计算方位的时候更加便利,我们给迷宫外面加上了一个“外墙”,如下图所示,白色代表通路,黑色代表墙,题目要求我们的路径必须是简单路径即在所求得的路径上不能重复出现同一通道块。
    在这里插入图片描述

    为了表示迷宫,我们建立了一个二维数组mg,用0来表示通路,用1来表示墙,在迷宫中的每一个方块,其上下左右均有一个方块与之相邻,如下图所示,我们假设当前方块的位置为(i, j),规定其上方的方块的方位号为0,按照顺时针的递增顺序依次给其余三个方位的方位号进行编号。在试探的过程中,我们按照方位号从0到3进行查找下一个可走的方块的位置。
    在这里插入图片描述
    我们采用栈这个数据结构来进行方块的存储,自然要对栈进行相应的定义,其定义如下
    在这里插入图片描述
    用C语言的思路来求解迷宫问题(从(1,1)到(M,N)的路径)算法:先将入口位置的方块进栈(初始方块的位置设置为-1),在栈不空的时候进循环:读栈顶方块(不退栈),如果该方块是出口,则输出栈中的方块位置即为路径;否则就在相邻的方块中寻找下一个可走的方块,若不存在可走的方块,则退栈(即向后退一步);若存在这样的方块,则将其位置存在栈中,并将这个可走的相邻方块入栈(并将新方块的初始位置设置为1)。
    为了保证试探的可走的相邻方块不是已经走过的方块,我们可以在一个方块入栈后将其对应的迷宫数组(mg数组)元素改为-1(变为不可走的方块),在退栈时(当没有可以走的方块的时候)再将其恢复为0。例如方块(i, j)已经入栈,在试探(i +1 ,j)的时候,又会试探到(i, j),这样可能会引起死循环,采用上述方法之后就会避免这种情况发生。
    对应的具体实现如下:

    /*
    1表示对应通道是墙,0表示对应通道为通路 
    */
    #include<stdio.h>
    #define maxsize 10001		//栈的最大容量 
    #define M 8			//8行 
    #define N 8			//8列 
    
    struct 
    {
    	int i;				//当前方块的行号	
    	int j;				//当前方块的列号 
    	int di;				//下一个可走的方位的方位号 
    }st[maxsize];			//定义栈 
    int top = -1;			//初始化栈顶指针 
    
    int mg[M + 2][N + 2] = 		//为了计算方便,在最外边加了"外墙",即增加了两行两列 
    {
    	{1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
    	{1, 0, 0, 1, 0, 0, 0, 1, 0, 1},
    	{1, 0, 0, 1, 0, 0, 0, 1, 0, 1},
    	{1, 0, 0, 0, 0, 1, 1, 0, 0, 1},
    	{1, 0, 1, 1, 1, 0, 0, 0, 0, 1},
    	{1, 0, 0, 0, 1, 0, 0, 0, 0, 1},
    	{1, 0, 1, 0, 0, 0, 1, 0, 0, 1},
    	{1, 0, 1, 1, 1, 0, 1, 1, 0, 1},
    	{1, 1, 0, 0, 0, 0, 0, 0, 0, 1},
    	{1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
    }; 
    
    //路径为,入口(x1, y1),出口(x2, y2) 
    void mgpath(int x1, int y1, int x2, int y2)		
    {
    	int i, j, di, find, k;
    	top++;			//初始化方块进栈 
    	st[top].i = x1;		//行号 
    	st[top].j = y1;		//列号 
    	st[top].di = -1;	//下一块的方位 
    	mg[x1][y1] = -1;	//因为题目要求不能走已经走过的路线,因此将第一个变为不可再走的方块 
    	
    	while(top > -1)		//栈不空时,循环继续 
    	{
    		i = st[top].i;
    		j = st[top].j;
    		di = st[top].di;
    		if(i == x2 && j == y2)		//说明已经找到了出口,直接输出路径
    		{
    			puts("迷宫路径如下:");
    			for(k = 0;k <= top;k++)
    			{
    				printf("\t(%d, %d)", st[k].i, st[k].j);
    				if((k +1) % 5 == 0)				//输出的时候每5个方块后换行 
    				puts("");
    			}
    			puts("");
    			return;
    		}
    		find = 0; 
    		while(find == 0 && di < 4)			//寻找下一个可走的方块 
    		{
    			di++;
    			switch(di)
    			{
    				case 0:i = st[top].i - 1;j = st[top].j;break;		//向上走 
    				case 1:i = st[top].i;j = st[top].j + 1;break;		//向右走 
    				case 2:i = st[top].i + 1;j = st[top].j;break;		//向下走 
    				case 3:i = st[top].i;j = st[top].j - 1;break;		//向左走			
    			}
    			if(mg[i][j] == 0)		//如果找到了通路,就不用再进行上面的循环了 
    				find = 1;
    		}
    		if(find == 1)				//找到了下一个可走的方块 
    		{
    			st[top].di = di;		//修改之前栈顶元素中di的值 
    			top++;					//下一个可以走的方块进栈,栈顶指针上移 
    			st[top].i = i;
    			st[top].j = j;
    			st[top].di = -1;		//注意这里要修改di的值
    			mg[i][j] = -1;			//避免重复走该方块 
    		} 
    		else		//没有路径就退栈(回溯) 
    		{
    			mg[st[top].i][st[top].j] = 0;		//让该位置变为其他路径可走的方块 
    			top--;								//栈顶指针下移
    		}
    	}
    	puts("没有可走路径。");
    }
    
    int main()
    {
    	int x1, y1, x2, y2;
    	puts("请输入起点与终点坐标(中间以空格分开且不大于8)");
    	scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
    	mgpath(x1, y1, x2, y2);
    	return 0;
    }
    

    如果本题稍作改动,变为输出迷宫所有路径并求出最短路径及其长度。对比上面的解法,在成功的找到一条可以走下去的路径之后就会退出;那我们可以将路径保存到另一个栈path[]中,并定义变量minlen来保存最短路径长度。当 while循环结束的时候输出path[]中最短的路径。具体实现如下:

    #include<stdio.h>
    #define maxsize 10001		//栈的最大容量 
    #define M 8			//8行 
    #define N 8			//8列 
    
    struct 
    {
    	int i;				//当前方块的行号	
    	int j;				//当前方块的列号 
    	int di;				//下一个可走的方位的方位号 
    }st[maxsize], path[maxsize];			//定义栈 
    int top = -1;			//初始化栈顶指针 
    int count = 1;			//初始化计数器
    int minlen = maxsize;	//最短路径长度 
    
    int mg[M + 2][N + 2] = 		//为了计算方便,在最外边加了"外墙",即增加了两行两列 
    {
    	{1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
    	{1, 0, 0, 1, 0, 0, 0, 1, 0, 1},
    	{1, 0, 0, 1, 0, 0, 0, 1, 0, 1},
    	{1, 0, 0, 0, 0, 1, 1, 0, 0, 1},
    	{1, 0, 1, 1, 1, 0, 0, 0, 0, 1},
    	{1, 0, 0, 0, 1, 0, 0, 0, 0, 1},
    	{1, 0, 1, 0, 0, 0, 1, 0, 0, 1},
    	{1, 0, 1, 1, 1, 0, 1, 1, 0, 1},
    	{1, 1, 0, 0, 0, 0, 0, 0, 0, 1},
    	{1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
    }; 
    
    //路径为,入口(x1, y1),出口(x2, y2) 
    void mgpath(int x1, int y1, int x2, int y2)		
    {
    	int i, j, di, find, k;
    	top++;			//初始化方块进栈 
    	st[top].i = x1;		//行号 
    	st[top].j = y1;		//列号 
    	st[top].di = -1;	//下一块的方位 
    	mg[x1][y1] = -1;	//因为题目要求不能走已经走过的路线,因此将第一个变为不可再走的方块 
    	
    	while(top > -1)		//栈不空时,循环继续 
    	{
    		i = st[top].i;
    		j = st[top].j;
    		di = st[top].di;
    		if(i == x2 && j == y2)		//说明已经找到了出口,直接输出路径
    		{
    			printf("迷宫路径如下:  ");
    			printf("\t第%d条:\n",count++);
    			for(k = 0;k <= top;k++)
    			{
    				printf("\t(%d, %d)", st[k].i, st[k].j);
    				if((k +1) % 5 == 0)				//输出的时候每5个方块后换行 
    				puts("\t");
    			}
    			puts("");
    			if(top + 1 < minlen)
    			{ 
    				for(k = 0;k <= top;k++)
    					path[k] = st[k];		//当前栈中元素依次压入临时栈中
    				minlen = top + 1;			//栈顶指针对应 
    			}
    			mg[st[top].i][st[top].j] = 0;	//让该位置方块变为其他路径可走的方块
    			top--;
    			i = st[top].i;
    			j = st[top].j;
    			di = st[top].di; 
    		}
    		find = 0; 
    		while(find == 0 && di < 4)			//寻找下一个可走的方块 
    		{
    			di++;
    			switch(di)
    			{
    				case 0:i = st[top].i - 1;j = st[top].j;break;		//向上走 
    				case 1:i = st[top].i;j = st[top].j + 1;break;		//向右走 
    				case 2:i = st[top].i + 1;j = st[top].j;break;		//向下走 
    				case 3:i = st[top].i;j = st[top].j - 1;break;		//向左走			
    			}
    			if(mg[i][j] == 0)		//如果找到了通路,就不用再进行上面的循环了 
    				find = 1;
    		}
    		if(find == 1)				//找到了下一个可走的方块 
    		{
    			st[top].di = di;		//修改之前栈顶元素中di的值 
    			top++;					//下一个可以走的方块进栈,栈顶指针上移 
    			st[top].i = i;
    			st[top].j = j;
    			st[top].di = -1;		//注意这里要修改di的值
    			mg[i][j] = -1;			//避免重复走该方块 
    		} 
    		else		//没有路径就退栈(回溯) 
    		{
    			mg[st[top].i][st[top].j] = 0;		//让该位置变为其他路径可走的方块 
    			top--;								//栈顶指针下移
    		}
    	}
    	if(minlen == 10001 && st[top].i == 0 == st[top].j == 0)  //如果输出的元素均为0,则说明没有路径可走 
    		puts("没有路径可走");
    	else
    	{
    		printf("最短路径的长度为:  %d\n", minlen);
    		printf("最短路径为:\n");
    		for(k = 0;k < minlen;k++)
    		{
    			printf("\t(%d, %d)", path[k].i, path[k].j);
    			if((k + 1) % 5 == 0)
    				puts("\t");
    		}
    	}
    }
    
    int main()
    {
    	int x1, y1, x2, y2;
    	puts("请输入起点与终点坐标(中间以空格分开且不大于8)");
    	scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
    	mgpath(x1, y1, x2, y2);
    	return 0;
    }
    
    展开全文
  • 11.2.1 将一个结构作为另一个结构的成员 414 11.2.2 声明结构中的结构 415 11.2.3 将结构指针用作结构成员 416 11.2.4 双向链表 420 11.2.5 结构中的位字段 423 11.3 结构与函数 424 11.3.1 结构作为函数的变...
  • 同样,输入 一个端口 P2,即是将 P2.7、P2.6 至 P2.0,读入到一个字节的 8 第一节: 第一节:单数码管按键显示 单片机最小系统的硬件原理接线图: 1. 2. 3. 4. 接电源:VCC(PIN40)、GND(PIN20)。加接退耦电容 ...
  • 记录逆向家app

    2020-12-31 15:57:52
    在请求登录时,可以发送获取二维码的时候有一个请求 其中 _sign就是要破解的参数了 找到参数加密位置 直接进行搜索,可以定位这里 那么getInterfaceSign这个函数就是返回的sign值了,frida打印看一下 ...
  • 非局部指的是,这不是由普通C语言goto,语句在一个函数内实施的跳转,而是在栈上跳过若干调用帧,返回到当前函数调用路径上的某一个函数中。 #include Int setjmp(jmp_buf env); 返回值:若直接调用则返回0,若从...
  • 为了保证在任何位置上都能沿原路返回,需要用一个后进先出的顺序栈结构来保存从起点当前位置的路径。 迷宫如图所示(代码中也可以自己更改): (代码中'#'表示墙壁,‘ ’代表可以通过) 【算法思想】 假设...
  • 数据结构(7)—栈的应用之迷宫求解

    千次阅读 多人点赞 2016-02-21 01:23:23
    参考书籍:数据结构(C语言版)严蔚敏吴伟民编著清华大学出版社 ... 1.问题描述: 采用“穷举求解”方法,从入口出发,顺...为了保证在任何位置上都能沿原路返回,显然需要用一个后进先出的栈结构来保存从入口...
  • 为了保证在任何位置上都能沿原路返回,这就需要一个后进先出的结构来存储起位置,所以用到了栈的概念。 在问题的求解过程中,用到了对栈的定义、栈的初始化、栈的空间的申情、栈的销毁等有关栈的知识。 通过这次...
  • 数据结构实验

    2012-04-13 09:55:47
    一个人,即原来的第m+1个位置上的人,又从1开始报数,再是数m的人站出来。依次重复下去,直到全部的人都站出来,按出列的先后又可得到一个新的序列。由于该问题是由古罗马著名的史学家Josephus提出的问题演变而...

空空如也

空空如也

1 2 3
收藏数 52
精华内容 20
关键字:

c语言返回到某一个位置

c语言 订阅