排序部分
1.对10个数进行排序
//选择排序法
//可以利用选择法,即从后9个比较过程中,选择一个最小的与第一个元素交换, 下次类推,即用第二个元素与后8个进行比较,并进行交换。
#include <stdio.h>
int main(void)
{
int min,n=10,a[10] = { 0 };
int temp;
for (int i = 0; i < n; i++)
{
scanf_s("%d", &a[i]);
}
for (int i = 0; i < n - 1; i++)
{
min = i;
for (int j = i + 1; j < n; j++)
{
if (a[j] < a[min])
{
min=j;
}
}
if (min != i)
{
temp = a[i];
a[i] = a[min];
a[min] = temp;
}
}
for (int i = 0; i < n; i++)
{
printf("%-2d", a[i]);
}
}
题目:将一个数组逆序输出。
程序分析:用第一个与最后一个交换
//题目:将一个数组逆序输出。
//程序分析:用第一个与最后一个交换
#include <stdio.h>
void main(void)
{
int temp;
int a[10] = {0,1,2,3,4,5,6,7,8,9};
for (int i = 0; i < 5; i++)
{
temp = a[i];
a[i] = a[9-i];
a[9 - i] = temp;
}
for (int i=0;i<10;i++)
{
printf("%-2d", a[i]);
}
}
有2个排序过的数组A,B的长度分别为 N1, N2, 用C++代码实现只用N1+N2次循环找出2个数组中相等的值
#include <stdio.h>
int main(void)
{
int a1[5] = {1,4,7,9,40};
int a2[5] = {5,7,9,10,50};
int len1 = sizeof(a1) / sizeof(a1[0]); //strlen(a1[5]) sizeof是一个运算符
int len2 = sizeof(a2) / sizeof(a2[0]); //strlen(a2[5]) strlen是一个函数头文件为string
int num = 0; //要计算长度的字符串起始地址,只能是char*类型,。
int j = 0; //其他类型传入会被强制类型转换为(char*)
for (int i=0;i<len1;)
{
if (a1[i] == a2[j])
{
printf("%-2d",a1[i]);
i++;
j++;
if (j == len2)
break;
}
else if (a1[i] < a2[j])
{
i++;
if (i == len1)
break;
}
else
{
j++;
if (j == len2)
break;
}
}
return 0;
}
计算一个int类型数据里含有多少个bit 1,尽量使用较快的方式:
#include <stdio.h>
int main()
{
int num;
scanf_s("%d", &num);
int count = 0;
while (num)
{
if (num&1)
{
count++;
}
num = num >> 1; //末尾补0
}
printf("%d", count);
}
实现把字符串转换为整数函数,,注意:无需调用其他函数;
#include <stdio.h>
int zhuanhua(char* p)
{
int a=0;
char i;
if (*p== '-' || *p== '+')
{
i = p[0];
p++;
}
while (*p != '\0')
{
if (*p < '9' && *p>'0')
{
a = (*p - '0') + a * 10;// '0'=48
p++;
}
else
p++;
}
if (i == '+')
{
return a;
}
if (i == '-')
{
return -a;
}
return a;
}
int main(void)
{
char a[10];
gets(a);
printf("%d",zhuanhua(a));
}
数列F0=1,F1=1,F2=2,...,Fn = Fn-1 + Fn-2,(n >= 2),实现函数int F(int n),返回数列Fn点的数值;
#include <stdio.h>
int F(int n)
{
int a = 0;
if (n == 0 || n == 1)
{
return 1;
}
else
return F(n - 1) + F(n - 2);
}
int main(void)
{
printf("%d", F(2));
}
完成下列函数
typedef struct node {
int data;
struct node *next;
} Node;
在链表第n个位置插入一个节点,并返回链表的头指针,Node * list_add(Node *List, int n,int value);
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
#pragma warning(disable : 4996)
//节点
typedef struct xxx
{
char data[20];
struct xxx* next; //地址域 保存下一个节点的地址
}NODE;
void printfs(NODE* p);
void frees(NODE* p);
NODE* list_add(NODE* List, int n, char* value)//List 原链表的首地址
{
NODE* New = malloc(sizeof(NODE));
if (New==NULL)
{
printf("表明空间申请失败\n");
return -1;
}
strcpy(New->data, value);
NODE* Temp = List;
if (n == 0)
{
New->next = List;;//将首节点的地址给到新节点的地址域
List=New;
}
else
{
for (int i = 0; i < n - 1; i++)//节点访问的偏移 偏移到前一个前一个节点(如果要插入在 2 3节点之间 当前就要偏移到节点1)
{
List = List->next;// p: 待插入位置的前一个节点(如果要插入在 2 3节点之间 当前p就是节点2的地址)
}
New->next = List->next;
List->next = New;
return Temp;//返回原地址
}
}
void printfs(NODE* p);
void frees(NODE* p);
int main(void)
{
//动态申请节点空间
NODE* p1 = (NODE*)malloc(sizeof(NODE));
NODE* p2 = (NODE*)malloc(sizeof(NODE));
NODE* p3 = (NODE*)malloc(sizeof(NODE));
//NODE* px = (NODE*)malloc(sizeof(NODE));
//------当前堆区中 有三个独立的节点 没有任何东西
if (p1 == NULL || p2 == NULL || p3 == NULL )
{
printf("表明空间申请失败\n");
return -1;
}
printf("表明空间申请成功\n");
//每个数据域进行复制
strcpy(p1->data, "包子");
strcpy(p2->data, "油条");
strcpy(p3->data, "豆浆");
//地址域
p1->next = p2;//节点1的地址域保存的是节点2的地址
p2->next = p3;//节点2的地址域保存的是节点3的地址
p3->next = NULL;
printfs(p1);
//frees(p1);
list_add(p1,2, "学不懂,根本学不懂");
printfs(p1);
frees(p1);
return 0;
}
//遍历输出
void printfs(NODE* p)
{
NODE* head = NULL;
for (head = p; head != NULL; head = head->next)
{
printf("商品的名称: %s\n", head->data);
}
}
//一次释放所有的节点 free()函数的参数是当前节点的地址
void frees(NODE* p)
{
NODE* head = NULL;
NODE* temp = NULL;
for (head = p; head != NULL; )
{
temp = head->next;//当释放之前先保存地址域中的数据
free(head);
head = temp;
}
}
图片在内存中存放是按一维数组存放的,先存放第一行,接着第一行的行尾再存放第二行,
以此类推;横轴为X坐标,垂直方向为Y坐标,如上图右图,大图的高为H,宽为W,左上角为起始点坐标为(0, 0),右下脚坐标为(W - 1,H - 1);现需要将小图(高为h,宽为w)内容拷贝至大图的(x,y)的起始的虚线矩形位置,假设每个像素只占一个字节;大图图像存储char* dest地址的内存里,小图图像存储在char* src地址内存里,所谓拷贝,就是内存中的像素值的赋值,如把src的起始像素拷贝到dest的起始像素,* dest = *src;void cpoyBitmap(int W,int H,int w,int h,int x, int y,char * dest,char * src);
#include <stdio.h>
void cpoyBitmap(int W,int H ,int w,int h,int x,int y,char* dest,char* src )
{
int x1 = x;
dest += (y * W) + x; //位置偏移到(x,y)上
for (int i = 0; i < w * h; i++) //小图像数字大小
{
*dest = *src;
x++;
dest++;
src++;
if (x == (x1 + w))//当到达像素w-1行上换下一行
{
x = x1;//复原 换下一行
y++;
dest += W - w;
}
}
}
- 有一个数组,里面存放着N个正整数,随机选取相邻两个数相乘后加1,替换掉之前的两个数,数组长度变为N-1,重复上述操作,直至数组长度变为1为止,如何保证最后得的那个数最大?
e.g. {1,2,3,4,5} => {1*2+1,3,4,5} => {3*3+1,4,5} => {10,4*5+1} => {10*21+1} => {211}
int getMaxResult(int* array, int N);
#include <stdio.h>
int* Buble_Sort(int* array, int N)
{
for (int i = 0; i < N - 1; i++)
{
for (int j = 0; j < N - 1 - i; j++)
{
if (array[j] > array[j + 1])
{
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
return array;
}
int getMaxResult(int* array, int N)
{
array = Buble_Sort(array, N);
for (int i = 1; i <= N - 1; i++)
{
array[0] = array[0] * array[1] + 1;
for (int j = 1; j <= N - 2; j++)
{
array[j] = array[j + 1];
}
Buble_Sort(array, N -i);
}
return array[0];
}
int main(void)
{
int array[] = { 1,2,3,4,5 };
int data = getMaxResult(array, 5);
printf("data=%d\n", data);
return 0;
}
完成下列函数,假设有int ramdom(int max)函数返回一个在[0, max)区间的随机数可供使用,请写一个函数将一个数组array[100]里的数打乱,array[100] = {0,1, 2, 3, ……, 98,99}
注意:时间复杂度最好是O(n),O(n^2)也可以
void Srand(int *array,int max)
{
int num;
for(int i=0;i<max;i++)
{
num=ramdom(max);
int temp = array[num];
array[num] = array[max-num-1];
array[max-1-num] = temp;
}
}
实现整型数组的冒泡排序
#include <stdio.h>
MaoPao(int *buff,int length) (冒泡法 :i<n-1 j<n-i-1)
{
for (int i = 0; i < length - 1; i++)
{
for (int j = 0; j < length - 1 - i; j++)
{
if (buff[j] < buff[j + 1])
{
buff[j] = buff[j] ^ buff[j + 1];
buff[j + 1] = buff[j] ^ buff[j + 1];
buff[j]= buff[j] ^ buff[j + 1];
}
}
}
}
int main(void)
{
int array[10] = { 2,4,6,1,3,7,8,10,9,5 };
int len = sizeof(array) / sizeof(array[0]);
MaoPao(array, len);
for (int i = 0; i < len; i++)
{
printf("%d ", array[i]);
}
return 0;
}
编写strcpy(strcmp)函数
#include <stdio.h>
char* mstrcpy(char* strDest, const char* strSrc)
{
while (*strSrc != '\0') //等价于while((*strDest++ = *strSrc++)!=‘\0’);
{
*strDest = *strSrc;
strDest++;
strSrc++;
}
return strDest;
}
int main(void)
{
char buff[] = "hello";
char buff1[10] = { 0 };
mstrcpy(buff1, buff);
printf("buff1=%s\n", buff1);
return 0;
}
编写指针函数:从键盘输入一个字符串,去掉其中重复的字符(12分)
eg:
字符串:helloworld
去掉重复字符:helowrd
//编写函数:从键盘输入一个字符串,去掉其中重复的字符
#include <stdio.h>
void del_string(char* p)
{
for (int i = 0; *(p + i + 1) != '\0'; i++)//遍历数组 当i固定查找后面每个元素是否相同
{
for (int j = i + 1; *(p + j) != '\0'; j++) //每次对比一个直到数组末尾
{
if (*(p + i) == *(p + j))//相同贼把所有字符提前
{
//元素重复,后方字符前移
for (int k = j; *(p + k) != '\0'; k++)
{
*(p + k) = *(p + k + 1);//把第i+1个字符去掉 把所有字符提前1位
}
j--;
}
}
}
}
int main(void)
{
char a[] = "hellllorld";
del_string(a);
printf("%s\n", a);
return 0;
}
其他思路
为了去掉字符串中的重复字符,我们可以使用指针函数来实现。具体步骤如下:
- 定义一个指针函数,函数的返回值为char*,参数为char*类型的字符串。
- 定义两个指针p和q,分别指向字符串的首尾。
- 从字符串的首部开始遍历,对于每个字符,从字符串的尾部开始遍历,查找是否有重复的字符。
- 如果找到了重复的字符,就将该字符删除,并将字符串长度减1。
- 继续遍历字符串,直到p和q相遇为止。
- 返回处理后的字符串。
下面是一个示例代码:
char* removeDuplicate(char* str) {
char* p = str;
char* q = str + strlen(str) - 1;
while (p < q) { //同一个字符串才能这样比较大小
char* tmp = q;
while (tmp > p) {
if (*tmp == *p) {
char* t = tmp;
while (t < q) {
*t = *(t + 1);
t++;
}
*q = '\0';
q--;
}
tmp--;
}
p++;
}
return str;
}
int main(void)
{
char a[] = "hellllorld";
removeDuplicate(a);
printf("%s\n", a);
return 0;
}
2.一球从100米高度自由落下,每次落地后反跳回原高度的一半;再落下,求它在第10次落地时,共经过多少米?第10次反弹多高?(10分)
/*一球从100米高度自由落下,每次落地后反跳回原高度的一半;
再落下,求它在第10次落地时,共经过多少米?第10次反弹多高?
*/
#include <stdio.h>
//函数功能:计算每次反弹的高度
//函数参数:反弹次数
//函数返回值:反弹的高度
double Get_High(int n)
{
double data = 100;
for (int i = 0; i < n; i++)
{
data = data *0.5;
}
return data;
}
int main(void)
{
double high = 0;//经过的距离
high += Get_High(0);//第一次落地的距离
//第10次落地前, 反弹了9次
for (int i = 1; i < 10; i++)
{
high += 2 * Get_High(i);
}
printf("第10次落地经过的距离:%.2f\n", high);
printf("第10次反弹的高度:%.2f\n", Get_High(10));
}
3.将一个正整数分解质因数。例如:输入90,打印出90=2*3*3*5
//1.程序分析:用短除法求解。
//对n进行分解质因数,应先找到一个最小的质数i,然后按下述步骤完成:
//(1)如果这个质数恰等于n,则说明分解质因数的过程已经结束,n本身就是质数,打印出n即可。
//(2)如果n != i,但n能被i整除,则应打印出i的值,并用n除以i的商, 作为新的正整数n, 重复执行第一步。
//(3)如果n不能被i整除,则用i + 1作为i的值, 重复执行第一步。
int main(void)
{
int num;
scanf_s("%d/n",&num);
for (int i = 2; i < num; i++)
{
while ( num!=i )
{
if (num % i == 0)
{
printf("%d*", i);
num/= i;
}
else
break;
}
}
printf("%d",num);
}
用C语言输出9 * 9成法口诀。共9行9列,i控制行,j控制列。
void main(void)
{
for (int i = 1; i < 10; i++)
{
for (int j = 1; j <= i; j++)
{
printf(" %d*%d=%d ", i, j, i * j);
}
printf("\n");
}
}
//下面程序的功能是将一个4×4的数组进行逆时针旋转90度后输出,
//要求原始数组的数据随机输入,新数组以4行4列的方式输出,请在空白处完善程序
#include <stdio.h>
void main(void)
{
int p1[4][4];
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
scanf_s("%d",&p1[i][j]);
}
}
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
printf(" %d", p1[i][j]);
}
printf("\n");
}
printf("\n");
printf("\n");
printf("\n");
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
printf(" %d", p1[j][i]);
}
printf("\n");
}
//有一对兔子,从出生后第3个月起每个月都生一对兔子,
//小兔子长到第三个月后每个月又生一对兔子,假如兔子都不死,问每个月的兔子总数为多少?
int tuzi(int n)
{
int num;
if (n== 1 || n == 2)
return 1;
else
{
return tuzi(n - 2) + tuzi(n - 1);
}
}
void main(void)
{
printf("%d", tuzi(5));
}
//判断101 - 200之间有多少个素数,并输出所有素数及素数的个数。
//
//程序分析:判断素数的方法:用一个数分别去除2到sqrt(这个数),如果能被整除,则表明此数不是素数,反之是素数。
#include<math.h>
void main(void)
{
for (int i = 101; i < 201; i++)
{
int k = sqrt(i + 1);
for (int j = 2; j <=k; j++)
{
if (i % j == 0) //被整除
{
break;
}
if (j == k)
{
if (i % k != 0) //被整除
{
printf("%d是素数\n", i);
}
}
}
}
}