翻译（链表，“派生链”）

最新推荐文章于 2021-11-24 11:29:09 发布
最新推荐文章于 2021-11-24 11:29:09 发布
阅读量415 收藏
点赞数
文章标签： c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyk219/article/details/82791703
版权

本程序使用了链表的知识，目的是根据词性翻译英文意思。代码需要大幅度优化，但是本人能力有限，还请各位多多指教。

先看效果，在上代码。开发环境（vs2017）。(我老大布置的作业)可以从这里下载https://download.csdn.net/my

词库

主文件

/********************************************************************
** 文  件  名：翻译
** 创  建  人：yk
** 最后修改时间：2018年9月10日
*********************************************************************/

#include "stdafx.h"
#include"line.h"
#include"openfile.h"
#include "Translate.h"
#include<iostream>
void input(WORDS *str, words *& daTe); //将键入信息存入结构体并翻译
int main()
{
	date *DaT = NULL, *DaT1 = NULL, *DaT2 = NULL;
	FiLe fILE;
	lines LINE,LINe;
	WORDS str[200] = {0};
	
	words* daTe = NULL,*dae=NULL,*again=NULL,*jkl=NULL;
	coloR(2);
	std::cout << "Loading................0%" << std::endl;
	coloR(16);
	DaT = fILE.Fileread(1);
	DaT1 = fILE.Fileread(2);
	DaT2 = fILE.Fileread(3);  //读取数据
	coloR(2);
	std::cout << "Loading................50%" << std::endl;
	coloR(16);
	LINE.LOOKUP(daTe, DaT2);//向链表中存数据
	coloR(2);
	std::cout << "Loading................80%" << std::endl;
	coloR(16);
	LINE.AddSon(daTe, DaT2, DaT,DaT1);
	coloR(2);
	std::cout << "Data read completion................100%" << std::endl;
	coloR(16);
	while(1)
	{ 
		coloR(5);
		std::cout << "[Please input the content you want to translate.]" << std::endl;
		coloR(16);
		scanf("%[^\n]", str);
		setbuf(stdin, NULL);//清空缓冲区
		coloR(1);
		input(str, daTe);//翻译
		coloR(16);

	}
	system("pause");
	return 0;
}

void input(WORDS * str,words *& daTe)
{
	Trancelate english;
	date *Trance = NULL, *NOW = NULL, *Head = NULL;
	Trance= (date *)malloc(sizeof(date));
	Head = Trance;
	for (NUMBERS Position = 0, i = 0;; i++)
	{
		if (str[i] != ' ' && str[i] != '\0' && str[i] != '\n')
		{
			Position++;
		}

		else if (Position != 0 && (str[i] == ' ' || str[i] == '\0' || str[i] == '\n'))
		{
			NUMBERS NOWPOsition = 0;
			Trance->wordss = (WORDS *)malloc(sizeof(WORDS)*(Position + 1));
			for (NUMBERS ADposition = i - Position; ADposition < i; ADposition++)
			{
				Trance->wordss[NOWPOsition] = str[ADposition];
				NOWPOsition++;
			}
			Trance->wordss[NOWPOsition] = '\0';
			Trance->next = NULL;
			NOW = Trance;
			Trance = (struct date *)malloc(sizeof(struct date));
			NOW->next = Trance;
			Position = 0;

		}
		else if (str[i] == '\0' || str[i] == '\n')
		{
			NOW->next = NULL;
			break;
		}
	}
	english.Enginsh_TO_Chinese(daTe, Head);
}

line.h

#ifndef LINE_H
#define LINE_H
#include"stdafx.h"
#define _CRT_SECURE_NO_DEPRECATE
#pragma warning(disable:4996)
struct words
{
	WORDS * characteristic;
	struct words* next;
	struct words *as=NULL;
};

class lines
{
public:

