数据结构练习1.线性单链表

先复盘学长测试题：

        建一个线性单链表，要求能初始化、插入、打印全部

练习方法：先什么都不看，写完后公示代码，再优化、修改，最后公示尽力优化后的代码（教科书对比和自己理解）

未理解报错代码片段1：（代码第三行报错*3）

//定义节点
typedef struct {
    int data;
    Node* next;
} Node;

错误原因：

修改后：（可以正常使用Node：自建类型）

//定义节点
typedef struct node{
    int data;
    node* next;
} Node;

衍生报错问题：

typedef struct{
    int data;
    struct Node* next;//报错
} Node;

typedef struct{
    int data;
    struct node* next;//不报错
} Node;

磕磕绊绊写完后，终于能运行的代码：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>//malloc函数在此头文件中

//定义节点
typedef struct node{
    int data;
    struct node* next;
} Node;

int main()
{
    Node* init(void);//初始化
    int insert(Node* N, int sit, int dt);//后插入(节点名、位置、值)，成功1，失败0
    int pr(Node* N);//打印所有

    //测试
    Node* list = init();
    //int i = 5;
    //int flag;
    //while (i) {
    //    int a, b;
    //    scanf_s("%d, %d", &a, &b);
    //    flag = insert(list, a, b);
    //    if (flag)
    //        printf("error");
    //    i--;
    //}
    int a, b;
    scanf("%d, %d", &a, &b);
    insert(list, a, b);
    insert(list, a, b);
    pr(list);
    return 0;
}

Node* init(void)//建立只有头节点的单链表，返回头节点地址
{
    Node* head = (Node*)malloc(sizeof(Node));
    if (head == NULL) {//建表失败
        printf("error");
        return NULL;
    }
        
    head->data = 0;//链表长度
    head->next = NULL;
    return head;
}

int insert(Node* N, int sit, int dt)
{
    Node* i1 = N;

    //将指针定位到插入位置
    if (sit > N->data) {//若指定位置大于链表长度
        printf("sit too big\n");
        return 0;
    }
    while (sit) {//定位
        i1 = i1->next;
        sit--;
    }

    //插入
    Node* New = (Node*)malloc(sizeof(Node));//新节点
    New->next = i1->next;
    i1->next = New;
    N->data++;
    New->data = dt;
    printf("inserted\n");
    printf("the data is %d\n", New->data);
    return 1;
}

int pr(Node* N)
{
    if (N->next == NULL) {//若为空表
        printf("is empty\n");
        return 0;
    }

    Node* i1 = N->next;
    while (i1 != NULL) {//挨个打印，直到结束
        printf("%d\n", i1->data);
        i1 = i1->next;
    }
    printf("print over\n");
    return 1;
}

 优化后：

//#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>//malloc函数在此头文件中

//定义节点
typedef struct node {
	int data;
	struct node* next;
} Node, * LinkList;//LinkList等价于Node*，但常用其定义指向单链表的头指针

int main()
{
	LinkList init(LinkList L);//初始化
	int insert(LinkList N, int sit, int dt);//后插入(节点名、位置、值)，成功1，失败0
	int pr(LinkList N);//打印所有

	//测试
	LinkList list = NULL;//指针必须先确定值，再使用
	list = init(list);
	//char a;
	int a, b;
	while(1) {
		scanf_s("%d %d", &a, &b);	
		//getchar();//消除输入残留的\n
		if (a == -1)
			break;
		insert(list, a, b);
	}
	pr(list);
	return 0;
}

LinkList init(LinkList L)//建立只有头节点的单链表，返回头节点地址
{
	L = (LinkList)malloc(sizeof(Node));
	if (L == NULL) {//建表失败
		printf("error");
		return NULL;
	}
		
	L->data = 0;//链表长度
	L->next = NULL;
	return L;
}

int insert(LinkList N, int sit, int dt)
{
	Node* i1 = N;

	//将指针定位到插入位置
	if (sit < 0) {//若为负数
		printf("sit too small\n");
		sit = 0;
		return 0;
	}
	if (sit > N->data) {//若指定位置大于链表长度
		printf("sit too big\n");
		return 0;
	}
	while (sit) {//定位
		i1 = i1->next;
		sit--;
	}

	//插入
	Node* New = (Node*)malloc(sizeof(Node));//新节点
	if (New == NULL) {
		printf("error");
	}
	New->next = i1->next;
	i1->next = New;
	N->data++;
	New->data = dt;
	printf("inserted:%d\n", New->data);
	return 1;
}

