四种数组交换方法、指针及swap函数实现方法

1. 将数组A中的内容和数组B中的内容进行交换。

方法一：运用数组元素间进行逻辑运算来实现交换

#include <stdio.h>
#include <stdlib.h>
int main(){
	int i,j,k;
	int A[10];
	int B[10];
	printf("请输入数组A的内容:");
	for(i=0;i<10;++i){
		scanf("%d",&A[i]);
	}
	printf("请输入数组B的内容:");
	for(j=0;j<10;++j){
		scanf("%d",&B[j]);
	}
	for(k=0;k<10;++k){
		A[k] = A[k] ^ B[k];
		B[k] = A[k] ^ B[k];
		A[k] = A[k] ^ B[k];
	}
	printf("交换后的数组A:");
	for(i=0;i<10;++i){
		printf("%d ",A[i]);
	}
	printf("\n");
	printf("交换后的数组B:");
	for(j=0;j<10;++j){
		printf("%d ",B[j]);
	}
	printf("\n");
	system("pause");
	return 0;
}	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

方法二：引用第三个数组进行数组交换

#include <stdio.h>
#include <stdlib.h>
int main(){
	int i,j,k;
	int A[10];
	int B[10];
	int C[10];
	printf("请输入数组A的内容:")
	for(i=0;i<10;++i){
		scanf("%d",&A[i]);
	}
	printf("请输入数组B的内容:");
	for(j=0;j<10;++j){
		scanf("%d",&B[j]);
	}
	for(k=0;k<10;++k){
		C[k] = A[k];
	}
	for(i=0;i<10;++i){
		A[i] = B[i];
	}
	for(j=0;j<10;++j){
		B[j] = C[j];
	}
	printf("交换后的数组A:");
	for(i=0;i<10;++i){
		printf("%d ",A[i]);
	}
	printf("\n");
	printf("交换后的数组B:");
	for(j=0;j<10;++j){
		printf("%d ",B[j]);
	}
	printf("\n");
	system("pause");
	return 0;
}		
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

方法三：引入第三个数组，再利用strcpy函数对数组进行交换

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(){
	char a[10];
	char b[10];
	char c[10];
	puts("请输入数组A的内容:\n");
	gets(a);
	puts("请输入数组B的内容:\n");
	gets(b);
	strcpy(c,a);
	strcpy(a,b);
	strcpy(b,c);
	puts("交换后数组A的内容:\n");
	puts(a);
	puts("交换后数组B的内容:\n");
	puts(b);
	printf("\n");
	system("pause");
	return 0;
}	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

方法四：利用swap函数进行交换

#include <stdio.h>
#include <stdlib.h>
void swap(int* a,int* b){     //定义了类型为int*的指针a,b，指针指向的类型为int
	int tmp = *a;     //将指针a所指向的地址中的内容赋值给tmp
	*a = *b;   //将指针b所指向的地址中的内容赋值给指针b所指向的地址中的内容
	*b = tmp;  
}
int main(){
	int i,j,k;
	int A[10];
	int B[10];
	printf("请输入数组A的内容:");
		for(i=0;i<10;++i){
			scanf("%d",&A[i]);
		}
	printf("请输入数组B的内容:");
		for(j=0;j<10;++j){
			scanf("%d",&B[j]);
		}
	for(k=0;k<10;++k){
		swap(&A[k],&B[k]);
	}
	printf("交换后的数组A:");
		for(i=0;i<10;++i){
			printf("%d ",A[i]);
		}
	printf("\n");
	printf("交换后的数组B:");
		for(j=0;j<10;++j){
			printf("%d ",B[j]);
		}
	printf("\n");
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

运行结果：

指针的类型和指针指向的类型，以下面的例子来说明：(*是间接访问符 /解引用 ，&取地址符）

1. int* p;
2. char* p;
3. int* *p;
4. int (*p)[3];
5. int* (*p)[3];
   从语法的角度看，你只要把指针声明语句里的指针名字去掉，剩下的部分就是这个指针的类型。这是指针本身所具有的类型。上述例子中指针的类型为：
6. int* ptr; //指针的类型是int*
7. char* ptr; //指针的类型是char*
8. int* ptr; //指针的类型是int*
9. int (ptr)[3]; //指针的类型是int()[3]
10. int* (ptr)[4];//指针的类型是int()[4]
    从语法上看，你只须把指针声明语句中的指针名字和名字左边的指针声明符去掉，剩下的就是指针所指向的类型。上述例子中指针指向的类型为：
11. int* ptr; //指针所指向的类型是int
12. char* ptr; //指针所指向的的类型是char
13. int* ptr; //指针所指向的的类型是int
14. int (*ptr)[3]; //指针所指向的的类型是int ()[3]
15. int* (ptr)[4]; //指针所指向的的类型是int ()[4]

利用swap函数交换时，一定要注意形参和实参的区别，这里很容易只交换了形参，而实参并未发生交换。swap函数的实现方式为：
void swap(int* a,int* b){ int tmp = *a; *a = *b; *b = tmp; }

2. 计算1/1-1/2+1/3-1/4+1/5 …… + 1/99 - 1/100 的值。

#include <stdio.h>
#include <stdlib.h>
int main(){
	int flag=1;
	float sum=0;
	for(float i = 1;i<101;++i){
		sum += flag/i;
		flag *= -1;  //定义一个变量来改变正负符号
	}
	printf("sum = %f\n",sum);
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

运行结果：

3. 编写程序数一下 1到 100 的所有整数中出现多少次数字9。

#include <stdio.h>
#include <stdlib.h>
int main(){
	int a;
	int count = 0;
	int count1 = 0;
	int count2 = 0;
	for(i=1;i<101;++i){
	int b = a / 10;  //求解数值a的十位
	int c = a % 10;  //求解数值a的个位
		if(b == 9){
			count1 ++;
			printf("%d\n",a);
		}
		if(a == 9){
			count2 ++;
			printf("%d\n",a);
		}
	}
	count = count1 + count2;
	printf("count=%d\n",count);
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

运行结果：