	NUMBERS line_push_back(struct words *& head, WORDS *str);  //在末尾添加数据
	NUMBERS print_line(words *& head);						   //打印数据
	NUMBERS OR(WORDS* p, WORDS* q);							   //判断字符串，相同返回0，不相同返回非0
	NUMBERS lineOR(words *&head, WORDS *q);                   //寻找相同内容,相同返回1，不相同返回0
	EMPTY Creadteline(struct words *& head, WORDS *STr);      //创建一个空链表
	NUMBERS LOOKUP(struct words *& daTe, date *DaTE);         //初次存入中链表
	NUMBERS AddSon(words *& daTe, date * DaTE, date * DAT, date * DAT1);//添加子链的内容
	NUMBERS sIze=0;
	

private:
	struct words *Begin = NULL, *End = NULL;
	NUMBERS line_push_back_double(struct words *& head, WORDS *str);
	NUMBERS ADDlinemomchar(words *& liNE1, WORDS *sTR, WORDS *Str);
	
};




#endif // !LINE_H

line.cpp

#include"stdafx.h"
#include "line.h"



NUMBERS lines::OR(WORDS* p, WORDS* q)//判断字符串，相同返回0，不相同返回非0
{
	NUMBERS xc = 0;
	while ((!(xc = *p - *q)) && *p)
	{
		*q++;
		*p++;
	}
	return xc;
}

NUMBERS lines::lineOR(words *& head, WORDS* q)//寻找相同内容,相同返回1，不相同返回0
{
	words *Guochen = head;
	while (Guochen != NULL)
	{
		if (!OR(Guochen->characteristic, q))
		{
			return 1;
		}
		Guochen = Guochen->next;
	}
	return 0;
}

EMPTY lines::Creadteline(struct words *& head, WORDS *STr)
{
	head = (struct words *)malloc(sizeof(struct words));
	head->characteristic = STr;
	sIze++;
	head->next = NULL;
	head->as = NULL;
	if (Begin == NULL)
	{
		Begin = head;
		End = head;
	}
	
	
}



NUMBERS lines::line_push_back(words *& head, WORDS *STr) //在末尾添加数据
{
	if (*STr == '\0'||*STr=='\n')
	{
		return 1;
	}
	if (head == NULL)
	{
		Creadteline(head, STr);
	}
	else
	{
		struct words *guochen = head, *TO = NULL, *Guochen = NULL;
		guochen = End;
		TO= (struct words *)malloc(sizeof(struct words));
		if (TO == NULL)return 1;
		TO->characteristic = STr;
		TO->next=NULL;
		TO->as = NULL;
		sIze++;
		guochen->next = TO;
		End = TO;
	}
	return 0;
}

NUMBERS lines::line_push_back_double(words *& head, WORDS * STr)
{
	if (*STr == '\0')
	{
		return 1;
	}
	if (head == NULL)
	{
		Creadteline(head, STr);
	}
	else
	{
		struct words *guochen = head, *TO = NULL, *Guochen = NULL;
		while(guochen->next!=NULL)
		{
			guochen = guochen->next;
		}
		TO = (struct words *)malloc(sizeof(struct words));
		if (TO == NULL)return 1;
		TO->characteristic = STr;
		TO->next = NULL;
		TO->as = NULL;
		guochen->next = TO;
	}
	return 0;
}

NUMBERS lines::print_line(words *& head)
{
	words *Guochen = head;
	while (Guochen != NULL)
	{
		std::cout << ">>" << Guochen->characteristic << ">>";
		Guochen = Guochen->next;
	}
	printf("\n");
	return 0;
}
NUMBERS lines::LOOKUP(struct words *& daTe, date *DaTE)
{
	for (NUMBERS i = 0;; i++)
	{
		if (DaTE->next != NULL)
		{

			if (daTe != NULL)
			{

				if (!lineOR(daTe, DaTE->wordss))//避免存入词的重复
				{

					line_push_back(daTe, DaTE->wordss);

				}
				DaTE = DaTE->next;
			}
			else
			{

				line_push_back(daTe, DaTE->wordss);
				DaTE = DaTE->next;
			}

		}
		else
		{
			break;
		}

	}
	return 0;
}

