后面的we打错了，可以无视_(:3⌒ﾟ)_

ch[i]的话是字符型，然后放在a[ch[i]]就不对了，改成a[ch[i]-'0']

一般flag是标志变量，用来控制循环，或者是控制变量的正负号的，这个要结合实际需求。

例如：求解：1-2+3-4+5-...+49-50的值：

int sum=0;
int flag=1;
for(int i=1;i<=50;i++){
    i*=flag;
    sum+=i;
    flag*=-1;
}
printf("1-2+3-4+5-...+49-50=%d\n",sum);

#include <stdio.h>
//int gongli;
double taxi(int gongli=12)
{
    double money;
    if (gongli<=3)
    {
        money=13+1;
        printf("小于3公里时的费用为%.2lf元\n",money);
    }
    else 
    {
        money=13+1+2.3*(gongli-3); 
        printf("大于3公里时的费用为%.2lf元\n",money);
    }
    return money;
}    
int main()
{
    // scanf("%lf",&gongli);
    printf("打车总费用为%.2lf元\n",taxi());
    return 0;
}

你的函数定义有问题

'||'或运算是只要有一个为真，那么结果就是真，当执行完++X之后，x的值是4,4是真，所以就不会往后边运算了，因为结果已经是真了。如果把或运算符改成‘与’运算符，那么此处结果就是x=4,y=4，因为‘与’运算符是，两个都为真，结果才是真

http://www.imooc.com/learn/249入门

如图所示，返回指针数据。

学习C语言吧，赵岩老师《C缺陷与点滴》特别好，既幽默，又有深度，适合入门和深学。

printf("平均分：%.2f\n",ping);//double数据%lf格式输出

 temp=score[j];
 score[j]=score[j+1];
 score[j+1]=score[j];//冒泡排序的问题，交换两个数-->score[j+1]=temp;

max=0,min=0//这两个数据的初值应该赋值为score[0]

ping=total/10;//整数/整数结果还是整数，会损失精度，ping=total/10.0;

呵呵，哈哈哈哈哈。逗。

随便一本C语言的教材后面都会有附录。

同样可以去下载C语言API

下载地址：C语言API（函数大全）下载地址

int a=1,b=2; 声明了两个变量a被赋值为1，b被赋值为2.这两个变量是全局变量，具有文件作用域。fun1()这个函数的变量a,b时重新声明的，与第二行的a,b可以说没有任何联系，即在做fun1()函数定义时，括号里面可以是（int c, int d),结果一样。fun2()这个函数的作用就是永久的修改了变量a,b的值。

                    使用线性表的链式存储结构实现
#include <stdio.h>
#include <stdlib.h>

typedef struct LNode{
	int data;			//链表数据
	struct LNode* next;		//链表指针
}LNode,*LinkList;

/*头插法-建立单链表*/
LinkList HeadCreate(LinkList la)
{
	int num;
	la=(LinkList)malloc(sizeof(LNode));	//建立头结点
	la->next=NULL;
	scanf("%d",&num);
	while(num!=10)
	{
		LNode *p=(LinkList)malloc(sizeof(LNode));
		p->data=num;
		p->next=la->next;
		la->next=p;
		scanf("%d",&num);
	}
	return la;
}

/*尾插法-建立单链表*/
LinkList TailCreate(LinkList la)
{
	int num;
	la=(LinkList)malloc(sizeof(LNode));
	la->next=NULL;
	LinkList s,r=la;
	scanf("%d",&num);
	while(num!=10)
	{
		s=(LinkList)malloc(sizeof(LNode));
		s->data=num;
		r->next=s;
		r=s;
		scanf("%d",num);
	}
	r->next=NULL;
	return la;
}

/*单链表遍历*/
void TravelList(LinkList la)
{
	LinkList p=la->next;
	while(p!=NULL)
	{
		printf("%d->",p->data);
		p=p->next;
	}
	printf("\n");
}

/*单链表的按位查找*/
LinkList GetElem(LinkList la,int i)
{
	int j=1;
	LNode* p=la->next;
	if(i<1)
		return NULL;
	while(p && j<i)
	{
		p=p->next;
		j++;
	}
	return p;
}

/*单链表的按值查找*/
LinkList LocalElem(LinkList la,int e)
{
	LNode* p=la->next;
	while(p!=NULL && p->data!=e)
		p=p->next;
	return p;
}

/*单链表插入操作*/
bool InsertList(LinkList la,int i,int e)
{
	//在la链表中的i位置插入数值e
	int j=1;
	LinkList p=la,s;
	while(p && j<i)
	{
		p=p->next;
		j++;
	}
	if(p==NULL)
		return false;
	if((s=(LinkList)malloc(sizeof(LNode)))==NULL)
		return false;
	s->data=e;
	s->next=p->next;
	p->next=s;
	return true;
}