int pr(LinkList N)
{
	if (N->next == NULL) {//若为空表
		printf("is empty\n");
		return 0;
	}

	Node* i1 = N->next;
	while (i1 != NULL) {//挨个打印，直到结束
		printf("%d\n", i1->data);
		i1 = i1->next;
	}
	printf("print over\n");
	return 1;
}

 更改了输入检测：

//#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>//malloc函数在此头文件中

//定义节点
typedef struct node {
	int data;
	struct node* next;
} Node, * LinkList;//LinkList等价于Node*，但常用其定义指向单链表的头指针

int main()
{
	LinkList init(LinkList L);//初始化
	int insert(LinkList N, int sit, int dt);//后插入(节点名、位置、值)，成功1，失败0
	int pr(LinkList N);//打印所有

	//测试
	LinkList list = NULL;//指针必须先确定值，再使用
	list = init(list);
	char a;
	int b;
	while(1) {
		scanf_s("%c,%d", &a, sizeof(a), &b);
		//getchar();//消除输入残留的\n
		if (a == '$')
			break;
		insert(list, a - '0', b);
	}
	pr(list);
	return 0;
}

LinkList init(LinkList L)//建立只有头节点的单链表，返回头节点地址
{
	L = (LinkList)malloc(sizeof(Node));
	if (L == NULL) {//建表失败
		printf("error");
		return NULL;
	}
		
	L->data = 0;//链表长度
	L->next = NULL;
	return L;
}

int insert(LinkList N, int sit, int dt)
{
	Node* i1 = N;

	//将指针定位到插入位置
	if (sit < 0) {//若为负数
		printf("sit too small\n");
		return 0;
	}
	if (sit > N->data) {//若指定位置大于链表长度
		printf("sit too big\n");
		return 0;
	}
	while (sit) {//定位
		i1 = i1->next;
		sit--;
	}

	//插入
	Node* New = (Node*)malloc(sizeof(Node));//新节点
	if (New == NULL) {
		printf("error");
	}
	New->next = i1->next;
	i1->next = New;
	N->data++;
	New->data = dt;
	printf("inserted:%d\n", New->data);
	return 1;
}

int pr(LinkList N)
{
	if (N->next == NULL) {//若为空表
		printf("is empty\n");
		return 0;
	}

	Node* i1 = N->next;
	while (i1 != NULL) {//挨个打印，直到结束
		printf("%d\n", i1->data);
		i1 = i1->next;
	}
	printf("print over\n");
	return 1;
}

这次测验严重影响速度的问题：

1.测试时面对结果没有定位到到问题出在哪个代码块

2.测试时面对scan函数反复输入错误的格式

3.链表next成员处理错误，导致断裂

注意到的加快速度的技巧：

1.chatGPT修改代码错误，但仍有局限：无法考虑到人工操作的失误（上面第二条）、非会员有长度和次数限制

2.注释不必太繁琐，在代码块写思路就好（不必一一解释低级代码，而是简要阐述高级的思想）

优化后：

1.加入了指向Node的指针类型LinkList，专用于指向头指针

        优点：1.使头指针更明显，不易与一般节点混淆

                2.使各函数接口更清晰，一目了然

                3.传递给插入函数的值的检测条件变成’$‘，不会存在检测占用某个数不能的情况

        缺点：容易混淆指向关系，如L和*L

        应对方法：目前是在LinkList的声明处写上说明（如：Node* L相当于LinkList L）

2.插入函数的位置形参考虑到了数值过大、过小的情况，除了用于停止输入的-1

3..删除了用于测试的、冗余的代码

仍存在的问题：

1.从第二次执行插入函数开始，每次调用会错误地弹出一条“太小”的提示信息，其它功能正常，这个错误暂时保留，等待有空时研究。

2.只使用一个源文件，没有将函数定义与主函数分离，使代码不易读

3.学长演示了一种只需两个形参的插入函数，仍能实现随机存储，是将data值在插入函数中等待输入吗