实验室考核总结

第一部分 C语言和python

1.请写出下面程序的输出结果。

#include<stdio.h>
int main(void){
	printf("%d\n",printf("Hello World!\n"));
	return 0;

输出结果
Hello World!
13
分析：printf的返回值为printf中字符的数量，所以为了执行%d的输出，所以必须先获得printf的返回值。
故先输出Hello World! 然后输出字符总数13
2.请写出下面程序的输出结果。

#include <stdio.h>
int main(void) {
int nums[3][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
printf("%d\n", nums[1][-2]);
printf("%d\n", nums[-1][5]);
printf("%d\n", -nums[1][5]);
return 0;
}

输出结果

2
3
-9

分析:无非是一个常见的二维数组，
那么num[1]代表第二个数组首元素的地址，[-2]则表示指针向前移两位即表示2
同理可得后两行答案为3，-9.
3.CSV的中文全称为_____________。CSV文件______（填写“是”或“不是”）纯
文本文件。
1.逗号分隔值文件
2.是
书上基本概念
4.csv.reader()中参数delimiter的作用是____________________________。
分隔符且默认为英语逗号
书上基本概念
5.使用pd.read_csv()读取CSV文件，返回值类型为______________。
返回值类型为数据框即Dataframe
6.构建一个学生类，包含学生的姓名，年龄，三科的成绩（高数，线代，离散），总
分，该类同时含有输出学生按某科成绩的排序的方法。
下面给出一组示例，斜体字为从键盘输入的内容：
请输入学生数量：3
请输入姓名：Tom
请输入年龄：18
请输入高数成绩：95
请输入线代成绩：93
请输入离散成绩：94
请输入姓名：Jerry
请输入年龄：18
请输入高数成绩：93
请输入线代成绩：96
请输入离散成绩：89
请输入姓名：Spike
请输入年龄：19
请输入高数成绩：92
请输入线代成绩：99
请输入离散成绩：85
请输入需要比较的成绩：线代
线代 成绩排名为：
第1名：Spike
第2名：Jerry
第3名：Tom
请在矩形框中和横线上完善代码，使其能够实现上面的功能。

class Student():
    def __init__(________, n):    # n为学生数量
        ________.stu = {}
        for i in range(n):
            name = str(input('请输入姓名：'))
            age = int(input('请输入年龄：'))
            score1 = int(input('请输入高数成绩：'))
            score2 = int(input('请输入线代成绩：'))
            score3 = int(input('请输入离散成绩：'))
    ————————————————————    
    def sortScore(________, val):
   ————————————————————
        print(val, '成绩排名为：')
        for i in range(n):        print(________________________________________________)
n = int(input('请输入学生数量：'))
a = Student(n)
sort_key = str(input('请输入需要比较的成绩：'))
a._________________________________________________________________

1.self 2.self
3.self.stu[name]=[]
self.stu[name].append(age)
self.stu[name].append({
‘高数’：score1，
‘线代’：score2，
‘离散’：score3
}）
self.stu[name][1][‘总分’]=sum(self.stu[name][1].value())
4.self
5.a=sorted(self.stu.items(),key=lambda item:item[1][1][val],reverse=Ture)
6.‘第{0:d}名:{1:s}’.format(i+1,a[i][0])
7.sortScore(sort_key)
说来惭愧，自学python时没有对类进行学习，结果惨不忍睹，要抽时间对类进行系统学习😥

第二部分 数据结构与算法

1.在循环队列中，当队列为空时，有front= =rear；而当所有队列空间全占满时，
也有front==rear。为了区别这两种情况，规定循环队列最多只能有
MAXSIZE-1个队列元素，当循环队列中只剩下一个空存储单元时，队列就已经
满了。因此，队列判空的条件是__________________，队列判满的条件是
。请简述循环队列的优点：_________

队列判空的条件为front= =rear
队列判满的条件是front==（rear+1）%MAXSIZE
循环队列优点：克服顺序队列的假溢出现象，使向量空间得到充分利用
2.对于一个具有n个结点的单链表，在已知的结点p后插入一个新结点的时间复
杂度为______，在给定值为x的结点后插入一个新结点的时间复杂度为______
O(1) O(X)

3.2010·考研真题 若元素a,b,c,d,e,f依次进栈，允许进栈、退栈操作交替进行
但不允许连续三次进行退栈操作，则不可能得到的出栈序列是______。
A.d,c,e,b,f,a B.c,b,d,a,e,f C.b,c,a,e,f,d D.a,f,e,d,c,b
分析：对于结果A的产生我们可以判断为：
a进b进c进d进d出c出e进e出b出f进f出a出，符合题意。
对于结果B的产生我们可以判断为：
a进b进c进c出b出d进d出a出e进e出f进f出，符合题意。
对于结果C的产生我们可以判断为：
a进b进b出c进c出a出d进e进e出f进f出d出，符合题意。
对于结果D的产生我们可以判断为：
a进a出b进c进d进e进f进f出e出d出c出b出，连续向外pop了四个元素，不满足题意，故选D。
4.回文链表
请判断一个单链表是否为回文链表。若链表为回文链表，函数返回true，否则，
返回false。链表的长度不超过50000。
语言：C

Definition for singly-linked list.
 *struct ListNode {
      int val;
      struct ListNode* next;
 };

bool isPalindrome(struct ListNode* head) {

函数实现
考核时我的想法就是可以将判断回文链表的问题转化为较为简单的判断回文数组问题，那么就需要定义一个数组来存储链表中每个元素的val值，遍历链表，将链表的val值赋给数组然后利用双指针遍历进行判断，下面为代码实现

int nums[50001];
int len=0;
while(head){
	nums[len++]=head->val;
	head=head->next;
}
for(int i =0,j=len-1;i<j;i++,j--){
	if (nums[i]!=nums[j]){
	return false;}
	}
	return true;
}

考核后我在看力扣官方题解时学到了另一种解法，即使用快慢指针和链表的反转，首先整俩指针，一个一次走一步，另一个一次走两步，那么当第二个指针到达链表尾部的时候，第一个链表刚好到达整个链表的中间位置，那么我们随之将前半部分链表反转，从表头和第一个指针的next分别往后遍历，判断每一次的val值是否相同，即可得到是否为回文链表
下面为代码实现

bool isPalindrome(struct ListNode* head){
    // 特殊情况的排除
    if(head == NULL || head->next == NULL)
        return true;
    if(head->next->next == NULL){
        if(head->val == head->next->val)
            return true;
        else
            return false;
    }

    struct ListNode *fastp, *slowp;
    fastp = head->next->next;
    slowp = head->next;

    // 快慢指针找到尾部及中部位置
    while(fastp && fastp->next != NULL){
        fastp = fastp->next->next;
        slowp = slowp->next;
    }

    // 翻转中部前链表序列
    struct ListNode *prep, *nextp;
    prep = nextp = NULL;
    while(head != slowp){
        nextp = head->next;
        head->next = prep;
        prep = head;
        head = nextp;
    }

    // 若结点个数为奇数，则舍弃中间结点
    if(fastp != NULL && fastp->next == NULL)
        slowp = slowp->next;

    // 回文匹配比较
    while(prep != NULL){
        if(prep->val != slowp->val)
            return false;
        prep = prep->next;
        slowp = slowp->next;
    }
    return true;
}

5.剑指offer31.栈的压入弹出序列
给定pushed和popped两个序列，每个序列中的值都不重复，只有当它们可
能是在最初空栈上进行的推入push和弹出pop操作序列的结果时，返回true；
否则，返回false。
提示：
(1)0 <= pushed.length == popped.length <= 1000
(2)0 <= pushed[i], popped[i] < 1000
(3)pushed是popped的排列。

刚看到这题时我就感觉很亲切，因为寒假看《大话数据结构》的时候看到了这个题型，但当时没有深思，所以思索了许久还是没什么好的思路。然后我师傅刚看这道题时给了我一个思路，下面是我根据思路而写的代码

bool validateStackSequences(int*pushed,int pushedSize,int*popped,int poppedSize){
	int i,j,k;
	int index=0;
	int index2=0;
	int num[poppedSize];
	for(i=0;i<=poppedSize;i++){
		j=popped[i];
		for(k=index;k<=pushedSize;k++){
			if (pushed[k]==j){
			num[j]++;
			index=k;
			index2++;//index2=2
			break;
			}
		}	
	}
		for(j=poppedSize;j>0;j--){
			if (num[j]!=1)	{
				for(i=0;i<pushSize;i++){//第一次遍历时j为4 
					if (popped[index2+1]=pushed[j])
						num[j]++;
						index2++;
					else return false;
				}
			}
		}
		return true;
}

我在代码中附加的注释是针对的情况为：
进入序列[1，2，3，4，5]和输出序列[3，5，4，2，1]
我先解释一下第一个嵌套for循环：先从输出序列的首开始遍历，如第一个为3，那么开始遍历输入序列，发现3所在的位置为第三位，那么我们创建一个空数列，并使其第三个位置+1，然后继续遍历输出序列，第二个数为5，那么从输入序列的第三位开始继续往后遍历，发现5的位置在第五位，那么空数列的第五位+1。
我们发现输出数列的第三位为4，接下来我们应该判断从输入数列的尾部往前遍历时未被标记的元素是否在已标记元素的邻位，当空数列的对应项为1时表示这个数之前已经被我们进行过判断了，即对它进行了标记，那么就应该对输入数列的4进行判断，4在已经出现的数字即5的邻位，那么这个出栈顺序时正确的，接下来依次对剩余数字进行判断即可得到答案。
（在下语言可能条理不是特别清晰，若对我的过程有疑问，可以在评论区留言，有时间就回😅）
6.实现一种算法，删除单向链表中间的node结点（即不是第一个或最后一个结点），假定你只能访问该结点。
示例：
输入：单向链表a->b->c->d->e->f中的节点c
结果：不返回任何数据，但该链表变为a->b->d->e->f
语言：C

Definition for singly-linked list.
  struct ListNode {
      int val;
      struct ListNode* next;
        };

这题说起来还有点坑，开始我还没看到给出的结点是要被删除的结点，默认给的是头结点，后来还是发现了，考核时对这题只想到了改变所给结点的val值的方法，即把原链表的c位置存储的值由c改为d，接着对链表后面进行相同操作，最后把多出来的一个结点free掉，和实验室所给出的答案大致相同，就是需要养成代码尽量精简的习惯。下面是组内给出的答案，我的代码多了一些可以省略的步骤就不丢人了😂

void deleteNode(struct ListNode* node) {
	struct ListNode*p=node,*q=node->next;
	p->val=q->val;
	p->next=q->next;
	free(p)

通过这次考核，我发现了自己在python学习方面的漏洞，数据分析部分的基础寒假记得也不是很牢，不过也强化了自己数据结构方面的理解，考核后认识到自己寒假学习中的问题，亡羊补牢、为时未晚，希望大家都能发现自己学习中的漏洞，通过我的博客能学到知识就更好了，加油，与大家共勉！(ง •_•)ง