NUMBERS lines::ADDlinemomchar(words *& liNE1,WORDS *sTR, WORDS *Str)
{
	struct words* Add = liNE1;
	while(Add!=NULL)
	{ 
	if(!OR(Add->characteristic,sTR))
	{
		if(!lineOR(Add->as, Str))
		{
		line_push_back_double(Add->as, Str);
		return 0;
		}	
	}
	Add = Add->next;
	}
	
	return 1;
}



NUMBERS lines::AddSon(words *& daTe, date * DaTE, date * DAT, date * DAT1)  //此处需优化！！！
{
	date *Threesline = DAT1, *Twoline = DAT,*oneline=DaTE, *oneline1 = DaTE;
	words * daTe1 = daTe;
	words * daTe2 = daTe;
	for (;;)
	{
		if (oneline->next != NULL)
		{

			ADDlinemomchar(daTe, oneline->wordss, Twoline->wordss);
			oneline = oneline->next;
			Twoline = Twoline->next;	
		}
		else
		{
			break;
		}
	}
	Twoline = DAT;
	Threesline = DAT1;
	for (;;)
	{
		if (daTe2 != NULL)
		{
			while (Threesline->next != NULL)
			{
				ADDlinemomchar(daTe2->as, Twoline->wordss, Threesline->wordss);
				Twoline = Twoline->next;
				Threesline = Threesline->next;

			}
			daTe2 = daTe2->next;
			Threesline = DAT1;
			Twoline = DAT;
		}
		else
		{
			break;
		}
	}
	words * daTe7 = NULL;
	words * daTemain = daTe;
	words * daTe4 = daTemain->as;
	words * daTe5 = daTe4->as;
	words * daTemain1 = daTe;
	Threesline = DAT1;
	Twoline = DAT;
	oneline = DaTE;
	for (;;)
	{
		if (!OR(daTe4->characteristic, Twoline->wordss))
		{
			daTe5 = daTe4->as;
			while (daTe5 != NULL)
			{
				if (!OR(daTe5->characteristic, Threesline->wordss))
				{
					oneline = oneline->next;
					if(*oneline->wordss!='\n')
					{ 
					while (daTemain1 != NULL)
					{
						if (!OR(daTemain1->characteristic, oneline->wordss))
						{
							daTe5->as = daTemain1;
							Threesline = DAT1;
							Twoline = DAT;
							oneline = DaTE;
							if (daTe4 != NULL)
							daTe4 = daTe4->next;
							daTemain1 = daTe;
							goto xc;
						}
						else
						{
							daTemain1 = daTemain1->next;
						}

					}
					}
					else
					{
						daTe5->as = NULL;
						Threesline = DAT1;
						Twoline = DAT;
						oneline = DaTE;
						daTe4 = daTe4->next;
						daTemain1 = daTe;
						break;

					}
					
					xc:daTe5 = daTe5->next;
				}
				else
				{
					if (oneline == NULL)
					{
						Threesline = DAT1;
						Twoline = DAT;
						oneline = DaTE;
					}
					Threesline = Threesline->next;
					oneline = oneline->next;
					
				}
			}
		}
		else
		{
			if (oneline == NULL)
			{
				Threesline = DAT1;
				Twoline = DAT;
				oneline = DaTE;
			}
			oneline = oneline->next;
			Twoline = Twoline->next;
			Threesline = Threesline->next;
		}
		if (daTe4 == NULL)
		{
			if (daTemain->next == NULL)break;
			daTemain = daTemain->next;
			daTe4= daTemain->as;
		}


	}
	
	return 0;
}

openfile.h

