链表练习

最新推荐文章于 2024-05-01 10:28:08 发布
最新推荐文章于 2024-05-01 10:28:08 发布
阅读量189 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/snowyuuu/article/details/100601843
版权 
//输入一个文件名或两个文件名（成绩表），解析内部学生成绩，然后计算总分，
//如果两个文件名，需要汇总两个表，然后按照成绩高低排列输出整表。
//（PS : 成绩表为CSV格式，已逗号分隔，暂不考虑异常输入。）

#include "count_grade.h"
#include <stdio.h>
#include<string.h>
#include <windows.h>

int main(int argc, char* argv[])
{
	FILE* fp = NULL;
	char* filename = NULL;
	char* file1_buf = NULL;
	char* line_buf = NULL;
	struct student stu[LSIZE] = { 0 };
	char ch = 0;
	int rows = 0;
	int first_line_len = 0;
	int line = 1;
	Item temp = { 0 };
	List student = NULL;

	FILE* fp2 = NULL;
	char* file2name = NULL;
	char* file2_buf = NULL;
	char* line2_buf = NULL;
	struct student stu2[LSIZE] = { 0 };
	char ch2 = 0;
	int rows2 = 0;
	int first_line_len2 = 0;
	int line2 = 1;
	Item temp2 = { 0 };
	List student2 = NULL;

	if (argc != 3)
	{
		printf("Usage:%s filemane\n", argv[0]);
		exit(EXIT_FAILURE);
	}
	fp = fopen(argv[1], "rb");
	if (NULL == fp)
	{
		fprintf(stderr, "Can't open %s\n", argv[1]);
		exit(EXIT_FAILURE);
	}
	fseek(fp, 0L, SEEK_END);
	int size = ftell(fp);

	file1_buf = (char*)malloc(size + 1);
	memset(file1_buf, 0, size + 1);
	line_buf = (char*)malloc(size + 1);
	memset(line_buf, 0, size + 1);

	filename = argv[1];
	fp = fopen(filename, "rb");
	if (NULL == fp)
	{
		fprintf(stderr, "Can't open %s\n", filename);
		exit(EXIT_FAILURE);
	}


	//计算行数
	while (EOF != (ch = getc(fp)))
	{
		if ('\n' == ch)
		{
			++rows;
		}
	}
	rewind(fp);
	//计算第一行的字符数
	while ('\n' != (ch = getc(fp)))
	{
		++first_line_len;
	}
	//让句柄偏移到第二行
	fseek(fp, first_line_len + 1, SEEK_SET);

#if 0
	int index = 0;
	while (line < rows)
	{
		read_line(fp, line_buf, size); //读出每一行
		parse_line(line_buf, &(stu[index]), line);//把每一行写入结构体
		++line;
		++index;

	}
	for (index = 0; index < rows - 1; ++index)
	{
		calculate_total_grade(&(stu[index]), rows);
	}
#endif
	int index = 0;
	int valid_line_num = 0;
	while (line < rows)
	{
		read_line(fp, line_buf, size); //读出每一行
		valid_line_num += parse_line(line_buf, &(stu[index]));//把每一行写入结构体
		++line;
		++index;
	}

	InitializeList(&student);//初始化链表;
	for (int z = 0; z < valid_line_num; z++)
	{
		AddItem(&student, &stu[z]);
	}
	printf("show the information of file1: \n");
	//Showstudent(temp, &student);
	calculate_total_grade(&student);

	//打开第二个文件
	fp2 = fopen(argv[2], "rb");
	if (NULL == fp2)
	{
		fprintf(stderr, "Can't open %s\n", argv[2]);
		exit(EXIT_FAILURE);
	}
	fseek(fp2, 0L, SEEK_END);
	int size2 = ftell(fp2);
	file2_buf = (char*)malloc(size2 + 1);
	memset(file2_buf, 0, size2 + 1);
	line2_buf = (char*)malloc(size2 + 1);
	memset(line2_buf, 0, size2 + 1);
	file2name = argv[2];
	fp2 = fopen(file2name, "rb");
	if (NULL == fp2)
	{
		fprintf(stderr, "Can't open %s\n", file2name);
		exit(EXIT_FAILURE);
	}
	//计算行数
	while (EOF != (ch2 = getc(fp2)))
	{
		if ('\n' == ch2)
		{
			++rows2;
		}
	}
	rewind(fp2);
	//计算第一行的字符数
	while ('\n' != (ch2 = getc(fp2)))
	{
		++first_line_len2;
	}
	//让句柄偏移到第二行
	fseek(fp2, first_line_len2 + 1, SEEK_SET);
	int index2 = 0;
	int valid_line_num2 = 0;//读取的行数
	while (line2 < rows2)
	{
		read_line(fp2, line2_buf, size2); //读出每一行
		valid_line_num2 += parse_line(line2_buf, &(stu2[index2]));//把每一行写入结构体
		++line2;
		++index2;
	}
	InitializeList(&student2);//初始化链表;
	for (int z = 0; z < valid_line_num2; z++)
	{
		AddItem(&student, &stu2[z]);
	}
	printf("show the information of file2: \n");
	//Showstudent(temp2, &student);
	calculate_total_grade( &student);//合并后计算总分
	printf("print combine file: \n");
	//Showstudent(temp, &student);
	Sort(&student);//排序
	printf("sort from high to low:\n");
	Showstudent(temp, &student);
	//单链表逆序打印
	Node* NewList = PrintReverse(&student);
	printf("sort from low to high:\n");
	Showstudent(temp, &NewList);

	//双向链表逆序打印
	//创建一个双向链表
	student = NULL;
	DListInitializeList(&student);
	for (int z = 0; z < valid_line_num; z++)
	{
		DListAddItem(&student, &stu[z]);
	}
	printf("Dlist:\n");
	DShowstudent(temp, &student);
	for (int z = 0; z < valid_line_num2; z++)
	{
		DListAddItem(&student, &stu2[z]);
	}
	printf("Dlist combine:\n");
	DShowstudent(temp, &student);
	Dcalculate_total_grade(temp, &student);//合并后计算总分
	//排序
	DSort(&student);
	printf("sort from high to low:\n");
	DShowstudent(temp, &student);
	//逆序打印
	DPrintReverse(temp, &student);
	printf("Dsort from low to high:\n");
	Showstudent(temp, &student);
	int DelineGrade = 0;
	printf("Input the lowest number:");
	scanf("%d", &DelineGrade);
	EraseStudent(&student, DelineGrade);
	printf("more than %d:\n",DelineGrade);
	Showstudent(temp, &student);
	WriteF(temp, &student);

	ListDestroy(&student2);
	ListDestroy(&student);
	fclose(fp);
	fclose(fp2);
	free(file1_buf);
	file1_buf = NULL;
	free(file2_buf);
	file2_buf = NULL;
	free(line_buf);
	line_buf = NULL;
	free(line2_buf);
	line2_buf = NULL;
	system("pause");
	return 0;
}
//list.c
#include"count_grade.h"
#include<assert.h>
#include<stdio.h>
#include<string.h>

