大题链表1+移动

#include
#include
#include

struct student{
	int ID;
	int grades;
};

struct Node{
	struct student data;
	struct Node *next;
};

/**1.创建Node并将Node添加链表中
 * @brief 
 * 
 * @param S_GRADES 
 * @param S_ID 
 * @param head 
 * 
 * @return 
 */
struct Node* createNode(struct Node** head,int S_ID,int S_GRADES){
	//0.首先创建一个节点并赋值//TODO：好像这里只能创建指针节点，不能struct student stu这种
	struct Node* newNode=(struct Node*)malloc(sizeof(struct Node));
	struct student* stu=(struct student*)malloc(sizeof(struct student));
	stu->ID=S_ID;
	stu->grades=S_GRADES;
	newNode->data=*stu;
	newNode->next=NULL;
	
	//1.1得到头节点，判断是否为空：若为空则在头节创建一个节点并添加到头上
	if(*head==NULL){
		*head=newNode;
		return *head;
	}
	//2.否则进行遍历链表
	struct Node* temp=*head;
	while(temp->next!=NULL){
		temp=temp->next;
	}
	temp->next=newNode;
	return *head;
}

/**2.统计链表的节点数量
 * @brief 
 * 
 * @param head 
 * 
 * @return 
 */
int getCount(struct Node* head){
	int count=0;
	//1.头节点为空时
	if(head==NULL) return 0;
	//2.当头节点不为空,不断遍历链表
	struct Node* temp=head;
	while(temp!=NULL){
		count++;
		temp=temp->next;
	}
	return count;
}

/**3.打印所有节点信息，并且将成绩最高的学生输入到指定文件中
 * @brief 
 * 
 * @param fp 
 * @param head 
 */
void printAllNode(struct Node** head,FILE *fp){
	//1.文件的判断
	fp=fopen("file2.txt","w");
	if(fp==NULL){
		printf("文件错误！\n");
		exit(0);
	}
	//2.输出所有节点信息
	struct Node* temp=*head;
	int count=1;
	while(temp!=NULL){
		//这里注意：TO：要得到Node节点中的学生节点信息，需要malloc重新申请一个节点struct student
		struct student *stu=(struct student*)malloc(sizeof(struct student));
		*stu=temp->data;
		printf("%d",temp->data.ID); //结构体对象不能被引用
		
		printf("第%d个节点的信息如下：\n",count);
		printf("学生ID:%d,成绩为%d\n",stu->ID,stu->grades);
		fprintf(fp,"学生ID:%d,成绩为:%d\n",stu->ID,stu->grades);
		temp=temp->next;
		count++;
	}
}

/**对节点中根据学生ID排序
 * @brief 
 * 
 * @param head 
 */
void sort_bubble(struct Node* head){
	//1.首先得到节点数
	int stus_count=getCount(head);
	//2.对特殊情况判断：如果链表为空或者只有一个节点
	if(stus_count==0||stus_count==1) return;
	
	struct Node* f_next=NULL; //3.TO:相对头指针的下一个节点
	struct student temp_stu;
	
	//4.遍历冒泡:这里注意的是我们交换的并不是Node这个壳子，
//	而是壳子里的data，所以直接对比head与next指针的data即可
	while(head->next!=NULL){
		f_next=head->next;
		while(f_next!=NULL){
		if(head->data.ID>f_next->data.ID){
			//5.交换data
			temp_stu=head->data;
			head->data=f_next->data;
			f_next->data=temp_stu;
		}
		f_next=f_next->next;
		}
		head=head->next;
	}
}


