寒假考核总结

寒假考核总结
第一部分：
1.请写出下面程序的输出结果

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

输出结果：
Hello World!
13
程序先执行printf内部，后执行外部，外部的printf返回的字符长度

3.CSV的中文全称为 逗号分隔值。CSV文件 是纯文本文件。

4.csv.reader()中参数 delimiter的作用是分割符，默认为英文逗号。

5.使用pd.read_csv()读取csv文件，返回值类型为数据框。

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__(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=sort(self.stu.items(),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)
         

类的总结：
1.python中定义类使用class关键字，class后面紧接类名，类名通常是大写开头的单词。
2.__init__方法的第一参数永远是self，表示创建的类实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身
3.self：
1）self其实就相当于C++中的this指针
2)、由同一个类可以生成无数对象，当一个对象的方法被调用的时候，对象会将自身的引用作为第一个参数传给该方法，那么python就知道需要操作哪个对象的方法了
self代表的当前的实例对象本身，这样在调用类方法等时Python就知道当前是哪个实例对象了,一个抽象类实例化后，实力对象为a，那么此时self就代表实例对象a。

第二部分：
1.在循环队列中,当队列为空时,有front= =rear；而当所有队列空间全占满时,也有front==rear。为了区别这两种情况，规定循环队列最多只能有MAXSIZE-1个队列元素，当循环队列中只剩下一个空存储单元时，队列就已经满了。因此，队列判空的条件是front= =rear，队列判满的条件是front= =(rear+1)%MAXSIZE 。请简述循环队列的优点：有效解决了以顺序表形式存储的队列的“假溢出”问题。

2.对于一个具有 n 个结点的单链表，在已知的结点*p 后插入一个新结点的时间复 杂度为O(1)，在给定值为 x 的结点后插入一个新结点的时间复杂度为O(N)。

3.若元素 a,b,c,d,e,f 依次进栈，允许进栈、退栈操作交替进行， 但不允许连续三次进行退栈操作，则不可能得到的出栈序列是 D。
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

D选项的顺序为a进a出b进c进d进e进f进f出e出d出c出b出,连续四次出栈操作，不和题意。

4.请判断一个单链表是否为回文链表。若链表为回文链表，函数返回true，否则，返回false。链表的长度不超过 50000。
语言：C

Definition for sing-linked list.
struct ListNode{
    int val;
    struct ListNode* next;
};
bool isPalindrome(struct ListNode* head){
}

函数实现：
方法1：

bool ispalindrome(struct ListNode* head){
	int nums[50000];
	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;
}

解法1创建一个数组，将链表中的数据储存至数组，之后比较数组头尾是否相同。
方法2：

//翻转列表 
struct ListNode*reverse(struct ListNode* head){
	struct ListNode* pre=NULL;
	struct ListNode* cur=head;
	while(cur){
		struct ListNode* nextNode=cur->next;
		cur->next=pre;
		pre=cur;
		cur=nextNode;
	}
	return pre;
} 
//快慢指针
struct ListNode* endofFirstHalf(struct ListNode* head){
	struct ListNode* fast=head;
	struct ListNode* slow=head;
	while(fast->next && fast->next->next){
		fast=fast->next->next;
		slow=slow->next;
	}
	return slow;
} 
//两链表比较
bool isPalindrome(struct ListNode* dead){
	if(head==NULL){
		return true;
	}
	struct ListNode* firstHalfEnd=endofFirstHalf(head);
	struct ListNode* secondHalfStart=reverse(firstHalfEnd->next);
	struct ListNode* p1=head;
	struct ListNode* p2=secondHalfStart;
	bool ret=true;
	while (ret && p2){
		if(p1->val!=p2->val){
			ret=false;
		}
		p1=p1->next;
		p2=p2->next;
	}
	return ret;
} 

解法2运用快慢指针和翻转列表的方法，快指针每次走两格，满指针走一格，当快指针走到链表尾时慢指针走到链表中部，将后一部分链表翻转后两链表相比较判断是否相同。

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

bool validateStackSequences(int* pushed, int pushedSize, int* poped, int popedSize){
	int* stack=(int*)malloc(sizeof(int)*pushedSize);
	int stackSize=0;
	for(int i=0,j=0;i<pushedSize;i++){
		stack[stackSize]=push[i];
		stackSize++;
		while(stackSize&&stack[stackSize-1]==popped[j]){
			j++;
			stackSize--;
		}
		return stackSize==0;
	}
}

题中给定pop和push两个序列，使用循环将push的数存入stack，与数组比较判断是否出栈，结果若stack为空栈，则返回true。

6.实现一种算法，删除单向链表中间的结点（即不是第一个或最后一个结 点），假定你只能访问该结点。
示例：
输入：单向链表 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;
}

代码实现：

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

void deletNode(struct ListNode*node){
       *node=*node->next;
}