//链表初始化，创建空链表
void InitializeList(List *ppFirst)
{
	*ppFirst = NULL;
	return;
}

//尾插添加学生信息
CopyToItem(Node* pNode, Item *item)
{
	//pNode->item = item;
	int size = sizeof(Item);
	memcpy(&(pNode->item), item, size);
}
void AddItem(List *ppFirst, Item *item)
{
	Node* pNewNode = NULL;
	Node* pCur = *ppFirst;
	int size = sizeof(Node);
	pNewNode = (Node *)malloc(sizeof(Node));
	memset(pNewNode, 0x0, sizeof(Node));
	if (NULL == pNewNode)
	{
		printf("Fail to malloc the size\n");
		exit(EXIT_FAILURE);
	}
	CopyToItem(pNewNode, item);
	pNewNode->next = NULL;

	if (pCur == NULL)
	{
		*ppFirst = pNewNode;//链表为空，把新开辟的空间放在链表头
	}
	else
	{
		while (pCur->next != NULL)
		{
			pCur = pCur->next;
		}
		pCur->next = pNewNode;
	}
	return;
}
//打印学生信息
void Showstudent(Item item, List *ppFirst)
{
	Node *pNode = *ppFirst;
	for (pNode = *ppFirst; pNode != NULL; pNode = pNode->next)
	{
		printf("%d,%s, %s, %d, %d, %d,%d->\n", pNode->item.number, pNode->item.sex,
			pNode->item.name, pNode->item.chinese_grade,
			pNode->item.math_grade, pNode->item.english_grade, pNode->item.total_grade);
	}
	return;
 }