#pragma once
#include"stdafx.h"
#include<iostream>
#define _CRT_SECURE_NO_DEPRECATE
#pragma warning(disable:4996)
#define MAX_NUMBEr 1024

class FiLe
{
public:
	
	NUMBERS Filestart(FILE * &fp);  //初始化文件读取功能
	NUMBERS Filestop(FILE * &fp);   //结束文件读取
	date * Fileread(NUMBERS FLog);   //读取文件
private:

};

openfile.cpp


#include"stdafx.h"
#include"openfile.h"


NUMBERS FiLe::Filestart(FILE * &fp)
{
	fp = fopen("G:\\yk\\Desktop\\as.txt", "r");
	if (fp == NULL)
	{
		return 1;
	}
		return 0;


}
NUMBERS FiLe::Filestop(FILE * &fp)
{
	if (!(fclose(fp) ^ 0))
	{
		return 0;
	}
	return 1;

}

date * FiLe::Fileread(NUMBERS FLog)//获取数据
{
	WORDS STR[1024], c[1024];
	NUMBERS i = 0,  l = 0, position = 0;
	date *DaTE = NULL, *HEad = NULL, *NOW;

	FILE *fp;
	FiLe fIlE;
	if (fIlE.Filestart(fp))  //打开文件
	{
		std::cout << "open faile" << std::endl;
		system("pause");
		exit(0);
	}
	DaTE = (date *)malloc(sizeof(date));

	HEad = DaTE;

	while (fgets(c, MAX_NUMBEr, fp)) {
		i++;
		if (i == 4)i = 1;
		if (i== FLog)//只读FLog行的数据
		{
			strcpy(STR, c);//遇到空格换节点，遇到换行就读下个FLog行数据
			for (NUMBERS k = 0; ; k++)
			{
				if (STR[k] != ' ' && STR[k] != '\n'&&STR[k] != '\0')
				{
					position++;
				}
				else if (position != 0 && (STR[k] == ' ' || STR[k] == '\0' || STR[k] == '\n'))//按需给予内存
				{
					NUMBERS NOWPOsition = 0;
					DaTE->wordss = (WORDS *)malloc(sizeof(WORDS)*(position + 1));
					for (NUMBERS ADposition = k - position; ADposition < k; ADposition++)
					{
						DaTE->wordss[NOWPOsition] = STR[ADposition];
						NOWPOsition++;
					}
					DaTE->wordss[NOWPOsition] = '\0';
					DaTE->next = NULL;
					NOW = DaTE;
					DaTE = (struct date *)malloc(sizeof(struct date));
					NOW->next = DaTE;
					position = 0;
				}
				else if (STR[k] == '\0' || STR[k] == '\n')
				{

					break;
				}
			}
			DaTE->wordss = (WORDS *)malloc(sizeof(WORDS)*(2));
			DaTE->wordss[0] ='\n';
			DaTE->wordss[1] = '\0';
			DaTE->next = NULL;
			NOW = DaTE;
			DaTE = (struct date *)malloc(sizeof(struct date));
			NOW->next = DaTE;
			DaTE->next = NULL;

		}

	}

	if (fIlE.Filestop(fp))//关闭文件
	{
		std::cout << "open faile" << std::endl;
		system("pause");
		exit(0);
	}
	return HEad;
}

//NUMBERS FiLe::Fileread(date *DaTE,NUMBERS FLog)//获取数据
//{
//
//	
//
//
//
//	WORDS STR[1024], c[1024];
//	NUMBERS i = 0, z = 0, l = 0;
//	FILE *fp;
//	if (Filestart(fp))
//	{
//		std::cout << "open faile" << std::endl;
//		system("pause");
//		exit(0);
//	}
//	while (fgets(c, MAX_NUMBEr, fp)) {
//		i++;
//
//		if (!(i % FLog))
//		{
//			strcpy(STR, c);
//			for (NUMBERS j = 0;; j++)
//			{
//				if (STR[j] != ' ' && STR[j] != '\n')
//				{
//					DaTE[z].wordss[l] = STR[j];
//					l++;
//
//				}
//				else if (STR[j] == ' ')
//				{
//					l = 0;
//					z++;
//
//				}
//				else if (STR[j] == '\n')
//				{
//					l=0;
//					break;
//				}
//			}
//		}
//
//
//	}
//	if (Filestop(fp))
//	{
//		std::cout << "open faile" << std::endl;
//		system("pause");
//		exit(0);
//	}
//	return 0;
//}