/*单链表删除操作*/
bool DeleteList(LinkList la,int i)
{
	int j=1;
	LinkList p=la,q;
	while(p && j<i)		                //p指向第i-1个元素
	{
		p=p->next;
		j++;
	}
	if(p==NULL || p->next==NULL)	//表示不存在第i-1个和第i的元素
		return false;
	q=p->next;
	p->next=q->next;
	free(q);
	return true;
}

/*单链表的表长*/
int LengthList(LinkList la)
{
	int nLen=0;
	LinkList p=la->next;
	while(p)
	{
		p=p->next;
		nLen++;
	}
	return nLen;
}

/*单链表逆置*/
LinkList Reserve(LinkList la)
{
	if(la==NULL || la->next==NULL)
		return la;
	LinkList p=la->next,q=p->next,r=q->next;
	la->next=NULL;
	p->next=NULL;
	while(r!=NULL)
	{
		q->next=p;
		p=q;
		q=r;
		r=r->next;
	}
	q->next=p;
	la->next=q;
	return la;
}

int main()
{
	LNode la;
	LinkList p;
	p=HeadCreate(&la);			//头插法创建单链表
	TravelList(p);
	printf("%p\n",GetElem(p,1));	        //获得第1个结点地址
	InsertList(p,2,10);			//在链表的第2个位置插入元素10
	TravelList(p);
	DeleteList(p,3);			//删除链表的第3个元素
	TravelList(p);
	printf("%d\n",LengthList(p));	        //获得链表长度
	p=Reserve(p);
	TravelList(p);
	return 0;
}

//运行结果
//5 6 12 7 8 14 9 3 2 5 14 10			        头插法创建链表
//14->5->2->3->9->14->8->7->12->6->5->			显示链表
//00382490					        第一个结点的地址
//14->10->5->2->3->9->14->8->7->12->6->5->		插入元素值为10的结点
//14->10->2->3->9->14->8->7->12->6->5->			删除第三个结点
//11							获得链表长度
//5->6->12->7->8->14->9->3->2->10->14->			链表逆置
//Press any key to continue

二、使用线性表的顺序存储结构实现
#include<stdio.h>

#define MaxSize 50
struct SqList{
	int data[MaxSize];	//存放顺序表的元素
	int length;		//存放顺序表的长度
};

/*顺序表的插入操作*/
bool InsertList(SqList&L,int i,int e)
{
	//在顺序表中第i个位置插入数值e
	int j;
	if(i<1 || i>L.length)
		return false;
	if(L.length>MaxSize)
		return false;
	for(j=L.length;j>=i;j--)	     //将第i个起得数据后移
		L.data[j]=L.data[j-1];
	L.data[j]=e;
	L.length++;
	return true;
}

/*顺序表的删除*/
bool DeleteList(SqList&L,int i)
{
	//删除顺序表中第i个元素
	int j;
	if(i<1 || i>L.length)
		return false;
	for(j=i;j<L.length;j++)
		L.data[j-1]=L.data[j];
	L.length--;
	return true;
}

/*顺序表的按值查找*/
int LocateElem(SqList&L,int e)
{
	for(int i=0;i<L.length;i++)
		if(L.data[i]==e)
			return i+1;
	return 0;
}

/*顺序表的输出*/
void OutPutList(SqList&L)
{
	for(int i=0;i<L.length;i++)
		printf("%d ",L.data[i]);
	printf("\n");
}

int main()
{
	SqList list;
	int A[5]={1,4,7,2,10};
	/*初始化顺序表*/
	for(int i=0;i<5;i++)
		list.data[i]=A[i];
	list.length=5;
	OutPutList(list);
	InsertList(list,3,12);
	OutPutList(list);
	DeleteList(list,3);
	OutPutList(list);
	printf("%d\n",LocateElem(list,10));
	return 0;
}

我觉得，所有常见语言的documentation都是英文，这中文页面实在是不好做啊。
再加上翻译过来的doc极其不精确，很多专业词汇翻译不准确，倒不如干脆用英文，连带着这种tutorial也都直接看英文了。
甚至我觉得，这个专业在一开始学习的时候就应该是英文教学，这样后期看doc会非常省力且准确且keep updated ： ）

C++更好一些吧

递归用法首先要假设你的程序已经能实现相应的功能

所以int number = getPeachNumber(1);//传入实参1，得到第一天桃子的数量

递归的实现条件：如果一个问题可以分成几个小问题，其中一个小问题和原来的问题本质上一样

递归的编写一般步骤：

1. 编写语句描述问题的分解步骤（假设递归函数已经完成）

2. 在递归函数的开头编写分支处理无法分解的情况
   

上例中第n天的桃子数量其实就是第（n+1）天桃子数量+1然后*2的结果

不管哪一天都可以分解成这种情况

然后分解到第10天就无法分解了，因为第10天只有1个桃子

这样说不知道你能清楚吗？

c语言程序设计现代方法比较好，望采纳。