//计算每个学生的总分
void calculate_total_grade(List *ppFirst)
{
	Node *pNode = *ppFirst;
	for (pNode = *ppFirst; pNode; pNode = pNode->next)
	{
		int total_grade = 0;
		total_grade = pNode->item.chinese_grade + pNode->item.math_grade + pNode->item.english_grade;
		pNode->item.total_grade = total_grade;
		printf("the id is %d:the total_grade of %s is %d\n", pNode->item.number, pNode->item.name, total_grade);
	}
	return;
}

void swap(Node* p1, Node* p2)
{
	Node* p3 = p2->next;
	p1->next = p3;
	p2->next = p1;
}
void swap2(Node* p0,Node* p1, Node* p2)
{
	Node* p3 = p2->next;
	p1->next = p3;
	p2->next = p1;
	p0->next = p2;
}
void Sort(List *ppFirst)
{
	Node* pPre = NULL;
	Node* pCur = NULL;
	Node* first = NULL;
	Node* second = NULL;
	Node* pTail = NULL;

	while (pCur != pTail)
	{
		first = *ppFirst;
		second = (*ppFirst)->next;

		if ((first->item.total_grade) < (second->next->item.total_grade))
		{
			swap(pCur, pCur->next);
			*ppFirst = pCur->next;
		}
		
		pCur = second;
		pPre = first;
		while (pCur->next != pTail)
		{
			if ((pCur->item.total_grade) < (pCur->next->item.total_grade))
			{
				swap2(pPre,pCur, pCur->next);
				continue;
			}
			pCur = pCur->next;
			pPre = pPre->next;
		}
		pTail = pCur;//把tail重新指向NULL
		pCur = *ppFirst;
	}
	return;
}
#if 0
void BubbleSort(Item item, List *ppFirst)
{
	Node* pCur = NULL;
	Node* pTail = NULL;
	pCur = *ppFirst;
	while (pCur != pTail)
	{
		while (pCur->next != pTail)
		{
			if ((pCur->item.total_grade) < (pCur->next->item.total_grade))
			{
				Item temp = pCur->item;
				pCur->item = pCur->next->item;
				pCur->next->item = temp;
			}
			pCur = pCur->next;
		}
		pTail = pCur;//把tail重新指向NULL
		pCur = *ppFirst;
	}
	return;
}
#endif

//void ListPopFront(List *ppFirst,Item item)
//{
//	//开辟新空间并且写入item
//	Node *pNewNode = NULL;
//	pNewNode = (Node *)malloc(sizeof(Node));
//	memset(pNewNode, 0x0, sizeof(Node));
//	if (NULL == pNewNode)
//	{
//		printf("Fail to malloc the size\n");
//		exit(EXIT_FAILURE);
//	}
//	CopyToItem(pNewNode, &item);
//	pNewNode->next = NULL;
//	//头插
//	pNewNode->item = item; //b
//	pNewNode->next = *ppFirst; //a point
//	*ppFirst = pNewNode;//更新头结点
//
//	return;
//}
//void ListPushFront(List *ppFirst)
//{
//	Node *pCur = *ppFirst;
//	*ppFirst = pCur->next;
//	free(pCur);
//}


//逆序打印
Node* PrintReverse( List *ppFirst)
{
	Node* pCur = *ppFirst;

	Node* new_list_head = (Node*)malloc(sizeof(Node));
	new_list_head->next = NULL;
	new_list_head->item = pCur->item;

	while (NULL != pCur->next)
	{
		Node *new_node = (Node*)malloc(sizeof(Node));

		new_node->item = pCur->next->item;
		new_node->next = new_list_head;
		new_list_head = new_node;
		pCur = pCur->next;
	}
	return new_list_head;
}