translate.h

#pragma once
#include"stdafx.h"
#include"line.h"

class Trancelate
{
public:
	EMPTY Chinese_TO_English(words *&linE,WORDS *str);
	EMPTY Enginsh_TO_Chinese(words *&linE, date *&str);  //翻译
private:

};

translate.cpp(没写汉译英)

#include "stdafx.h"
#include "Translate.h"



EMPTY Trancelate::Chinese_TO_English(words *& linE, WORDS * str)
{
	words * linEstrat = linE;



	return EMPTY();
}

EMPTY Trancelate::Enginsh_TO_Chinese(words *& linE,date *& str)
{
	words * linEstrat = linE;
	lines line_or;
	words * linEguochen = linEstrat->as;
	words * linEGuochen = linEguochen->as;
	words * linEGUochen = linEGuochen->as;
	date *ddF = str;
	date *dDF = str;
	if (str->wordss[0] == '\0')
	{
		coloR(4);
		std::cout << "Error!!!" << std::endl;
		coloR(16);
		return;
	}
	while(linEstrat!=NULL)
	{ 
		linEguochen = linEstrat->as;
	A:while (linEguochen != NULL)
	{
		if (!line_or.OR(linEguochen->characteristic, ddF->wordss))
		{
			linEGuochen = linEguochen->as;
			C:if (linEGuochen->next == NULL)
			{
				B:printf("[%s]", linEGuochen->characteristic);
				ddF = ddF->next;
				if (linEGuochen->as == NULL || ddF == NULL)
				{
					printf("\n");
					return;
				}
				linEguochen = linEGuochen->as->as;
				goto A;
			}
			else
			{
				linEGUochen = linEGuochen->as->as;
				dDF = ddF->next;
					while (linEGUochen != NULL)
					{
						if (!line_or.OR(linEGUochen->characteristic, dDF->wordss))
						{
							goto B;
						}
						linEGUochen = linEGUochen->next;
					}
					linEGuochen = linEGuochen->next;
					goto C;

					
			}
			
		}
		linEguochen = linEguochen->next;

	}
	linEstrat = linEstrat->next;
   }
	coloR(4);
	std::cout << "Error!!!" << std::endl;
	coloR(16);
	return;
}

stdax.h

// stdafx.h : 标准系统包含文件的包含文件，
// 或是经常使用但不常更改的
// 特定于项目的包含文件
//

#pragma once

#include "targetver.h"
#include"malloc.h"
#include <stdio.h>
#include <tchar.h>
#include"windows.h"
#include<string>
#include<iostream>



typedef char WORDS;
typedef int NUMBERS;
typedef bool JUDGE;
typedef void EMPTY;
void coloR(short x);
struct date
{
	WORDS *wordss;
	struct date *next;
};
// TODO: 在此处引用程序需要的其他头文件

stdafx.cpp

// stdafx.cpp : 只包括标准包含文件的源文件
// ConsoleApplication5.pch 将作为预编译标头
// stdafx.obj 将包含预编译类型信息

#include "stdafx.h"
void coloR(short x)	//自定义函根据参数改变颜色 
{
	if (x >= 0 && x <= 15)//参数在0-15的范围颜色
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), x);	//只有一个参数，改变字体颜色 
	else//默认的颜色白色
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
}
// TODO: 在 STDAFX.H 中引用任何所需的附加头文件，
//而不是在此文件中引用

 