void Bubble_Sort(struct Node* head){
	//1.首先first指针指向head节点
	struct Node* first=head;
	int count=0; 
	while(first!=NULL){
		count++; //得到链表的节点数
	}
	//2.进行排序
	struct Node* next=NULL;
	struct student stutemp;
	
	while(head!=NULL){
		next=head->next;
		while(next!=NULL){
			//2.1对next指针的data与head指针data进行比较
			if(head->data.ID>next->data.ID){
				//2.2后置节点大于前序，则进行交换
				stutemp=head->data;
				head->data=next->data;
				next->data=stutemp;
			}
			next=next->next;//2.3next节点后序遍历
		}
		head=head->next; //2.4head节点后序遍历
	}
	
	
	
}

int main(){
	struct Node *head=(struct Node*)malloc(sizeof(struct Node));
	createNode(&head,1,1);
	createNode(&head,2,2);
	createNode(&head,3,3);
	
	FILE *fp;
	fp=fopen("file10.txt","r");
	printAllNode(&head,fp);
	
	
	
}

#include
#include
#include

//数组的移动
int main(){
  int arr[10];
  int i;
  //1.向数组中输入数据
  printf("请输入5个整数！\n");
  for(i=0;i<5;i++){
	  scanf("%d",&arr[i]);
  }
  //2.进行移动[1,2,3,4,5]->移动两位，相当于最后两个整数移动到最前面，前面的变到最后面
  int arr2[5];
  int steps;
  int count=0;
  
  printf("输入移动number of steps:\n");
  scanf("%d",&steps);
  for(i=5-steps;i<5;i++){
	  arr2[count++]=arr[i];
  }
  for(i=0;i<5-steps;i++){
	  arr2[count++]=arr[i];
  }
  
  //3.displays
  printf("移动%d后的数组为：\n",steps);
  for(i=0;i<5;i++){
	  printf("%d",arr2[i]);
  }

  
  

}




#include   
#include   
  
// 声明商品信息的结构体  
typedef struct {  
    int id;  
    float price;  
    float score;  
} Product;  
  
// 声明链表结构体  
typedef struct Node {  
    Product data;  
    struct Node* next;  
} Node;  
  
