0%

# 软件技术基础的前两次实验

发表于 2022-11-02 更新于 2022-11-08 分类于 C语言 阅读次数：

## 先放工程文件内容(工程内容为第一次做的母本，实际写实验报告时建议修改代码蓝本)

- 第一次实验提取密码：36w2。
- 第二次实验提取密码：s0z4。

### 第一次实验代码

    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
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66

    #include<stdio.h>
    #include<string.h>
    #include<malloc.h>
    #pragma warning(disable:4996)
    typedef struct student
    {
    	int elem;
    	int num;
    	char name[20];
    	char adress[30];
    	char sex[20];
    	int year;
    	struct student *next;
    }link;
    link * creatLink(int * initelem, int len) {
    	int i;
    	//最初状态下，头指针 H 没有任何结点，所以，插入第一个元素，就相当于是创建结点 H
    	link *H = (link*)malloc(sizeof(link));
    	H->elem = initelem[0];
    	H->next = NULL;
    	//如果采用头插法插入超过 1 个元素，则可添加到第一个结点 H 之前
    	for (i = 1; i < len; i++) {
    		link * a = (link*)malloc(sizeof(link));
    		a->elem = initelem[i];
    		//插入元素时，首先将插入位置后的链表链接到新结点上
    		printf("学号：");
    		scanf("%d", &(a->num));
    		printf("名字：");
    		scanf("%s", &(a->name));
    		printf("地址：");
    		scanf("%s", &(a->adress));
    		printf("性别（可填武装直升机）：");
    		scanf("%s", &(a->sex));
    		printf("年龄：");
    		scanf("%d", &(a->year));
    		printf("\n");
    		a->next = H;
    		//然后再链接头指针 H
    		H = a;
    	}
    	return H;
    }
    void display(struct student *p) {
    	while (((p->elem) > 1)&& ((p->elem) = 1)) {
    		printf("学生：");
    		printf("%d\t", p->num);
    		printf("%s\t", p->name);
    		printf("%s\t", p->adress);
    		printf("%s\t", p->sex);
    		printf("%d\t", p->year);
    		printf("\n");
    		p = p->next;
    	}
    	printf("\n");
    }
    int main(void)
    {
    	int a, i;
    	int elem[20] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
    	printf("结构体数目：");
    	scanf("%d", &i);
    	link *Head = creatLink(elem,i+1);
    	display(Head);
    	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
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154

    #include<stdio.h>
    #include <stdlib.h>
    #include<malloc.h>
    #pragma warning (disable:4996)
    struct Node//结构体
    {
    	char data;
    	struct Node* link;
    };
    struct Node* buildLinkedList(char* arr, int n) //尾插法初始化链表并插入元素的函数
    {
    	struct Node*p, *pre, *head;
    	head = (struct Node*)malloc(sizeof(struct Node));
    	head->link = NULL;
    	pre = head;
    	for (int i = 0; i < n; i++) {
    		p = (struct Node*)malloc(sizeof(struct Node));
    		p->data = arr[i];
    		p->link = NULL;
    		pre->link = p;
    		pre = p;
    	}
    	return head;
    }
    struct Node* insertElem(Node * p, char elem, int add) // 插入函数
    {
    	Node * temp = p;//创建临时结点temp
    	//首先找到要插入位置的上一个结点
    	for (int i = 2; i < add*2; i++) {
    		if (temp == NULL) {
    			printf("插入位置无效\n");
    			return p;
    		}
    		temp = temp->link;
    	}
    	//创建插入结点c
    	Node * c = (Node*)malloc(sizeof(Node));
    	c->data = elem;
    	//向链表中插入结点
    	c->link = temp->link;
    	temp->link = c;
    	return p;
    }
    struct Node * delElem(Node * p, int add)
    {
    	Node * temp = p;
    	//temp指向被删除结点的上一个结点
    	for (int i = 2; i < add*2; i++) {
    		temp = temp->link;
    	}
    	Node * del = temp->link;//单独设置一个指针指向被删除结点，以防丢失
    	temp->link = (temp->link)->link;//删除某个结点的方法就是更改前一个结点的指针域
    	free(del);//手动释放该结点，防止内存泄漏
    	return p;
    }
    void printLinkedList(struct Node* head) //打印链表的函数
    {
    	head = head->link;
    	printf("%c", head->data);
    	head = head->link;
    	while (head != NULL) {
    		printf("%c", head->data);
    		head = head->link;
    	}
    }
    int Length(struct Node* L)//表长统计函数
    {
    	int len = 0; //统计表长
    	struct Node *p = L;
    	while (p->link != NULL) {
    		p = p->link;
    		len = len + sizeof(struct Node);
    	}
    	return len;
    }
    void getItem(Node head, int j)//通过位置获取对应结构体子数据的函数
    {
    	Node *p = head.link;
    	int i = 2;
    	while (p&&i < j*2)		//找到第j个位置，当遍历到链表尾或j的值小于1时跳出循环
    	{
    		p = p->link;
    		i++;
    	}
    	if (!p || i > j*2)		//判断找到的位置是否正确，表尾或i>j均输出错误
    	{				//i<j是指输入的位置小于0,即不在链表内
    		printf("请输入正确的位置，%d该位置不在范围内\n", j);
    	}
    	else
    	{
    		printf("第%d个位置的字符为%c\n", j, p->data);
    	}
    }
    void LocateElem(Node L) //对应元素位置寻找
    {
    	//声明一个指针
    	Node *p=L.link;
    	char j = 'a';
    	//计数器
    	int i = 2;
    	//当指针指向的结点不为空，并且指针指向的结点的数据域与要查找的值不相等
    	while (p && p->data != j)
    	{
    		p = p->link;
    		i++;
    	}
    	i = i / 2;
    	if (p)
    		printf("位置为：1\n");//如果指针指向的结点不为空，则输出计数器的内容，也即是结点数据域的位置
    	else
    		printf("未找到该数据\n");//如果指针为空，则表明未找到该数据
    }

    int main(void)
    {
    	int n, i,pos(1),len;
    	char newelem;
    	char* a;
    	printf("结构体总数：");
    	scanf("%d\n", &n);
    	a = (char*)malloc(n * sizeof(char));	//动态内存分配申请字符串空间
    	len = n;
    	n = n * 2;
    	for (i = 0; i < n; i++)
    	{
    		scanf("%c", &a[i]);
    	}
    	printf("\n");
    	struct Node* temp = NULL;	//声明一个指针变量temp
    	temp = buildLinkedList(a, n);//创建链表，把返回的头指针赋值给temp指针变量
    	printLinkedList(temp);//打印链表：整个链表用temp来代表。
    	printf("\n结构体总长度：%d\n", Length(temp));
    	if (temp->link == NULL)
    		printf("空");
    	else
    		printf("非空");//判断单链表是否为空
    	printf("\n输入所求字符位置：");
    	scanf("%d",&pos);
    	getItem(*temp,pos);
    	printf("寻找字符a的位置\n");
    	LocateElem(*temp);
    	printf("输入修改字符位置：");
    	scanf("%d", &pos);
    	printf("输入修改的字符：");
    	scanf("%s", &newelem);
    	temp=insertElem(temp, newelem, pos);
    	printLinkedList(temp);//再次打印链表
    	printf("输入删除的位置：");
    	scanf("%d", &pos);
    	temp = delElem(temp, pos);
    	printLinkedList(temp);//再次打印链表
    	system("pause");
    	return 0;
    }

欢迎打赏

微信支付