2021寒假收假考核（改错）

2021寒假收假考核（改错）

1.第一部分第一题
请写出下面程序的输出结果。

对于printf函数，其返回值为输入字符串的宽度，且当多个printf函数嵌套使用时，程序从右向左运行，先执行最里面的printf语句。
故其输出为两行，第一行为Hello World！第二行为13
值得注意的是转义字符\n也算作一个字符。

2.第一部分第三题

CSV文件的全称为逗号分隔值，其英文为Comma-Separated Values。CSV文件是文本文件。
关于文本文件的定义，一下采用百度百科的描述

3.第一部分第四题

reader函数为python中csv模块中的一个函数，其功能是返回一个reader对象，利用该对象遍历csv文件中的行。 delimiter为reader函数中的关键字，表示分隔符，默认为delimiter = ‘,’

4.第一部分第五题

read_csv函数为python中pandas模块内的函数，其作用是读取csv文件中的数据并且转换成Dataframe数据框。

5.第一部分第六题



代码第一行 def init( ___,n) 为初始化方法，此处应填特殊参数self ，第二行采用self预先为将要输入的参数创建一个字典。
根据已知代码，第一个方框中应该将上面输入的数据保存进字典中，由下文代码 可知，在这一步还要求出每个人的总成绩

class Student():
    def __init__(self,n):
        self.stu = {}
        for i in range(n):
            name = str(input('请输入姓名：'))
            age = int(input('请输入年龄：'))
            score1 = int(input('请输入高数成绩：'))
            score2 = int(input('请输入线代成绩：'))
            score3 = int(input('请输入离散成绩：'))
            self.stu[name] = []
            self.stu[name].append(age)
            self.stu[name].append({
                '高数': score1,
                '线代': score2,
                '离散': score3
            })
            self.stu[name][1]['总分'] = sum(self.stu[name][1].values())
    def sortScore(self,val):
        a = sorted(self.stu.items(3), key=lambda item:item[1][1][val], reverse=True)
        print(val,'成绩排名为：')
        for i in range(n):
            print('第{0:d}名：{1:s}'.format(i+1,a[i][0]))
n = int(input('请输入学生数量：'))
a = Student(n)
sort_key = str(input('请输入需要比较的成绩：'))
a.sortScore(sort_key)

6.第二部分第一题

循环队列的判空条件为：front==rear
循环队列的判满条件为：(rear+1) % MAXSIZE == front
补充循环队列的通用长度计算公式：
（rear-front+MAXSIZE）% MAXSIZE

7.第二部分第二题

因为*p的结点位置已知，所以可以直接完成插入操作，不需要遍历链表。 时间复杂度为O(1)。
而在定值x所在的结点插入结点时，虽然知道x的值，但并不知道x所在结点的位置，所以需要遍历一次链表找到x，然后进行插入操作。时间复杂度为O(n)。
8.第二部分第三题

D 因为D的操作需要连续进行三次
A、B、C均可以通过交替进行的进栈出栈操作得到。
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退

9.第二部分第四题

思路1： 数组双指针
首先 将链表中的数复制给一个数组，然后分别在数组的首尾设置两个指针，从数组的两端向中点以此遍历

#include <stdio.h>
#include <stdlib.h>

struct ListNode {
	int val;
	struct ListNode* next; 
};

bool isPalindrome(struct ListNode* head) {
	int arr[100001], count = 0;
	while(head) {
		arr[count++] = head->val;
		head = head->next;
	}
	for(int i = 0, j = count-1; i < j; ++i, --j) {
		if(arr[i] != arr[j]) {
			return false;
		} 
	}
	return true;
} 

int main()
{
	return 0;
 } 

思路2： 可以用快慢指针的方法来判断回文链表，设置两个指针，一个为快指针，另一个为慢指针，快指针每次走两步即每次经过两个结点，慢指针每次走一步。
这样，当快指针都在尾端时，慢指针刚好走到了链表的中间位置。
此时，整条链表被慢指针从中间一分为二，第二段链表的首尾正好是慢指针和快指针，而第一段链表的首尾为头指针和慢指针。
这样可以同时对两端链表进行遍历，第一段从头指针到慢指针，第二段从快指针到慢指针，若每个结点的数据都相等，则为回文链表，返回true，否则返回false。

struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode* prev = NULL;
    struct ListNode* curr = head;
    while (curr != NULL) {
        struct ListNode* nextTemp = curr->next;
        curr->next = prev;
        prev = curr;
        curr = nextTemp;
    }
    return prev;
}

struct ListNode* endOfFirstHalf(struct ListNode* head) {
    struct ListNode* fast = head;
    struct ListNode* slow = head;
    while (fast->next != NULL && fast->next->next != NULL) {
        fast = fast->next->next;
        slow = slow->next;
    }
    return slow;
}

bool isPalindrome(struct ListNode* head) {
    if (head == NULL) {
        return true;
    }

    // 找到前半部分链表的尾节点并反转后半部分链表
    struct ListNode* firstHalfEnd = endOfFirstHalf(head);
    struct ListNode* secondHalfStart = reverseList(firstHalfEnd->next);

    // 判断是否回文
    struct ListNode* p1 = head;
    struct ListNode* p2 = secondHalfStart;
    bool result = true;
    while (result && p2 != NULL) {
        if (p1->val != p2->val) {
            result = false;
        }
        p1 = p1->next;
        p2 = p2->next;
    }

    // 还原链表并返回结果
    firstHalfEnd->next = reverseList(secondHalfStart);
    return result;
}

10.第二部分第五题



思路： 将输入的序列依次放入栈stack中，若栈顶元素与popped序列中的第一个元素相同，则将该元素出栈，知道当前栈顶元素与popped序列中的第一个元素不同，最后判断栈stack是否为空，若为空，返回true，否则返回false。

bool validateStackSequences(int* pushed, int pushedSize, int* popped, int poppedSize){
    int* stack = (int*)malloc(sizeof(int)* pushedSize); //创建名为Stack的栈
    int stackSize = 0;
    for(int i = 0, j = 0; i < pushedSize; i++) {
    	stack[stackSize] == pushed[i];
		stackSize++;
		while(stackSize && stack[stackSize-1] == popped[j]) {
			j++;
			stackSize--;
		}	
	}
    return stackSize == 0;
}

11.第二部分第六题


思路1: 将node-next结点中的值val赋值给node，然后删除掉node->结点即可

node->val = node->next->val;
node->next = node->next->next;

思路2： 将node下一个结点中的内容 赋值给 node 相当于把node结点给覆盖掉。
参考某大佬的图示：

代码为：

*node = *node->next;