//销毁链表
void ListDestroy(List *ppFirst)
{
	assert(ppFirst != NULL);

	Node *pNode = *ppFirst;
	Node *pNext = NULL;

	while (pNode != NULL)
	{
		pNext = pNode->next;//用一个变量记录下一个结点
		free(pNode);//释放当前结点
		pNode = pNext;//更新结点
	}
	*ppFirst = NULL; //释放头指针
	return;
}

//Dlist.c

#include "count_grade.h"

void DListInitializeList(List* ppFirst)
{
	*ppFirst = NULL;
	return;
}

CopyToDItem(Node* pNode, struct student* item)
{
	int size = sizeof(Item);
	memcpy(&(pNode->item), item, size);
}
void DListAddItem(List *ppFirst, struct student *stu)
{
	Node* pNewNode = NULL;
	Node* pCur = *ppFirst;
	pNewNode = (Node *)malloc(sizeof(Node));
	memset(pNewNode, 0x0, sizeof(Node));
	if (NULL == pNewNode)
	{
		printf("Fail to malloc the size\n");
		exit(EXIT_FAILURE);
	}
	CopyToDItem(pNewNode, stu);
	//尾插
	if (pCur == NULL)
	{
		//链表为空，把新开辟的空间放在链表头
		*ppFirst = pNewNode;
		pNewNode->next = NULL;
		pNewNode->pre = NULL;

	}
	else
	{
		while (pCur->next != NULL)
		{
			pCur = pCur->next;

		}
		pNewNode->next = pCur->next;
		pNewNode->pre = pCur;
		pCur->next = pNewNode;
	}
	return;
}

//打印学生信息
void DShowstudent(Item item, List *ppFirst)
{
	Node *pNode = *ppFirst;
	for (pNode = *ppFirst; pNode != NULL; pNode = pNode->next)
	{
		printf("%d,%s, %s, %d, %d, %d,%d<->\n", pNode->item.number, pNode->item.sex,
			pNode->item.name, pNode->item.chinese_grade,
			pNode->item.math_grade, pNode->item.english_grade, pNode->item.total_grade);
	}
	return;
}

//计算每个学生的总分
void Dcalculate_total_grade(Item item, List *ppFirst)
{
	Node *pNode = *ppFirst;
	for (pNode = *ppFirst; pNode; pNode = pNode->next)
	{
		int total_grade = 0;
		total_grade = pNode->item.chinese_grade + pNode->item.math_grade + pNode->item.english_grade;
		pNode->item.total_grade = total_grade;
		printf("the id is %d:the total_grade of %s is %d\n", pNode->item.number, pNode->item.name, total_grade);
	}
	return;
}
void Swap(Node* p1, Node* p2)
{
	Node* p4 = p2->next;
	Node* p0 = p1->pre;

	p1->next = p4;
	p2->next = p1;
	if (p4 != NULL)
	{
		p4->pre = p1;
	}
	if (p1->pre != NULL)
	{
		p0->next = p2;
	}
	p2->pre = p1->pre;
	p1->pre = p2;
}
void DSort(List *ppFirst)
{
	Node* pCur = NULL;
	Node* pTail = NULL;
	pCur = *ppFirst;
	while (pCur != pTail)
	{
		while (pCur->next != pTail)
		{
			if ((pCur->item.total_grade) < (pCur->next->item.total_grade))
			{
				Swap(pCur, pCur->next);
				continue;
			}
			pCur = pCur->next;
		}
		pTail = pCur;//把tail重新指向
		pCur = *ppFirst;
	}
	return;
}
#if 0
void DSort(Item item, List *ppFirst)
{
	Node* pCur = NULL;
	Node* pTail = NULL;
	pCur = *ppFirst;
	while (pCur != pTail)
	{
		while (pCur->next != pTail)
		{
			if ((pCur->item.total_grade) < (pCur->next->item.total_grade))
			{
				Item temp = pCur->item;
				pCur->item = pCur->next->item;
				pCur->next->item = temp;
			}
			pCur = pCur->next;
		}
		pTail = pCur;//把tail重新指向NULL
		pCur = *ppFirst;
	}
	return;
}
#endif