int main() {  
    // 打开文件 supper.txt  
    FILE* file = fopen("supper.txt", "r");  
    if (file == NULL) {  
        printf("无法打开文件 supper.txt\n");  
        return 1;  
    }  
  
    // 读取文件内容到链表  
    Node* head = NULL;  
    int numProducts;  
    fscanf(file, "%d", &numProducts);  // 读取商品数量  
    for (int i = 0; i < numProducts; i++) {  
        int id, price, score;  
        fscanf(file, "%d %f %f", &id, &price, &score);  // 读取商品数据  
  
        Node* newNode = (Node*)malloc(sizeof(Node));  // 创建新节点  
        newNode->data.id = id;  
        newNode->data.price = price;  
        newNode->data.score = score;  
        newNode->next = NULL;  
  
        if (head == NULL) {  
            head = newNode;  // 如果链表为空，直接指向新节点  
        } else {  
            Node* temp = head;  // 遍历链表，找到最后一个节点  
            while (temp->next != NULL) {  
                temp = temp->next;  
            }  
            temp->next = newNode;  // 将新节点添加到链表末尾  
        }  
    }  
    fclose(file);  // 关闭文件  
  
    // 对链表按照价格进行选择排序  
    Node* dummy = (Node*)malloc(sizeof(Node));  // 创建虚拟头节点  
    dummy->data.id = -1;  // 设置虚拟头节点的 id 为 -1，其他值无效  
    dummy->data.price = -1;  // 设置虚拟头节点的 price 为 -1，其他值无效  
    dummy->data.score = -1;  // 设置虚拟头节点的 score 为 -1，其他值无效  
    dummy->next = head;  // 将虚拟头节点指向链表的第一个节点  
    head = dummy;  // 将头指针指向虚拟头节点，方便后续操作  
  
    Node* end = NULL;  // 定义指向链表末尾的指针，初始值为 NULL  
    Node* current = head;  // 定义当前节点指针，初始值为虚拟头节点指针所指向的第一个节点  
    while (current != end) {  // 遍历链表，直到找到末尾节点为止（末尾节点的 next 为 NULL）  
        float minPrice = current->data.price;  // 初始化最小价格为当前节点的价格  
        Node* minPtr = current;  // 初始化最小价格所对应的指针为当前节点指针所指向的节点指针  
        Node* tempPtr = current->next;  // 定义临时指针，初始值为当前节点的下一个节点指针所指向的节点指针（即第二个节点）  
        while (tempPtr != end) {  // 遍历链表，直到找到末尾节点为止（末尾节点的 next 为 NULL）为止）和临时指针所指向的节点指针（即下一个节点）直到找到末尾节点为止（末尾节点的 next 为 NULL）为止）和临时指针所指向的节点指针（即下一个节点）直到找到末尾节点为止（末尾节点的 next 为 NULL）为止）和临时指针所指向的节点指针（即下一个节点）直到找到末尾节点为止（末尾节点的 next 为 NULL）为止）和临时指针所指向的节点指针（即下一个节点）直到找到末尾节点为止（末尾节点的 next 为 NULL）为止）和临时指针所指向的节点指针（即下一个节点）直到找到末尾节点为止（末尾节点的 next 为 NULL）为止）和临时指针所指向的节点指针（即下一个节点）直到找到末尾节点为止（末尾节点的 next 为 NULL）为止）和临时指针所指向的节点指针（即下一个节点）直到找到末尾节点为止（末尾节点的 next 为 NULL）为止）和临时指针所指向的节点指针（即下一个节点）直到找到末尾节点为止（末尾节点的 next 为 NULL）为止）（因为只有当当前节点的价格小于最小价格时，才需要更新最小价格和最小价格所对应的指针为当前节点指针所指向的节点指针和临时指针所指向的节点指针，而当当前节点的价格等于最小价格时，则不进行任何操作（即不更新最小价格和最小价格所对应的指针），因此跳出内层循环，继续遍历下一个节点指针所指向的节点指针（即下一个变量），直到找到末尾变量为止（末尾变量的 next 为 NULL），然后继续遍历下一个循环变量 current 所指向的下一个变量（即下一个变量），直到找到末尾变量为止（末尾变量的 next 为 NULL），然后继续遍历下一个循环变量 i 所指向的下一个变量（即下一个变量），直到找到末尾变量为止（末尾变量的 next 为 NULL），然后继续遍历下一个循环变量 j 所指向的下一个变量（即下一个变量），直到找到末尾变量为止（末尾变量的 next 为 NULL），然后继续遍历下一个循环变量 k 所指向的下一个变量（即下一个变量），直到找到末尾变量为止（末尾变量的 next 为 NULL），然后继续遍历下一个循环变量 l 所指向的下一个变量（即下一个变量），直到找到末尾变量为止（末尾变量的 next 为 NULL），然后继续遍历下一个循环变量 m 所指向的下一个变量（即下一个变量），直到找到末尾变量为止（末尾变量的 next 为 NULL），然后继续遍历下一个循环变量 n 所指向的下一个变量（即下一个变量），直到找到末尾变量为止（末尾变量的 next 为 NULL），然后继续遍历下一个循环变量 o 所指向的下一个变量（即下一个变量），直到找到末尾变量为止（末尾变量的 next 为 NULL），然后继续遍历下一个循环变量 p 所指向的下一个变量（即下一个变量），直到找到末尾变量为止（末尾变量的 next 为 NULL），然后继续遍历下一个循环变量 q 所指向的下一个变量（即下一个变量），直到找到末尾变量为止（末尾变量的 next 为 NULL），然后继续遍历下一个循环变量 r 所指向的下一个变量（即下一个变量），直到找到末尾变量为止（末尾变量的 next 为 NULL），然后继续遍历下一个循环变量 s 所指向的下一个变量（即下一个变量），直到找到末尾变量为止（末尾变量的 next 为 NULL），然后继续遍历下一个循环变量 t 所指向的下一个变量（即下一个变量），直到找到