你爱吃秋葵。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构：链表(linked-list)
蜗牛君的奋斗史
05-09 5万+
链表分为单向链表(Singly linked lis)、双向链表(Doubly linked list)、循环链表(Circular Linked list)。
翻译（链表）
09-20
翻译，链表，但因为能力有限，所以优化不是特别好。
java链表英文_Java学习笔记--链表
weixin_42346710的博客
02-17 153
心在山东身在吴，飘蓬江海漫嗟吁。他时若遂凌云志， 敢笑黄巢不丈夫。——水浒传先上源代码,LinkedList类:1 private static class Node{2 E item;3 Nodenext;4 Nodeprev;56 Node(Node prev, E element, Nodenext) {7 this.i...
链表英文名用list来表示
qq_27809619的博客
11-24 1160
链表 链表英文名用list来表示，顾名思义，就和我们常见的项链一样，上面有很多的圆环一个一个的连接起来，只是对于软件来说就是把一个一个对象连接起来，在C语言中我们这个对象就是我们自己定义的各个结构体，我们将这些结构体连接起来，然后就形成了链表。这些结构体中必须有一个node节点，这个节点都是我们所说的项链上的一个个圆环，每个圆环左手拉上一个圆环的右手，圆环的右手拉下一个圆环的左右。他们之间的相互牵手然后形成了一个链表。 ...
数据结构学习笔记（一）：链表（linked list）
文程序公子的博客
05-11 1586
数据结构学习笔记（一）：常见数据结构及其增删查操作 1 链表（linked list） 链表，又称线性表或线性链表，是若干数据元素组成的线性序列，将数据元素像链条一样组织在一起。存储在链表中的数据元素被称为结点（node）,每个结点具有两个要素：第一、数据元素的具体值，第二、指向下一个结点的指针，指针用来存储下一个结点的内存地址。 最基本的链表结构是单向链表，最前面是一个头指针用来指向第一个结点，最后一个结点的指针是一个空指针（null pointer），每一个结点都只指向它的下一个结点，例如一个存储
实现两个链表类的链接
10-20
在编程领域，链表是一种非常基础且重要的数据结构，它不同于数组，不连续存储数据，而是通过节点间的引用关系来组织数据。本题的核心任务是实现两个链表类的链接，以便模拟加法运算，也就是将两个链表的元素相加。...
栈链.rar_链表
09-20
本示例“栈链.rar_链表”是使用VC++6.0编译的一个简单的链表程序，它展示了链表的基本操作。 链表不同于数组，它不连续存储元素，而是通过节点间的指针链接。每个节点包含两部分：数据域和指针域。数据域用于存储...
链正向链表、反向链表.rar
06-13
链表是一种基础且重要的数据结构，它在计算机科学中扮演着不可或缺的角色。相较于数组，链表在内存管理和数据存储上有着独特的优点。本资料主要探讨的是正向链表和反向链表，这两种链表类型各有特点，适用于不同的...
用C++写的双向循环链表派生栈和队列
11-10
总的来说，"用C++写的双向循环链表派生栈和队列"这个项目涵盖了数据结构中的链表、栈和队列，以及面向对象编程中的派生概念，是学习和实践这些知识的好例子。通过实践，你不仅能掌握这些理论知识，还能提高编程能力...
C++版链表派生栈和队列
01-02
该代码主要是用C++语言来实现通过链表派生栈和队列
Java单链表源码分析-interviews:采访
06-05
Java单链表源码分析采访 您的软件工程技术面试个人指南。 维护者 - 翻译 目录 文章 在线评委 实时编码练习 数据结构 链表 链表是数据元素的线性集合，称为节点，每个元素通过指针指向下一个节点。 它是由一组节点组成的数据结构，这些节点一起表示一个序列。 单向链表：每个节点指向下一个节点，最后一个节点指向空的链表 双向链表：链表中的每个节点都有两个指针 p，n，使得 p 指向前一个节点，n 指向下一个节点； 最后一个节点的 n 指针指向 null 循环链表：每个节点指向下一个节点，最后一个节点指向第一个节点的链表 时间复杂度： 访问： O(n) 搜索： O(n) 插入： O(1) 删除： O(1) 堆 Stack是元素的集合，有两个主要操作： push ，添加到集合中， pop删除最近添加的元素 后进先出数据结构（LIFO） 时间复杂度： 访问： O(n) 搜索： O(n) 插入： O(1) 删除： O(1) 队列 Queue是元素的集合，支持两种主要操作： enqueue ，将元素插入队列，以及dequeue ，从队列中删除元素 先进先出数据结构（FIFO） 时间复杂度： 访问：
C++继承和派生
m0_60961911的博客
08-21 178
一 继承的基本概念 系统提供了相当多的已定义好的基类，用户可以根据具体的应用，在已有类的基础上构架新类，在派生类中，可以直接使用父类部分的代码，但却不需要重新编写父类的代码。这样可以加速软件开发的速度，保障软件开发的质量。继承提供了在已有类的基础上开发出新类的机制，可以节省重复代码的编写工作，是软件重用的基础。 已知一个类A，对A类加以扩展，即增加一些属性和行为，构成一个新类B，此时B类将A类已有的属性和行为继承下来。称类 B 继承了 A ，或称类 A 派生了 B 。A：父类，基类，B：子类，派生类..
C++学习总结——通过抽象类和派生创建异质链表
IM_GD
05-23 1264
#include&lt;iostream&gt; #include&lt;Windows.h&gt; #include&lt;stdlib.h&gt; using namespace std; class base//抽象基类的定义 { public: virtual void show() = 0;//通过纯虚函数定义公共接口 }; //链表结点定义 class linknode { publ...
[数据结构]什么是链表?
菜鸟腾飞
07-14 1万+
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的–百度百科 大致分为单链表和双向链表 1.单链表:每个节点包含两部分,一部分存放数据变量的data,另一部分是指向下一节点的next指针 2.双向链表:除了包含单链表的部分,还增加的pre前一个节点的指针 链表的优点在于,不需要连续的存储单元,修改链表的复杂度为O(1) (在不考虑查找时) 但是...
Python之禅 的翻译和解释
jgftyfc的博客
11-11 603
Python之禅 的翻译和解释
使用单链表统计英文文本单词个数
SuilandCoder的博客
11-17 2935
#include "stdio.h" #include "malloc.h" #include "string.h" /** * 注意下面三个*********************************************中的内容 * 都是容易出错的地方！ */ //统计字符串中单词个数及每个单词出现次数 typedef struct WordsNode{ int tim
拉链表
TINHAO
03-01 1438
1 什么是拉链表 拉链表， 记录每条信息的生命周期为单位， 一旦条记录的生命周期结束，就重新开始一条新的记录，并把当前日期放入生效开始日期。 如果当前信息至今有效，在生效结束日期中填入一个极大值（如9999-99-99 或者 9999-12-31）。 2 为什么要做拉链表 1 、 需要查看某些业务信息的某一个时间点当日的信息 。 2 、 数据会发生变化，但是大部分是不变的。（无法做每日增量） 3...
链表
热门推荐
程序猿的博客
04-27 3万+
链表 链表是由节点构成的，这个节点我们可以通过建立一个类来实现它。这个类我们通常选用内部类。 class TestLink{ class Entry{ int data; Entry next; public Entry() { next = null; } public Entr...
逆转一个链表的链接方向
最新发布
06-18
- 初始化prev为null，curr为链表头节点。 - 当curr不为空时，执行以下操作： - 将curr的下一个节点赋给curr的prev（即反转curr的next指针）。 - 移动curr到其prev节点（curr = curr.prev）。 - 最后，将原头...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值