void ExchageNode(Node* p1, Node*p2)
{
	Node* p3 = p2->next;
	
	p1->next = p3;
	p2->next = p1;
	if (NULL != p3)
	{
		p3->pre = p1;
	}
	p2->pre = p1->pre;
	p1->pre = p2;
}
void DPrintReverse(Item item, List *ppFirst)
{
	Node* pNode = *ppFirst;
	while ((pNode->next) != NULL)
	{
		Node* pNext = pNode->next;
		ExchageNode(pNode, pNext);
		*ppFirst = pNext;//更新链表头
		while ((pNext->pre) != NULL)
		{
			ExchageNode(pNext->pre, pNext);
			*ppFirst = pNext;
		}
	}
}

#if 0
	Node *pNode = *ppFirst;
	Node *pNext = pNode->next;
	Node *pTail = NULL;

	Node *NewHeadNode = (Node*)malloc(sizeof(Node));

	NewHeadNode->item = (*ppFirst)->item;
	NewHeadNode->next = NULL;
	while (NULL != pNext)
	{
		pTail = pNext->next;
		Node *FNewNode = (Node*)malloc(sizeof(Node));
		FNewNode->item = pNext->item;
		NewHeadNode->pre=FNewNode;
		FNewNode->next = NewHeadNode;
		NewHeadNode = FNewNode;
		pNode = pNext;
		pNext = pTail;
	}
	return NewHeadNode;
}
#endif

int ListErase(List *ppFirst, Node* pPos)
{
	if (*ppFirst == pPos)
	{
		Node *pOldFirst = *ppFirst;
		*ppFirst = (*ppFirst)->next;
		(*ppFirst)->pre = NULL;
		free(pOldFirst);
		return 1;
	}

	Node *pCur = *ppFirst;
	for (pCur = *ppFirst; pCur->next != pPos; pCur = pCur->next)
	{
		;
	}
	pCur->next = pPos->next;
	pPos->next->pre = pPos->pre;
	free(pPos);
	return 0;
}
void EraseStudent(List *ppFirst, int DelineGrade)
{
	Node *pNode = *ppFirst;
	while (pNode)
	{
		if ((pNode->item.total_grade) < DelineGrade)
		{
			int ret = ListErase(ppFirst, pNode);
			if (1 == ret)
			{
				pNode = *ppFirst;
				continue;
			}
			pNode = pNode->pre;
		}
		pNode = pNode->next;

	}
	return;
}

void WriteF(Item item, List *ppFirst)
{
	Node *pNode = *ppFirst;
	FILE* fp = NULL;
	fp = fopen(" output.csv", "wb+");
	if (NULL == fp)
	{
		fprintf(stderr, "Can't open %s\n", " output.csv");
		exit(EXIT_FAILURE);
	}

	while (pNode)
	{
		fprintf(fp, "%d,%s, %s, %d, %d, %d,%d\n",
			pNode->item.number, pNode->item.sex,
			pNode->item.name, pNode->item.chinese_grade,
			pNode->item.math_grade, pNode->item.english_grade,
			pNode->item.total_grade);
		pNode = pNode->next;
	}

	//fwrite()
	fclose(fp);
	return;
}

#ifndef COUNT_GRADE_H
#define COUNT_GRADE_H
#include <stdio.h>
#include<string.h>
#include <stdlib.h>
#include<stdbool.h>

#define LSIZE 100
typedef struct  student
{
	int number;
	char name[LSIZE];
	char sex[LSIZE];
	int math_grade;
	int chinese_grade;
	int english_grade;
	int total_grade;
};
typedef struct  student Item;
typedef struct node
{
	Item item;// 存放元素值
	struct node* next;//指向后继节点
	struct node* pre;
} Node; //单链表节点类型名

typedef Node* List;//该类型的指针名 

typedef struct  student2
{
	int number;
	char name[LSIZE];
	char sex[LSIZE];
	int math_grade;
	int chinese_grade;
	int english_grade;
};


void read_line(FILE* fp, char* line_buf, int size);
int parse_line(char *line_buf, struct student *stu);
//void calculate_total_grade(struct student *stu, int rows);


//创建一个List类型的变量。List student;
//创建一个Item类型的变量。 Item temp;
//初始化链表为空。 
//在链表末尾添加项。
//访问链表中的每个项并显示它们。
//释放分配的内存
void InitializeList(List *ppFirst);//初始化链表;
void AddItem(List *ppFirst, Item *item);
void Showstudent(Item item, List *ppFirst);
void calculate_total_grade(List *ppFirst);
void Sort(List *ppFirst);
Node* PrintReverse(List *ppFirst);
void ListDestroy(List *ppFirst);

