本文详细介绍了C语言中字符指针数组的理解，包括全局变量、静态变量、文件操作、字符串输出函数puts、数据结构如顺序表、二叉树等的应用。此外，还涵盖了C语言中各种运算符的优先级、文件定位、数组处理以及数据结构算法如哈希表、二叉树的遍历和操作。通过实例代码展示了如何在实际问题中运用这些概念和技巧。
知识积累与整理
字符指针数组理解！
#include<stdio.h>
int main()
{
char *c[4] = {"string0", "string1", "string2", "string3"};
char **p;
p = c;
int i;
for(i = 0; i < 4; i++)
{
printf("%s\n", *(p + i));
int j;
for(j = 0; j <7; j++)
{
printf("%c ", *(*(p + i) + j));
}
printf("\n");
}
return 0;
}
B
*s是指向字符串的指针，而**s是指向字符串指针的指针
C不解释太简单了
因为pc数组的元素本身都是一级指针又不是二级指针，不存在可以得到’a’这些元素的，故BD排除
对于AC我们可以这么理解，就是pc[0] = “aaa”，pc[1] = “bbb”，pc[2] = “ccc”，就相当于char *p1，*p2，*p3;p1 = “aaa”, p2 = “bbb”, p3 = "ccc"所以选C
全局变量与局部变量
全局变量也称为外部变量，也就是说是在函数外部定义的变量。它不属于哪一个函数，而是属于一个源程序文件。一般情况下其作用域是从定义处开始一直到整个源程序文件结束。
静态变量static
局部静态变量的初值为0（对整型变量）或空字符（对字符型变量）。
函数的隐含储存类型是extern,函数的形参或变量的储存类型为auto
C语言规定，只要在定义函数时不进行存储类型的显式说明，函数的存储类型就隐含为外部类型，即extern型，外部类型允许其他文件中的函数调用。
实际上函数的声明和定义都不需要添加extern关键字，在实际使用的时候也最好不要添加关键字。
如果一个函数是不会被其它文件调用的，那么这个函数应该被声明成static的。
自动类型转换
自动转换发生在不同数据类型运算时，在编译的时候自动完成。自动转换遵循的规则就好比小盒子可以放进大盒子里面一样，下图表示了类型自动转换的规则。
注：字节小的可以向字节大的自动转换，但字节大的不能向字节小的自动转换
赋值运算符和赋值表达式
使用赋值表达式要注意以下几个方面：
- ①赋值运算符不是数学中的“等于号”，而是进行“赋予”操作。如：a=5+3 应读作“先进行5+3运算，然后把运算结果赋给变量a”。
- ②赋值运算符的左边只能是变量，不能是常量或表达式，而赋值运算符的右边可以是常量或表达式。如：a+3=5，a+b=c等都是不合法的赋值表达式。
- ③赋值表达式x=y的作用是：将变量y所代表的存储单元中的内容赋给变量x所代表的存储单元，x中原有的数据被替换掉，而变量y所代表的存储单元中的内容不变。简单地说，就是把变量y的值赋给变量x，变量y的值不变，而变量x原有的值被y的值所替换。
- ④可以进行连续的赋值操作，但不可以进行连续的赋初值操作。a=b=5是合法的赋值表达式，由于赋值运算符的结合方向是自右向左，因此这个表达式等价于a=（b=5），即先将5赋给变量b，再把b的值赋给变量a。
- ⑤赋值表达式n=n+1的含义是：取出变量n中的值加1再放回到变量n中，即使变量n中的值增1。
- ⑥当赋值运算符两边的类型不一致时，要进行类型自动转换。
逗号表达式
“，”是C语言提供的一种特殊的运算符，称为逗号运算符。逗号运算符的结合性为从左到右。在所有运算符中，逗号运算符的优先级最低。
对于逗号表达式做以下几点说明：
- （1）逗号表达式的求解过程是：先求解表达式1，再求解表达式2。整个逗号表达式的值是表达式2的值。
- （2）逗号表达式在求解的过程中要注意各个运算符之间的优先级，逗号运算符的优先级最低。例如：
#include<stdio.h>
int main()
{
int a;
printf("%d\n", (a = 3 * 5, a * 4));
return 0;
}
赋值运算符的优先级别高于逗号运算符，因此应先求解a=3*5（也就是把“a=3*5”作为一个表达式）。经计算和赋值后得到a的值为15，然后求解a*4，得60，因此整个逗号表达式的值为60。
- （3）逗号表达式可以进行嵌套，即表达式1和表达式2本身也可以是逗号表达式。例如：
#include<stdio.h>
int main()
{
int a;
printf("%d\n", ((a = 12, a * 4), a + 5));
return 0;
}
运算符优先级
单目>算术>位移>关系>逻辑>条件>赋值
文件的打开
如果fopen()打开文件失败则返回空指针NULL
#include<stdio.h>
int main()
{
FILE *fp = fopen("test.txt", "r");
if(NULL == fp)
{
printf("can not open the file!\n");
}
else
{
printf("open success!\n");
}
return 0;
}
文件定位
移动文件内部位置指针的函数主要有两个，即 rewind 函数和fseek函数。
（1）rewind函数
（2）fseek函数
文件相关题目
fopen函数
【解释】执行fopen函数时，如果文件打开成功，则返回该文件结构体的指针，如果打开失败（例如，读打开时文件不存在，写打开时文件不能创建），则返回NULL（即0）。
故选择答案是B。
字符串输出函数puts
题目
1
灵活法（全排列）
#include<bits/stdc++.h>
using namespace std;
int book[4] = {0};
int a[4] = {1, 2, 3, 4};
int b[3] = {0};
int n = 3;
int cnt = 0;
void dfs(int step)
{
if(step == n)
{
for(int i = 0; i < 3; i++)
{
cout << b[i] << " ";
}
cout << endl;
cnt++;
return;
}
for(int i = 0; i < 4; i++)
{
if(book[i] == 0)
{
b[step] = a[i];
book[i] = 1;
dfs(step + 1);
book[i] = 0;
}
}
}
int main()
{
dfs(0);
cout << cnt << endl;
return 0;
}
中规中矩法（暴力法）
#include<bits/stdc++.h>
using namespace std;
int main()
{
int i, j, k;
int cnt = 0;
for(i = 1; i < 5; i++)
{
for(j = 1; j < 5; j++)
{
if(j != i)
{
for(k = 1; k < 5; k++)
{
if(k != i && k != j)
{
cout << i << j << k << endl;
cnt++;
}
}
}
}
}
cout << cnt << endl;
return 0;
}
运行结果：
2
2015年真题大题部分
C程序设计
1、
#include<stdio.h>
#define MAX_SIZE 6
int main()
{
int array[MAX_SIZE] = {10, 0, -1, 2, 3, 4};
int max = array[0];
int min = array[0];
for(int i = 0; i < MAX_SIZE; i++)
{
if(max < array[i])
{
max = array[i];
}
if(min > array[i])
{
min = array[i];
}
}
printf("max:%d min:%d\n", max, min);
return 0;
}
2、
#include<stdio.h>
#define MAX_SIZE 5
int main()
{
double array[MAX_SIZE] = {1.3, 3.1, 4.1, 5.2, 7};
double average = 0;
int i = 0;
double sum = 0;
for(int i = 0; i < MAX_SIZE; i++)
{
sum += array[i];
}
average = sum / MAX_SIZE;
printf("average:%lf\n", average);
return 0;
}
3、
#include<stdio.h>
/*
员工信息结构体
*/
typedef struct EmployeeInfo{
int id; /* 工号 */
char name[10];
float wage;
char position[20]; /* 职位 */
}EInfo;
typedef struct StatisticResult{
int indexLowestWage;
int indexHighestWage;
float avwage;
}SResult;
int getWageStatistic(EInfo *pinfo, int length, SResult *pres)
{
if(pinfo == NULL || pres == NULL)
{
return 0;
}
int indexHighestWage = 0;
int indexLowestWage = 0;
float sumWage = 0;
for(int i = 0; i < length; i++)
{
sumWage += pinfo[i].wage;
if(pinfo[indexHighestWage].wage < pinfo[i].wage)
{
indexHighestWage = i;
}
if(pinfo[indexLowestWage].wage > pinfo[i].wage)
{
indexLowestWage = i;
}
}
pres->avwage = sumWage / length;
pres->indexHighestWage = indexHighestWage;
pres->indexLowestWage = indexLowestWage;
return 1;
}
int printS(EInfo *pinfo, int length, float avwage)
{
if(pinfo == NULL)
{
return 0;
}
for(int i = 0; i < length; i++)
{
if(avwage < pinfo[i].wage)
{
printf("id:%d name:%s\n", pinfo[i].id, pinfo[i].name);
}
}
return 1;
}
int main()
{
EInfo info[6] = {
{1, "liming", 63000, "助理"},
{2, "lihua", 32000, "助理"},
{3, "liyi", 12000, "讲师"},
{4, "lile", 24000, "秘书"},
{5, "lihang", 35000, "顾问"},
{6, "lirui", 96000, "大佬"},
};
SResult sres = {0};
getWageStatistic(info, 6, &sres);
printf("LowestID:%d\n", info[sres.indexLowestWage].id);
printf("HighestID:%d\n", info[sres.indexHighestWage].id);
printS(info, 6, sres.avwage);
return 0;
}
数据结构算法题
1、
#include<stdio.h>
#include<stdlib.h>
#define Maxsize 100
typedef int ElemType;
typedef struct SqList{
ElemType *plist;
int length;
int listsize;
}SqList;
int CreateSqList(SqList *p)
{
ElemType *elem = (ElemType *)malloc(Maxsize * sizeof(ElemType));
if(!elem)
{
return 0;
}
p->plist = elem;
p->length = 0;
return 1; /*1表示初始成功，0表示初始失败*/
}
int oneSort(SqList *p, int left, int right)
{
int tmp = p->plist[left];
while(left < right)
{
while(left < right && p->plist[right] >= tmp)
{
right--;
}
p->plist[left] = p->plist[right];
while(left < right && p->plist[left] < tmp)
{
left++;
}
p->plist[right] = p->plist[left];
}
p->plist[left] = tmp;
return left;
}
int main()
{
SqList q;
CreateSqList(&q);
int n = 8;
int array[8] = {24, 6, 3, 9, 8, 1, 0, 33};
int i;
for(i = 0; i < 8; i++)
{
q.plist[i] = array[i];
}
q.length = n;
oneSort(&q, 0, 7);
for(i = 0; i < 8; i++)
{
printf("%5d", q.plist[i]);
}
printf("\n");
return 0;
}
这么写也可以，就是没有写创建顺序表函数，而是直接在主函数将plist指向数组首地址
#include<stdio.h>
#include<stdlib.h>
#define Maxsize 100
typedef int ElemType;
typedef struct SqList{
ElemType *plist;
int length;
int listsize;
}SqList;
int oneSort(SqList *p, int left, int right)
{
int tmp = p->plist[left];
while(left < right)
{
while(left < right && p->plist[right] >= tmp)
{
right--;
}
p->plist[left] = p->plist[right];
while(left < right && p->plist[left] < tmp)
{
left++;
}
p->plist[right] = p->plist[left];
}
p->plist[left] = tmp;
return left;
}
int main()
{
SqList q;
int n = 8;
int array[8] = {24, 6, 3, 9, 8, 1, 0, 33};
int i;
q.plist = array;
q.length = n;
oneSort(&q, 0, 7);
for(i = 0; i < 8; i++)
{
printf("%5d", q.plist[i]);
}
printf("\n");
return 0;
}
2、
#include<stdio.h>
#include<stdlib.h>
typedef char ElemType;
typedef struct BiTNode{
char data;
struct BiTNode *lchild, *rchild;
struct BiTNode *parent;
}BiTNode, *Bitree;
void CreateBitree(Bitree *bt)
{
char ch;
scanf("%c", &ch);
if(ch == '#')
{
*bt = NULL;
}
else
{
*bt = (Bitree)malloc(sizeof(BiTNode));
(*bt)->data = ch;
CreateBitree(&(*bt)->lchild);
CreateBitree(&(*bt)->rchild);
}
}
void preorder(Bitree bt)
{
if(bt == NULL)
{
return;
}
printf("%c ", bt->data);
preorder(bt->lchild);
preorder(bt->rchild);
}
void inorder(Bitree bt)
{
if(bt == NULL)
{
return;
}
inorder(bt->lchild);
printf("%c ", bt->data);
inorder(bt->rchild);
}
void postorder(Bitree bt)
{
if(bt == NULL)
{
return;
}
postorder(bt->lchild);
postorder(bt->rchild);
printf("%c ", bt->data);
}
void preTravelTree(Bitree t, ElemType x, BiTNode *parent)
{
if(t != NULL)
{
t->parent = parent;
if(t->data == x)
{
BiTNode *ancesterNode = t->parent;
while(ancesterNode != NULL)
{
printf("%c ->", ancesterNode->data);
ancesterNode = ancesterNode->parent;
}
}
preTravelTree(t->lchild, x, t);
preTravelTree(t->rchild, x, t);
}
}
void getNodeAncesters(Bitree t, ElemType x)
{
preTravelTree(t, x, NULL);
}
int main()
{
Bitree T;
printf("请输入二叉树结点序列:\n");
CreateBitree(&T);
printf("\n先序遍历:");
preorder(T);
printf("\n中序遍历:");
inorder(T);
printf("\n后序遍历:");
postorder(T);
printf("\n");
char character = 'D';
getNodeAncesters(T, character);
return 0;
}
2016真题
选择题
涉及知识点：字符串和字符数组关于’\0’的处理
其中字符数组如char c[5] = {‘C’, ‘h’, ‘i’, ‘n’, ‘a’};并不要求它最后一个字符为’\0’，甚至可以不包含’\0’
大题C语言程序设计
1、
#include<stdio.h>
#define MAX_SIZE 7
int main()
{
int age[MAX_SIZE] = {21, 18, 19, 20, 31, 42, 40};
int lowestAge = age[0];
int highestAge = age[0];
double average = 0.0;
int sum = 0;
int i;
for(i = 0; i < MAX_SIZE; i++)
{
if(age[i] < lowestAge)
{
lowestAge = age[i];
}
if(age[i] > highestAge)
{
highestAge = age[i];
}
sum += age[i];
}
average = sum / MAX_SIZE;
printf("%d %d %lf\n", lowestAge, highestAge, average);
return 0;
}
2、
#include<stdio.h>
#define MAX_SIZE 7
int poww(int power)
{
int product = 1;
int i = 0;
int Xi = 0;
printf("Enter Xi:");
scanf("%d", &Xi);
for(i = 1; i <= power; i++)
{
product *= (Xi - 8);
}
return product;
}
int main()
{
int n = 0;
long int sum = 0;
int i = 0;
printf("Enter n:");
scanf("%d", &n);
printf("\n");
for(i = 0; i < n; i++)
{
sum += poww(4);
}
printf("%d", sum);
return 0;
}
3、
#include<stdio.h>
#define MAX_SIZE 7
typedef struct Courses{
int grades_eng;
int grades_math;
int grades_software;
int grades_internet;
}Courses;
typedef struct Person{
char name[10];
Courses course;
double sum;
double aver_grades;
}Person;
int main()
{
Person student[3] = {"Jacky", 97, 98, 99, 96, 0, 0,"Lily", 90, 90, 90, 90, 0, 0,"Alan", 98, 95, 93, 92, 0, 0};
int sum_eng = 0;
int sum_math = 0;
int sum_software = 0;
int sum_internet = 0;
int student_sum = 0;
double aver_student = 0;
double aver_eng = 0;
double aver_math = 0;
double aver_software = 0;
double aver_internet = 0;
int i;
for(i = 0; i < 3; i++)
{
student_sum = 0;
sum_eng += student[i].course.grades_eng;
sum_math += student[i].course.grades_math;
sum_software += student[i].course.grades_software;
sum_internet += student[i].course.grades_internet;
student_sum = student[i].course.grades_eng + student[i].course.grades_math + student[i].course.grades_software + student[i].course.grades_internet;
student[i].aver_grades = student_sum / 4;
student[i].sum = student_sum;
printf("student %s's scores:%lf\n", student[i].name, student[i].sum);
}
aver_eng = sum_eng / 3;
aver_math = sum_math / 3;
aver_software = sum_software / 3;
aver_internet = sum_internet / 3;
printf("average_eng:%lf average_math:%lf average_software:%lf average_internet:%lf\n", aver_eng, aver_math, aver_software, aver_internet);
}
大题数据结构
1、（我的提示：构造拉链法哈希表用二级指针）
#include<stdio.h>
#include<stdlib.h>
typedef struct Node{
int data;
struct Node *next;
}Node;
typedef struct HashTable{
Node **point;
int table_length;
}HashTable;
int createHashTable(HashTable *table, int size)
{
if(!size)
{
return 0;
}
table->point = (Node **)malloc(sizeof(Node *) * size);
table->table_length = size;
while(size)
{
table->point[--size] = NULL;
}
return 1;
}
int insertNode(HashTable *table, int prime, int number)
{
if(number < 0)
{
return 0;
}
int index = number % prime;
Node *p = (Node *)malloc(sizeof(Node));
p->data = number;
p->next = table->point[index];
table->point[index] = p;
return 1;
}
int lookupHashTable(HashTable table, int number, int prime)
{
if(number < 0)
{
return -1;
}
int index = number % prime;
Node *p = table.point[index];
while(p != NULL && p->data != number)
{
p = p->next;
}
if(p != NULL)
{
return index;
}
return -1;
}
int main()
{
HashTable t;
if(!createHashTable(&t, 5))
{
printf("Fail to create!\n");
return 0;
}
printf("insert 5\n");
insertNode(&t, 5, 4);
printf("insert 6\n");
insertNode(&t, 5, 7);
if(lookupHashTable(t, 7, 5))
{
printf("it is at %d\n", lookupHashTable(t, 7, 5));
}
else
{
printf("it is inexistent\n");
}
return 0;
}
2、
typedef struct BSTNode{
int data;
struct BSTNode *lchild;
struct BSTNode *rchild;
}BSTNode, *BSTree;
BSTNode *tmp;
void travel(BSTree T, ElemType value)
{
if(T != NULL)
{
travel(T->rchild, value);
if(T->data > value)
{
tmp = T;
travel(T->lchild, value);
}
}
}
int getValue(BSTree T, ElemType value)
{
travel(T, value);
return tmp->data;
}
2017真题
C语言大题
1、
#include<stdio.h>
int main()
{
int sales[10] = {82, 75, 58, 79, 64, 48, 96, 55, 81, 69};
int high , low, aver = 0;
int sum = sales[0];
high = sales[0];
low = sales[0];
int h, l;
h = 0, l = 0;
int i;
for(i = 1; i < 10; i++)
{
if(high < sales[i])
{
high = sales[i];
h = i;
}
if(low > sales[i])
{
low = sales[i];
l = i;
}
sum += sales[i];
}
aver = sum / 10;
printf("销售数量最高为第%d天\t销售数量最低为第%d天\n平均销售数量为%d\t最高销售数量为%d\t最低销售数量为%d\n", h + 1, l + 1, aver, high, low);
return 0;
}
2、
#include<stdio.h>
int main()
{
int i = 1;
int n = 30;
double sum = 0;
for(i = 1; i <= n; i++)
{
int f = 1;
int j = 0;
for(j = i; j >= 1; j--)
{
f *= j;
}
printf("%lf\n", 1.0 / (f * f));
sum += 1.0 / (f * f);
}
printf("%lf\n", sum);
}
3、
#include<stdio.h>
typedef struct Score{
int Hmath;
int Dmath;
int Program;
int Physics;
int English;
}Score;
int main()
{
Score student[6] = {72, 86, 87, 97, 45, 53, 76, 98, 58, 84, 83, 89, 75, 84, 47, 35, 59, 47, 83, 49, 64, 76, 87, 83, 36, 87, 89, 96, 65, 58};
int hmath = 0, dmath = 0, program = 0, physics = 0, english = 0;
double aver[6];
int i;
for(i = 0; i < 6; i++)
{
double sum = 0;
hmath += student[i].Hmath;
dmath += student[i].Dmath;
program += student[i].Program;
physics += student[i].Physics;
english += student[i].English;
sum = student[i].Hmath + student[i].Dmath + student[i].Program
+ student[i].Physics + student[i].English;
aver[i] = sum / 6.0;
}
int j;
int k;
for(i = 0; i < 5; i++)
{
k = i;
for(j = i + 1; j < 6; j++)
{
if(aver[k] > aver[j])
{
k = j;
}
}
if(k != i)
{
int tmp = i;
i = k;
k = tmp;
}
}
printf("高等数学总分：%d\t离散数学总分：%d\t程序设计总分：%d\t大学物理总分：%d\t大学英语总分：%d\n", hmath, dmath, program, physics, english);
printf("从高到低平均分：\n");
for(i = 0; i < 6; i++)
{
printf("%lf\t", aver[i]);
}
return 0;
}
数据结构大题
1、
#include<stdio.h>
typedef struct DuLinkNode{
ElemType data;
int freq;
struct DuLinkNode *lLink;
struct DuLinkNode *rLink;
}DLNode, *DLink;
void Locate(DLink L, ElemType x)
{
DLNode *p = L;
while(p->rLink != NULL)
{
if(p->rLink->data == x)
{
break;
}
p = p->rLink;
}
/*
结点不存在，生成新节点
*/
if(p->rLink == NULL)
{
DLNode *r = (DLNode *)malloc(sizeof(DLNode));
r->data = x;
r->freq = 1;
r->rLink = p->rLink;
r->lLink = p;
p->rLink = r;
}
/*
结点早已存在
*/
else
{
DLNode *r = p->rLink;
r->rLink->lLink = p;
p->rLink = r->rLink;
r->freq += 1;
DLNode *t = p;
while(t != L)
{
if(r->freq <= t->freq)
{
break;
}
t = t->lLink;
}
r->rLink = t->rLink;
t->rLink->lLink = r;
r->lLink = t;
t->rLink = r;
}
}
2、
#include<stdio.h>
#define maxn 100
int heap[maxn] = {0, 2, 6, 8, 9, 3, 7, 4, 0, 33, 24};
int n = 10;
void swap(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
int downAdjust(int low, int high)
{
int i = low;
int j = i * 2;
while(j <= high)
{
if(j + 1 <= high && heap[j + 1] > heap[j])
{
j = j + 1;
}
if(heap[j] > heap[i])
{
swap(&heap[i], &heap[j]);
i = j;
j = i * 2;
}
else
{
break;
}
}
}
void createHeap()
{
int i;
for(i = n / 2; i >= 1; i--)
{
downAdjust(i, n);
}
}
void heapSort()
{
int i;
createHeap();
for(i = n; i > 1; i--)
{
swap(&heap[i], &heap[1]);
downAdjust(1, i - 1);
}
}
2018真题
C语言大题
1、
#include<stdio.h>
#include<math.h>
int main()
{
double xi;
double sum = 0.0;
int cnt;
for(cnt = 1; cnt <= 20; cnt++)
{
scanf("%lf", &xi);
sum += pow((1.5 * xi - 3), 5);
}
printf("%lf", sum);
}
2、
#include<stdio.h>
typedef struct Record{
int workerId;
char workerName[10];
double workerWages;
double workerAllowance;
double workerRealWages;
}Record;
int main()
{
Record worker[10] = {
1, "Alan", 90, 80, 0,
2, "Bob", 90, 86, 0,
3, "Cindy", 90, 88, 0,
4, "Dylan", 92, 80, 0,
5, "Elen", 96, 80, 0,
6, "Frank", 99, 80, 0,
7, "Galen", 98, 80, 0,
8, "Halen", 90, 83, 0,
9, "Iwan", 91, 80, 0,
10, "Jenny", 95, 80, 0,
};
double sumWorkerRealWages = 0.0;
int cnt = 0;
for(; cnt < 10; cnt++)
{
worker[cnt].workerRealWages = worker[cnt].workerWages + worker[cnt].workerAllowance;
sumWorkerRealWages += worker[cnt].workerRealWages;
}
double averageRealWages = sumWorkerRealWages / 10;
for(cnt = 0; cnt < 10; cnt++)
{
if(worker[cnt].workerRealWages > averageRealWages)
{
printf("%d %s %lf ", worker[cnt].workerId, worker[cnt].workerName, worker[cnt].workerWages);
printf("%lf %lf\n", worker[cnt].workerAllowance, worker[cnt].workerRealWages);
}
}
return 0;
}
数据结构大题
1、
#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode, *LinkList;
int initList(LinkList *L)
{
*L = (LNode *)malloc(sizeof(LNode));
if(*L == NULL)
{
return 0;
}
(*L)->next = NULL;
return 1;
}
int listInsert(LinkList *L, int i, ElemType e)
{
if(i < 1)
{
return 0;
}
LNode *p;
int j = 0;
p = *L;
while(p != NULL && j < i - 1)
{
p = p->next;
j++;
}
if(p == NULL)
{
return 0;
}
LNode *s = (LNode *)malloc(sizeof(LNode));
s->data = e;
s->next = p->next;
p->next = s;
return 1;
}
void convertList(LinkList *L, ElemType n)
{
LNode *p = *L;
LNode *q, *r;
int i;
for(i = 0; i < n / 2; i++)
{
p = p->next;
}
q = p->next;
p->next = NULL;
while(q != NULL)
{
r = q->next;
q->next = p->next;
p->next = q;
q = r;
}
/*
q是后面大数链表要插入到前面小数链表的结点
q1是大数链表q后一个结点
r是前面小数链表第一个结点
tmp为小数链表r后一个结点
*/
q = p->next;
p->next = NULL;
r = (*L)->next;
LNode *tmp = r->next;
LNode *q1 = q->next;
while(r != NULL)
{
q->next = r->next;
r->next = q;
q = q1;
if(q1 == NULL)
{
break;
}
q1 = q1->next;
if(tmp == NULL)
{
break;
}
r = tmp;
tmp = tmp->next;
}
if(tmp == NULL && q != NULL)
{
r->next->next = q;
}
}
int main()
{
int i = 1;
LinkList L;
initList(&L);
/*
L是长度为5的奇数链表
*/
for(; i < 6; i++)
{
listInsert(&L, i, i);
}
LNode *p = L->next;
for(i = 0; i < 5; i++)
{
printf("i = %d\t", p->data);
p = p->next;
}
printf("\n奇数转置新链表：\n");
convertList(&L, 5);
p = L->next;
for(i = 0; i < 5; i++)
{
printf("i = %d\t", p->data);
p = p->next;
}
printf("\n\n\n");
LinkList L1;
initList(&L1);
/*
L1是长度为6的偶数链表
*/
for(i = 1; i < 7; i++)
{
listInsert(&L1, i, i);
}
LNode *p2 = L1->next;
for(i = 0; i < 6; i++)
{
printf("i = %d\t", p2->data);
p2 = p2->next;
}
printf("\n偶数转置新链表：\n");
convertList(&L1, 6);
p2 = L1->next;
for(i = 0; i < 6; i++)
{
printf("i = %d\t", p2->data);
p2 = p2->next;
}
return 0;
}
2、
关键答题代码
#include<stdio.h>
typedef struct BiTNode{
char data;
struct BiTNode *lchild;
struct BiTNode *rchild;
}BiTNode, *BiTree;
int L = 1;
void leno(BiTNode *p, char x)
{
if(p != NULL)
{
if(p->data == x)
{
printf("所在第%d层\n", L);
}
++L;
leno(p->lchild, x);
leno(p->rchild, x);
--L;
}
}
int main()
{
BiTree T;
CreateBiTree(&T);
char c = 'E';
leno(T, c);
return 0;
}
测试代码
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define MAX_SIZE 30
#define NLAYER 4
typedef struct BiTNode{
char data;
struct BiTNode *lchild;
struct BiTNode *rchild;
}BiTNode, *BiTree;
void CreateBiTree(BiTree *bt)
{
char ch;
scanf("%c", &ch);
if(ch == '#')
{
*bt = NULL;
}
else
{
*bt = (BiTree)malloc(sizeof(BiTNode));
(*bt)->data = ch;
CreateBiTree(&((*bt)->lchild));
CreateBiTree(&((*bt)->rchild));
}
}
void TranslevelPrint(BiTree bt)
{
struct node{
BiTree vec[MAX_SIZE]; /* 存放树结点 */
int layer[MAX_SIZE]; /* 结点所在层 */
int locate[MAX_SIZE]; /* 打印结点位置 */
int front, rear;
}q;
int i, j = 1, k = 0, nLocate;
q.front = 0; /* 初始化队列 */
q.rear = 0;
printf(" ");
q.vec[q.rear] = bt;
q.layer[q.rear] = 1;
q.locate[q.rear] = 20;
q.rear += 1;
while(q.front < q.rear)
{
bt = q.vec[q.front];
i = q.layer[q.front];
nLocate = q.locate[q.front];
if(j < i)
{
printf("\n");
printf("\n");
j += 1;
k = 0;
while(k < nLocate)
{
printf(" ");
k++;
}
}
while(k < (nLocate - 1))
{
printf(" ");
k++;
}
printf("%c", bt->data);
q.front = q.front + 1;
if(bt->lchild != NULL)
{
q.vec[q.rear] = bt->lchild;
q.layer[q.rear] = i + 1;
q.locate[q.rear] = (int)(nLocate - pow(2, NLAYER - i - 1));
q.rear += 1;
}
if(bt->rchild != NULL)
{
q.vec[q.rear] = bt->rchild;
q.layer[q.rear] = i + 1;
q.locate[q.rear] = (int)(nLocate + pow(2, NLAYER - i - 1));
q.rear += 1;
}
}
}
/* 输出叶子结点 */
void PreOrderLeaf(BiTree root)
{
if(root != NULL)
{
if(root->lchild == NULL && root->rchild == NULL)
{
printf("%c ", root->data);
}
PreOrderLeaf(root->lchild);
PreOrderLeaf(root->rchild);
}
}
int L = 1;
void leno(BiTNode *p, char x)
{
if(p != NULL)
{
if(p->data == x)
{
printf("所在第%d层\n", L);
}
++L;
leno(p->lchild, x);
leno(p->rchild, x);
--L;
}
}
/* 输出叶子结点的个数 */
int LeafCount(BiTree root)
{
int LeafNum;
if(root == NULL)
{
LeafNum = 0;
}
else if((root->lchild == NULL) && (root->rchild == NULL))
{
LeafNum = 1;
}
else
{
LeafNum = LeafCount(root->lchild) + LeafCount(root->rchild);
}
return LeafNum;
}
/* 输出二叉树的深度 */
int PostTreeDepth(BiTree root)
{
int hl, hr, max;
if(root != NULL)
{
hl = PostTreeDepth(root->lchild);
hr = PostTreeDepth(root->rchild);
max = hl > hr ? hl : hr;
return(max + 1);
}
else
{
return 0;
}
}
int main()
{
BiTree T;
printf("请输入二叉树结点序列：\n");
CreateBiTree(&T);
TranslevelPrint(T);
printf("\n所有叶子结点:");
PreOrderLeaf(T);
printf("\n输出叶子结点个数：%d\n",LeafCount(T));
printf("树的深度为：%d\n",PostTreeDepth(T));
char c = 'E';
leno(T, c);
return 0;
}
很明显E确实是在第三层
2019真题
C语言大题
1、
代码一：
#include<stdio.h>
#include<math.h>
int main()
{
int n;
scanf("%d", &n);
int i;
int tmp = 1;;
int sum;
for(i = 1; i <= n; i++)
{
tmp *= i;
sum += tmp;
}
printf("sum = %d\n", sum);
return 0;
}
代码二：
#include<stdio.h>
int func(int n)
{
int sum = 0;
int i;
for(i = 1; i <= n; i++)
{
int mul = 1;
int j;
for(j = i; j >= 1; j--)
{
mul *= j;
}
sum += mul;
}
return sum;
}
int main()
{
int n;
scanf("%d", &n);
printf("%d", func(n));
return 0;
}
2、
代码一：
#include<stdio.h>
int main()
{
int a[10][10] = {0};
int i;
int j;
for(i = 1; i < 10; i++)
{
a[0][i] = i;
}
for(j = 1; j < 10; j++)
{
a[j][0] = j;
}
for(i = 1; i < 10; i++)
{
for(j = 0; j < 9; j++)
{
a[i][j + 1] = a[i][j] + 1;
}
}
for(i = 0; i < 10; i++)
{
for(j = 0; j < 10; j++)
{
if(a[i][j] == 0)
{
printf(" ");
}
else
{
printf("%5d ", a[i][j]);
}
}
printf("\n");
}
return 0;
}
代码二：
#include<stdio.h>
int multiTable()
{
printf("\t|");
int colNum = 1;
for(; colNum < 10; colNum++)
{
printf("%d\t", colNum);
}
printf("\n");
int j;
for(j = 1; j <= 10; j++)
{
printf("-------\t");
}
int rowNum;
printf("\n");
for(rowNum = 1; rowNum < 10; rowNum++)
{
printf("%d\t|", rowNum);
colNum = 1;
for(; colNum < 10; colNum++)
{
printf("%d\t", rowNum + colNum);
}
printf("\n");
}
}
int main()
{
multiTable();
return 0;
}
数据结构大题
1、
需考虑的特殊情况：
关键代码：
#include<stdio.h>
#include<stdlib.h>
typedef struct BiTNode{
char data;
struct BiTNode *lchild, *rchild;
}BiTNode, *Bitree;
void CreateBitree(Bitree *bt)
{
char ch;
scanf("%c", &ch);
if(ch == '#')
{
*bt = NULL;
}
else
{
*bt = (Bitree)malloc(sizeof(BiTNode));
(*bt)->data = ch;
CreateBitree(&(*bt)->lchild);
CreateBitree(&(*bt)->rchild);
}
}
int PostTreeDepth(Bitree root)
{
int hl, hr, max;
if(root != NULL)
{
hl = PostTreeDepth(root->lchild);
hr = PostTreeDepth(root->rchild);
max = hl > hr ? hl : hr;
return(max + 1);
}
else
{
return 0;
}
}
int maxdistance = 0;
int maxDistance(Bitree T)
{
if(T == NULL)
{
return maxdistance;
}
int l = PostTreeDepth(T->lchild);
int r = PostTreeDepth(T->rchild);
int cnt = l + r;
if(cnt > maxdistance)
{
maxdistance = cnt;
}
maxDistance(T->lchild);
maxDistance(T->rchild);
return maxdistance;
}
int main()
{
Bitree T;
printf("请输入二叉树结点序列:\n");
CreateBitree(&T);
printf("\n");
PostTreeDepth(T);
printf("最远距离：%d\n", maxDistance(T));
return 0;
}
完整代码：
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define MAX_SIZE 30
#define NLAYER 5
typedef struct BiTNode{
char data;
struct BiTNode *lchild, *rchild;
}BiTNode, *Bitree;
void CreateBitree(Bitree *bt)
{
char ch;
scanf("%c", &ch);
if(ch == '#')
{
*bt = NULL;
}
else
{
*bt = (Bitree)malloc(sizeof(BiTNode));
(*bt)->data = ch;
CreateBitree(&(*bt)->lchild);
CreateBitree(&(*bt)->rchild);
}
}
void preorder(Bitree bt)
{
if(bt == NULL)
{
return;
}
printf("%c ", bt->data);
preorder(bt->lchild);
preorder(bt->rchild);
}
void inorder(Bitree bt)
{
if(bt == NULL)
{
return;
}
inorder(bt->lchild);
printf("%c ", bt->data);
inorder(bt->rchild);
}
void postorder(Bitree bt)
{
if(bt == NULL)
{
return;
}
postorder(bt->lchild);
postorder(bt->rchild);
printf("%c ", bt->data);
}
int PostTreeDepth(Bitree root)
{
int hl, hr, max;
if(root != NULL)
{
hl = PostTreeDepth(root->lchild);
hr = PostTreeDepth(root->rchild);
max = hl > hr ? hl : hr;
return(max + 1);
}
else
{
return 0;
}
}
int maxdistance = 0;
int maxDistance(Bitree T)
{
if(T == NULL)
{
return maxdistance;
}
int l = PostTreeDepth(T->lchild);
int r = PostTreeDepth(T->rchild);
int cnt = l + r;
if(cnt > maxdistance)
{
maxdistance = cnt;
}
maxDistance(T->lchild);
maxDistance(T->rchild);
return maxdistance;
}
void TranslevelPrint(Bitree bt)
{
struct node{
Bitree vec[MAX_SIZE]; /* 存放树结点 */
int layer[MAX_SIZE]; /* 结点所在层 */
int locate[MAX_SIZE]; /* 打印结点位置 */
int front, rear;
}q;
int i, j = 1, k = 0, nLocate;
q.front = 0; /* 初始化队列 */
q.rear = 0;
printf(" ");
q.vec[q.rear] = bt;
q.layer[q.rear] = 1;
q.locate[q.rear] = 20;
q.rear += 1;
while(q.front < q.rear)
{
bt = q.vec[q.front];
i = q.layer[q.front];
nLocate = q.locate[q.front];
if(j < i)
{
printf("\n");
printf("\n");
j += 1;
k = 0;
while(k < nLocate)
{
printf(" ");
k++;
}
}
while(k < (nLocate - 1))
{
printf(" ");
k++;
}
printf("%c", bt->data);
q.front = q.front + 1;
if(bt->lchild != NULL)
{
q.vec[q.rear] = bt->lchild;
q.layer[q.rear] = i + 1;
q.locate[q.rear] = (int)(nLocate - pow(2, NLAYER - i - 1));
q.rear += 1;
}
if(bt->rchild != NULL)
{
q.vec[q.rear] = bt->rchild;
q.layer[q.rear] = i + 1;
q.locate[q.rear] = (int)(nLocate + pow(2, NLAYER - i - 1));
q.rear += 1;
}
}
}
int main()
{
Bitree T;
printf("请输入二叉树结点序列:\n");
CreateBitree(&T);
printf("\n");
TranslevelPrint(T);
printf("\n");
PostTreeDepth(T);
printf("最远距离：%d\n", maxDistance(T));
return 0;
}
测试样例：
ABD#FH###EG#I###C##
2、
#define MAXSIZE 100
typedef int ElemType
typedef struct SqList{
ElemType *elem;
int length;
int maxsize;
}SqList;
void moveValueBehind(ElemType value, SqList *L, int value)
{
int lowIndex = 0;
int highInedex = L->length - 1;
while(lowIndex < highIndex)
{
while(lowIndex < highIndex)
{
if(L->elem[lowIndex] == value)
{
break;
}
else
{
lowIndex++;
}
}
while(lowIndex < highIndex)
{
if(L->elem[highIndex] != value)
{
break;
}
else
{
highIndex--;
}
}
if(lowIndex < highInex)
{
ElemType tmp = L->elem[lowIndex];
L->elem[lowIndex] = L->elem[highIndex];
L->elem[highIndex] = tmp;
}
}
}
2020真题
C语言大题
1、
代码一：
#include<stdio.h>
int main()
{
int n;
scanf("%d", &n);
double s;
int i;
int tmp1 = 0;
for(i = 1; i <= n; i++)
{
tmp1 += i;
s += 1.0/ tmp1;
}
printf("%lf\n", s);
return 0;
}
代码二：
#include<stdio.h>
float getResult(int n)
{
float s = 0;
int deno = 0;
int i;
for(i = 1; i <= n; i++)
{
deno += i;
s += 1.0 / deno;
}
return s;
}
int main()
{
int n;
scanf("%d", &n);
float res = getResult(n);
printf("%f\n", res);
return 0;
}
2、
#include<stdio.h>
typedef struct StScore{
int math;
int english;
int chinese;
}StScore;
int main()
{
StScore student[4] = {
72, 97, 87,
98, 95, 93,
89, 88, 96,
93, 91, 88
};
int i;
int aver = 0;
for(i = 0; i < 4; i++)
{
aver = student[i].math + student[i].english + student[i].chinese;
aver /= 4;
if(aver < 70)
{
printf("No.%d student's info:\nmath:%d\tenglish:%d\tchinese:%d\n", i + 1, student[i].math, student[i].english, student[i].chinese);
}
}
return 0;
}
数据结构大题
1、请设计算法将循环单链表中每个结点左移K
typedef int ElemType;
typedef struct CircularLinkNode{
ElemType data;
struct CircularLinkNode *nextNode;
}CircularLinkNode, CircularLinkList;
void move(int k, CircularLinkList *L)
{
CircularLinkNode *pCurNode = L;
int cnt = 1;
while(cnt <= k)
{
pCurNode = pCurNode->nextNode;
cnt++;
}
L = pCurNode;
}
2、设计算法求二叉链表结构存储的二叉树中每层结点的最大值
typedef char ElemType;
typedef struct BiTNode{
ElemType data;
struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;
typedef struct QElemType{
BiTNode *pNode;
int nodeLevel;
}QElemType;
int getWidthBiTree(BiTree T)
{
if(T == NULL)
{
return 0;
}
Queue Q;
QElemType e;
e.pNode = T;
e.nodeLevel = 1;
initialQueue(Q);
enQueue(Q, e);
int currentLevel = 1;
int maxValue = T->data;
while(!isEmpty(Q))
{
deQueue(Q, e);
ElemType elemData = (e.pNode)->data;
if(currentLevel == e.nodeLevel)
{
if(maxValue < elemData)
{
maxValue = elemData;
}
}
else
{
printf("%d", maxValue);
currentLevel = e.nodeLevel;
maxValue = elemData;
}
QElemType tmp;
BiTNode *p = e.pNode;
if(NULL != (e.pNode)->lchild)
{
tmp.pNode = (e.pNode)->lchild;
tmp.nodeLevel = e.nodeLevel + 1;
enQueue(Q, tmp);
}
if(NULL != (e.pNode)->rchild)
{
tmp.pNode = (e.pNode)->rchild;
tmp.nodeLevel = e.nodeLevel + 1;
enQueue(Q, tmp);
}
}
}
2021真题
C代码：（注意一定要模块化！！！）
#include<stdio.h>
#define MAX_LENGTH 10
typedef struct BankInfo{
int ID;
char name[MAX_LENGTH];
char passWord[MAX_LENGTH];
float balance;
}BankInfo;
float getAverage(BankInfo infList[], int infListLength)
{
float sum = 0;
int i;
for(i = 0; i < infListLength; i++)
{
sum += infList[i].balance;
}
return sum / infListLength;
}
void printBigger(float avg, BankInfo infList[], int infListLength)
{
int i;
for(i = 0; i < infListLength; i++)
{
if(avg <= infList[i].balance)
{
printf("%d %s %s %f\n",infList[i].ID, infList[i].name, infList[i].passWord, infList[i].balance);
}
}
}
int enterInf(BankInfo infList[])
{
int infListLength = 0;
scanf("%d", &infListLength);
int i = 0;
for(; i < infListLength; i++)
{
scanf("%d %s %f", &infList[i].ID, infList[i].name, &infList[i].balance);
gets(infList[i].passWord);
}
return infListLength;
}
int main()
{
BankInfo infList[90];
int infListLength = 0;
infListLength = enterInf(infList);
float avg = getAverage(infList, infListLength);
printBigger(avg, infList, infListLength);
return 0;
}
下面这个代码是反面教材
#include<stdio.h>
typedef struct BankAccount{
int ID;
char name[20];
char password[30];
double money;
}BankAccount;
int main()
{
BankAccount account[90] = {1, "LiMing", "123", 50.0, 2, "LiHua", "321", 99.9, 3, "Alan", "132", 96.9};
int i = 0;
for(i = 3; i < 90; i++)
{
account[i].ID = -1;
}
double sumMoney = 0;
double averMoney = 0;
i = 0;
while(account[i].ID != -1)
{
sumMoney += account[i].money;
i++;
}
int cnt = i;
averMoney = sumMoney / i;
for(i = 0; i < cnt; i++)
{
if(account[i].money > averMoney)
{
printf("UserID:%d\tUsername:%s\tUserpassword:%s\tUsermoney:%lf\n", account[i].ID, account[i].name, account[i].password, account[i].money);
}
}
return 0;
}
第二个题的C代码：
#include<stdio.h>
float fun(int m)
{
float sum = 1;
int i;
for(i = 2; i <= m; i++)
{
sum = sum - 1.0 / (i * i);
}
return sum;
}
int main()
{
int m;
scanf("%d", &m);
float sum = fun(m);
printf("%f", sum);
return 0;
}
数据结构大题
1、设计算法在有序单链表中删除重复元素e，使得单链表删除e后依然有序
#include<stdio.h>
typedef int ElemType;
typedef struct LNode{
ElemType data;
struct LNode *next;
int length;
}LNode, *LinkList;
void deleteValue(int e, LinkList *L)
{
int cnt = 0;
int i;
int flag = 0;
LNode *p = (*L)->next;
LNode *q;
for(i = 0; i < (*L)->length; i++)
{
if(p->data == e)
{
if(flag == 0)
{
flag = 1;
}
else
{
LNode *p1 = p;
p = p->next;
q->next = p;
free(p1);
}
}
q = p;
p = p->next;
}
}
2、设计算法在二叉排序树中查找第k大的结点
BSTNode *pNodeK = NULL;
int iCurOrder = 0;
void inTravsing(BSTree T, int k)
{
if(T != NULL)
{
inTravsing(T->rchild, k);
iCurOrder += 1;
if(iCurOrder == k)
{
pNodeK = T;
}
else if(pNodeK == NULL)
{
inTravsing(T->lchild, k);
}
}
}
BSTNode *getTop(int k, BSTree T)
{
inTravsing(T, k);
return pNodeK;
}
668
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