void DListInitializeList(List* ppFirst);
void DListAddItem(List *ppFirst, struct student *stu);
void DShowstudent(Item item, List *ppFirst);
void Dcalculate_total_grade(Item item, List *ppFirst);
void DSort(List *ppFirst);
void DPrintReverse(Item item, List *ppFirst);
void EraseStudent(List *ppFirst, int DelineGrade);
void WriteF(Item item, List *ppFirst);






#endif
#include "count_grade.h"
#include <stdio.h>
#include <stdlib.h>
#include<string.h>

void read_line(FILE* fp, char* line_buf, int size)
{
	memset(line_buf, 0, size + 1);
	fgets(line_buf, size, fp);//获取一行的字符
	return;
}

int parse_line(char *line_buf, struct student *stu)
{
	//%[^a]：表示取到指定字符为止的字符串
	int  num = sscanf(line_buf, "%d,%[^,],%[^,],%d,%d,%d",
		&(*stu).number, (*stu).name, (*stu).sex, &(*stu).math_grade, &(*stu).chinese_grade, &(*stu).english_grade);
	if (num == 6)
	{
		//printf("%d,%s,%s,%d,%d,%d\n", stu->number, stu->name, stu->sex, stu->math_grade,
		//stu->chinese_grade, stu->english_grade);
		return 1;
	}
	return 0;
}


#if 0
void calculate_total_grade(struct student *stu, int rows)
{

	int total_grade = 0;
	//stu[i].chinese_grade
	total_grade = stu->chinese_grade + stu->math_grade + stu->english_grade;
	printf("the id is %d:the total_grade of %s is %d\n", stu->number, stu->name, total_grade);
	return;
}
#endif

 

hello_shaonian
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基础链表练习（附详细注释）
04-08
在这个“基础链表练习”中，我们将探讨如何创建一个带头结点的字符串链表，以及如何对这个链表进行操作。下面将详细阐述相关知识点。 首先，我们来了解**单链表**的基本概念。单链表由一系列节点组成，每个节点包含...
链表经典练习题
最新发布
2302_81016149的博客
05-01 678
本篇文章到这里就结束了，如果有不理解的题目，可私信或在评论区留下问题，记得一定要练习，这是非常重要的。再强调：大部分题目解法只为了抛砖引玉。希望对大家有所启发。完！
数据结构——链表（练习题）
LGFaiJC的博客
03-28 1923
这道题我们的思路是分别找出长的链表与短的链表节点个数然后用长的节点数减去短的节点数得到的数就是长的链表比短的链表多出的节点个数然后创建两个指针long，short，long先走多出的个数然后再一起走当long与short指向的next相等时就找到了相交节点。让我们来看看这道题，我的思路是快慢指针，类似追击问题，我们创建两个指针一个指针以一次两个节点的速度走下去，一个指针一次一个节点走下去，如果是有环的链表那么指针一定会相交，如果不是环形链表那么快的会遇到NULL。大家好，我是小锋我们继续来学习链表。
C语言之链表练习题
weixin_46305053的博客
12-06 3460
本关需要你设计一个程序，实现单链表的逆置。单链表的逆置分为两种方法：头插法和就地逆置法，这两种方法虽然都能够达到逆置的效果，但还是有着不小的差别。头插法逆置链表初始为空，表中节点从原链表中依次“删除”，再逐个插入逆置链表的表头（即“头插”到逆置链表中），使它成为逆置链表的“新”的第一个结点，如此循环，直至原链表为空。就地逆置法先假定有一个函数，可以将以为头结点的单链表逆序，并返回新的头结点。利用这个函数对问题进行求解：将链表分为当前表头结点和其余部分，递归的过程就是，先将表头结点从链表中拆出来，然后对其余部
链表的练习
奋斗的龙猫的博客
09-13 306
文章目录回文链表重排链表排序的循环链表 回文链表 给定一个链表的 头节点 head ，请判断其是否为回文链表。 如果一个链表是回文，那么链表节点序列从前往后看和从后往前看是相同的。 示例 1： 输入: head = [1,2,3,3,2,1] 输出: true 示例 2： 输入: head = [1,2] 输出: fasle 提示： 链表 L 的长度范围为 [1, 105] 0 <= node.val <= 9 进阶：能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？ 来源：力扣（L
链表练习.c
11-08
数据结构中对链表的创建和遍历，采用c进行实现，通过该部分学习可以加深对链表和指针的学习，同时对c的应用可以更加深刻。
数据结构链表练习
07-23
学习数据结构过程中，亲自在VC++上编译通过的单链表源代码，与大家共享。
链表练习题目（打印）1
08-08
在给定的编程练习中，涉及了两个关于链表的操作：删除素数节点和计算相邻节点和的最小值。这两个问题都是基于C语言的链表数据结构，下面将详细解释这些知识点。 首先，我们来看链表的基础知识。链表是一种线性数据...
链表练习题(修正)1
08-08
这些练习题涵盖了链表的基本操作，对于学习和理解链表至关重要。在实际编程中，链表常用于动态数据结构，如队列、栈或者实现高级数据结构如图和树。掌握链表的插入、删除和遍历等操作，能帮助我们更好地解决复杂问题...
16种链表的练习
08-17
16种链表的练习 1.c 有头 无序 不循环 单向 2.c 有头 有序 不循环 单向 3.c 无头 无序 不循环 单向 4.c 无头 有序 不循环 单向 5.c 有头 无序 循环 单向 6.c 有头 有序 循环 单向 7.c 无头 无序 循环 单向 8.c 无头 有序 循环 单向 9.c 有头 无序 不循环 双向 10.c 有头 有序 不循环 双向 11.c 无头 无序 不循环 双向 12.c 无头 有序 不循环 双向 13.c 有头 无序 循环 双向* 14.c 有头 有序 循环 双向 15.c 无头 无序 循环 双向 16.c 无头 有序 循环 双向 listVerOutput.c 将有头 无序 不循环 单向链表的指针指向逆序并输出。
单链表练习
05-07
数据结构第一次课程实验：实现链表的创建，增加，删除，遍历等功能。
【数据结构】链表经典练习题
Dooo_yh的博客
01-01 4015
1.移除单链表元素 2.逆转单链表 3.获取链表的中间结点 4.获取链表中倒数第k个结点 5.合并两个有序单链表 6.单链表一分为二 7.判断链表是否为回文结构
链表的经典习题（画图详解）
weixin_69939913的博客
11-10 520
链表的经典习题
链表9大练习
m0_64254651的博客
04-23 101
cur是用来遍历的节点（我们之前写的都是cur=cur.next；但是现在问题在于我们遍历到节点的时候需要把当前节点的next修改成前一个的地址；但是引入问题我们把当前节点的next修改了；就需要Node在修改前先把这个当前节点的next记录下来；但是上一个节点的地址我们又丢了；但是这里的开始是head和cur是保持在同一个位置；.结束条件就是前面的节点和后面的节点相遇就说明是回文。当走两步的指针找到终点的时候；而且这种情况也能避免是偶数个节点的冲突情况；然后后面的代码就无效；因为这里的头节点是不知道的；
链表相关练习题以及题解
2302_81342533的博客
05-01 948
学习完了链表结构，不妨多加练习熟系这种数据结构。所以本篇论文列举出了一些和链表相关的练习题，并描述解题思路，相信对能够令读者对链表这种结构的掌握更加得心应手。
C语言数据结构-----链表类型详解及链表练习题
qq_57425280的博客
11-11 548
之前我讲解了循序表以及单链表，接下来我会在介绍几个不同的链表，并举例相关习题使大家能够更加深入的理解。前期内容如下：链接:链接:链接: [双向链表增删查改的代码实现] 紧张制作中。
数据结构之链表练习题(leetCode）
容铎的博客
05-01 1721
数据结构之链表练习题(leetCode）
K - 双向链表练习题
03-25
A：好的，下面是K - 双向链表练习题的解答。 题目描述： 设计一个数据结构，要求实现双向链表的基本操作：插入、删除、反转等，并实现一个方法向链表中添加一个元素。同时，该数据结构需要支持以下操作： 1. get...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值