基于链表的词典

最新推荐文章于 2022-10-13 10:20:14 发布
最新推荐文章于 2022-10-13 10:20:14 发布
阅读量789 收藏 4
点赞数 1
分类专栏： 数据结构 文章标签： 链表 基于链表的词典
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hjy132/article/details/62889863
版权

基于链表的词典

词典（Dictionary），也称映射（map），词典中每个元素都由两部分组成：一个关键字，通常称为查找键（search key）；一个与该键值相关联的值，一般将它们称之为键值对。每一个查找键在词典中是唯一的，即不存在两个相同的查找键，这样就可以通过查找建来访问其对应的值。

就像上一篇 基于数组的词典，每个元素可以是Entry类的一个实例，即键值对封装在一个对象中，如下图

另外一种是不使用Entry类，而是定义私有Node类，其包含3个数据域key、value、next。

词典接口

public interface DictionaryInterface<K,V> {
	public V add(K key,V value);
	public V remove(K key);
	public V getValue(K key);
	public boolean contains(K key);
	public boolean isEmpty();
	public boolean isFull();
	public int getSize();
	public void clear();
	public void display();
	public Iterator<K> getKeyIterator();
	public Iterator<V> getValueIterator();
}

基于链表的无序词典

插入和删除操作的效率本应该是O(1)，但防止出现重复查找键需要从链表的始端开始顺序查找，因此最快情况下的效率为O(n)。
插入：添加元素时，首先定位该查找键是否存在，若不存在，直接插入到链头，若存在，则替换该位置的值
删除：删除元素时，首先定位该查找键是否存在，若不存在，则返回null，若存在，则删除该位置的元素 

public class Linked_Unsorted_Dictionary<K,V> implements DictionaryInterface<K, V>{

	private Node firstNode;
	private int currentSize;

	public Linked_Unsorted_Dictionary() {
		firstNode=null;
		currentSize=0;
	}

	@Override
	public V add(K key, V value) {
		System.out.print("["+key+","+value+"]"+" ");
		V result=null;
		Node currentNode=firstNode;
		while(currentNode!=null && !key.equals(currentNode.getKey()))
			currentNode=currentNode.getNextNode();
		if(currentNode!=null && key.equals(currentNode.getKey())){
			result=currentNode.getValue();
			currentNode.setValue(value);
		}else{
			Node newNode=new Node(key, value);
			newNode.setNextNode(firstNode);
			firstNode=newNode;
			currentSize++;
		}
		return result;
	}

	@Override
	public V remove(K key) {
		V result=null;
		Node currentNode=firstNode;
		Node beforeNode=null;
		while(currentNode!=null && !key.equals(currentNode.getKey())){
			beforeNode=currentNode;
			currentNode=currentNode.getNextNode();
		}
		if(currentNode!=null && key.equals(currentNode.getKey())){
			result=currentNode.getValue();
			beforeNode.setNextNode(currentNode.getNextNode());
			currentSize--;
		}
		return result;
	}

	@Override
	public V getValue(K key){
		V result=null;
		Node currentNode=firstNode;
		while(currentNode!=null && !key.equals(currentNode.getKey()))
			currentNode=currentNode.getNextNode();
		if(currentNode!=null && key.equals(currentNode.getKey()))
			result=currentNode.getValue();
		return result;
	}

	@Override
	public boolean contains(K key) {
		Node currentNode=firstNode;
		while(currentNode!=null && !key.equals(currentNode.getKey()))
			currentNode=currentNode.getNextNode();
		return currentNode!=null;
	}

	@Override
	public boolean isEmpty() {
		return currentSize==0;
	}

	@Override
	public boolean isFull() {
		return false;
	}

	@Override
	public int getSize() {
		return currentSize;
	}

	@Override
	public void clear() {
		firstNode=null;
		currentSize=0;
	}

	@Override
	public void display() {
		System.out.println();
		Iterator keyiterator=getKeyIterator();
		Iterator<V> valueiterator=getValueIterator();
		while(keyiterator.hasNext() && valueiterator.hasNext()){
			System.out.print("["+keyiterator.next()+","+valueiterator.next()+"]"+" ");
		}
		System.out.println();
	}

	@Override
	public Iterator<K> getKeyIterator() {
		return new KeyIterator();
	}

	@Override
	public Iterator<V> getValueIterator() {
		return new ValueIterator();
	}

	private class KeyIterator implements Iterator<K>{

		private Node nextNode;

		public KeyIterator() {
			nextNode=firstNode;
		}

		@Override
		public boolean hasNext() {
			return nextNode!=null;
		}

		@Override
		public K next() {
			K result=nextNode.getKey();
			nextNode=nextNode.getNextNode();
			return result;
		}
	}

	private class ValueIterator implements Iterator<V>{

		private Node nextNode;

		public ValueIterator() {
			nextNode=firstNode;
		}

		@Override
		public boolean hasNext() {
			return nextNode!=null;
		}

		@Override
		public V next() {
			V result=nextNode.getValue();
			nextNode=nextNode.getNextNode();
			return result;
		}
	}

	private class Node {
		private K key;
		private V value;
		private Node next;
		private Node(K key,V value) {
			this(key,value,null);
		}

		private Node(K key,V value,Node next){
			this.key=key;
			this.value=value;
			this.next=next;
		}

		private K getKey(){
			return key;
		}

		private V getValue(){
			return value;
		}

		private void setValue(V value){
			this.value=value;
		}

		private Node getNextNode(){
			return next;
		}

		private void setNextNode(Node nextNode){
			next=nextNode;
		}
	}
}
测试代码 
public class main_Unsorted_Dictionary {

	private static Linked_Unsorted_Dictionary<Integer, Integer> list;
	public static void main(String[] args) {
		list=new Linked_Unsorted_Dictionary<Integer, Integer>();
		Random ra =new Random();
		for(int i=0;i<10;i++)
			list.add(ra.nextInt(100),ra.nextInt(100));
		list.display();
		list.remove(56);
		list.display();
	}
}

基于链表的有序词典

public class Linked_Sorted_Dictionary<K extends Comparable<? super K>,V> implements DictionaryInterface<K, V>{

	private Node firstNode;
	private int currentSize;

	public Linked_Sorted_Dictionary() {
		firstNode=null;
		currentSize=0;
	}

	@Override
	public V add(K key, V value) {
		System.out.print("["+key+","+value+"]"+" ");
		V result=null;
		Node currentNode=firstNode;
		Node beforeNode=null;
		while(currentNode!=null && key.compareTo(currentNode.getKey())>0){
			beforeNode=currentNode;
			currentNode=currentNode.getNextNode();
		}
		if(currentNode!=null && key.compareTo(currentNode.getKey())==0){
			result=currentNode.getValue();
			currentNode.setValue(value);
		}else{
			Node newNode=new Node(key, value);
			currentSize++;
			if(beforeNode==null){
				newNode.setNextNode(firstNode);
				firstNode=newNode;
			}else{
				newNode.setNextNode(currentNode);
				beforeNode.setNextNode(newNode);
			}
		}
		return result;
	}

	@Override
	public V remove(K key) {
		V result=null;
		Node currentNode=firstNode;
		Node beforeNode=null;
		while(currentNode!=null && key.compareTo(currentNode.getKey())>0){
			beforeNode=currentNode;
			currentNode=currentNode.getNextNode();
		}
		if(currentNode!=null && key.compareTo(currentNode.getKey())==0){
			result=currentNode.getValue();
			beforeNode.setNextNode(currentNode.getNextNode());
		}
		return result;
	}

	@Override
	public V getValue(K key) {
		V result=null;
		Node currentNode=firstNode;
		while(currentNode!=null && key.compareTo(currentNode.getKey())>0)
			currentNode=currentNode.getNextNode();
		if(currentNode!=null && key.compareTo(currentNode.getKey())==0)
			result=currentNode.getValue();
		return result;
	}

	@Override
	public boolean contains(K key) {
		Node currentNode=firstNode;
		while(currentNode!=null && key.compareTo(currentNode.getKey())>0)
			currentNode=currentNode.getNextNode();
		return currentNode!=null;
	}

	@Override
	public boolean isEmpty() {
		return currentSize==0;
	}

	@Override
	public boolean isFull() {
		return false;
	}

	@Override
	public int getSize() {
		return currentSize;
	}

	@Override
	public void clear() {
		firstNode=null;
		currentSize=0;
	}

	@Override
	public void display() {
		System.out.println();
		Iterator keyiterator=getKeyIterator();
		Iterator<V> valueiterator=getValueIterator();
		while(keyiterator.hasNext() && valueiterator.hasNext()){
			System.out.print("["+keyiterator.next()+","+valueiterator.next()+"]"+" ");
		}
		System.out.println();
	}

	@Override
	public Iterator<K> getKeyIterator() {
		return new KeyIterator();
	}

	@Override
	public Iterator<V> getValueIterator() {
		return new ValueIterator();
	}

	private class KeyIterator implements Iterator<K>{

		private Node nextNode;

		public KeyIterator() {
			nextNode=firstNode;
		}

		@Override
		public boolean hasNext() {
			return nextNode!=null;
		}

		@Override
		public K next() {
			K result=nextNode.getKey();
			nextNode=nextNode.getNextNode();
			return result;
		}
	}

	private class ValueIterator implements Iterator<V>{

		private Node nextNode;

		public ValueIterator() {
			nextNode=firstNode;
		}

		@Override
		public boolean hasNext() {
			return nextNode!=null;
		}

		@Override
		public V next() {
			V result=nextNode.getValue();
			nextNode=nextNode.getNextNode();
			return result;
		}
	}

	private class Node {
		private K key;
		private V value;
		private Node next;
		private Node(K key,V value) {
			this(key,value,null);
		}

		private Node(K key,V value,Node next){
			this.key=key;
			this.value=value;
			this.next=next;
		}

		private K getKey(){
			return key;
		}

		private V getValue(){
			return value;
		}

		private void setValue(V value){
			this.value=value;
		}

		private Node getNextNode(){
			return next;
		}

		private void setNextNode(Node nextNode){
			next=nextNode;
		}
	}
}
测试代码 
public class main_SortedDictionary {
	
	private static Linked_Sorted_Dictionary<Integer, Integer> list;
	public static void main(String[] args) {
		list=new Linked_Sorted_Dictionary<Integer, Integer>();
		Random ra =new Random();
		for(int i=0;i<10;i++)
			list.add(ra.nextInt(100),ra.nextInt(100));
		list.display();
		list.remove(45);
		list.display();
	}
}

基于数组词典与基于链表词典的比较

词典各操作在最坏的情况下的效率如下表：
  • 基于链表词典不需要考虑词典的长度，而基于数组词典需要
  • 两种实现的各种操作的时间复杂度几乎一样，但需要认识到数组需要平移元素，而链表不需要
  • 基于数组的词典因为使用二叉查找，检索操作更高效




c语言链表的项目（用链表实现的字典）
04-18
用C语言做的字典程序，中使用链表和结构体，涉及的知识点有结构体，指针，链表的添加，遍历，删除，释放，文件的打开，读取，关闭等。使用Xcode写的代码，可以在Xcode4.2中直接运行，但是需要更改字典数据文件的路径，也可以在终端下编译运行，也可以直接把main.C拷贝到vc下去运行
【c语言课程设计】基于链表与结构体的英语单词辞典系统
01-07
【c语言课程设计】基于链表与结构体的英语单词辞典系统 实现单词的增删改查 形成一个词典 菜单界面操作 可实现文件读取与存档
电子词典的实现
qiumei1101381170的博客
08-11 705
电子词典的实现 #define _CRT_SECURE_NO_WARNINGS #include #include #include #include #define MAX 111111 //最大记录数 struct dict { char *key; char *content; }; //打开字典文件，并读取文件内容 int open
数据结构----链表实现字典结构
湫兮若风的博客
10-08 771
文章目录1. 概述2. 源码 1. 概述 通过内部封装的链表，来实现字典结构。 2. 源码 /** * 通过链表实现字典. */ public class LinkedListMap<K, V> implements Map<K, V> { private class Node { public K key; public V...
用c语言链表做一个词典,大家帮帮忙，谁帮忙用C语言链表编写一个英语查询词典！~...
weixin_42467896的博客
05-21 192
该楼层疑似违规已被系统折叠隐藏此楼查看此楼给定一个单词库文件(txt类型)，含有英语单词和中文解释，英语单词和中文解释之间有空格隔开。每行一个英语单词构建的数据结构如下struct word{char enword[18];char cnword[128];struct word * next;}要求根据该数据结构，从txt文件中为了保证读出的数据正确，不妨做个判断 可以考虑用isalpha逐个...
C语言基于单链表的词典软件
程序设计
10-13 877
题目：基于单链表的词典软件 内容： 利用单链表存储词典，可以实现从文件中加载数据、查询单词、添加词条、删除词条、将词典保存到文件等功能。单链表带有专用头结点head。是否区分大小写可自行规定。 使用C语言；完成后，还可以自愿尝试以Java实现。
DIANZICIDIAN.zip_电子词典_链表电子词典
09-21
本项目涉及两种实现方式：基于链表的电子词典和基于数组的电子词典。下面将详细探讨这两种方法及其特点。 1. **基于链表的电子词典** - **链表基础**：链表是一种线性数据结构，与数组不同，它不连续存储元素。每...
文件操作和链表操作的英汉电子词典.zip
08-06
总结一下，文件操作和链表操作是编程中不可或缺的基础，它们在实现电子词典这样的应用时起到了关键作用。了解并熟练掌握这些概念，对于任何IT专业人士来说都至关重要。通过不断实践和深入学习，你将能够构建出更加...
链表与数组电子词典的设计与实现
资源摘要信息:"该压缩包文件包含了一款基于链表实现的电子词典软件，以及另一款基于数组实现的电子词典软件。这两款软件都是为用户提供查词和学习单词的便利工具。" 知识点一：链表数据结构 在软件开发中，链表是一...
基于C语言实现电子英汉词典
最新发布
05-22
文件"基于C语言实现电子英汉词典_137行"可能包含了这些函数的实现。代码中，可以看到如何处理输入、内存管理、错误处理以及与用户交互的细节。 此外，考虑到实际应用，程序可能还需要读取和保存词典数据到文件，...
C语言单链表实现字典索引
04-25
详细描述了如何利用C语言实现二级链表，第一级存储所有的26个字母，二级存储对应的单词都有详细的注释。
电子词典C语言代码（华清）
05-02
基于C语言、Sqlite3编写的在线电子词典小项目，运用到进程、线程、网络套接字等知识，该电子词典适用于华清培训的小项目，最好自己能够实现
电子词典--两次扫描文件发/链表法
吴英强的技术博客
04-28 1256
二次扫描文件法实现的电子词典 #define _CRT_SECURE_NO_WARNINGS #include #include #include #include struct dict { char *key; char *content; }; int get_dict_size(FILE *pfile)//得到字典文件中词条总数 { if (pfile == NULL)
用c语言链表做一个词典,电子字典C语言链表版
weixin_35531779的博客
05-21 708
#define _CRT_SECURE_NO_WARNINGS#include #include #include #include struct dict{char *key;char *content;struct dict *next;//指向链表下一个节点的指针};//打开字典文件，并读取文件内容int open_dict(struct dict **p, const char *dict...
c语言链表实现词典,大家帮帮忙，谁帮忙用C语言链表编写一个英语查询词典！~...
weixin_32230811的博客
05-21 341
该楼层疑似违规已被系统折叠隐藏此楼查看此楼给定一个单词库文件(txt类型)，含有英语单词和中文解释，英语单词和中文解释之间有空格隔开。每行一个英语单词构建的数据结构如下struct word{char enword[18];char cnword[128];struct word * next;}要求根据该数据结构，从txt文件中为了保证读出的数据正确，不妨做个判断 可以考虑用isalpha逐个...
编写电子词典（含自定义头文件和链表的建立）
weixin_30374009的博客
02-29 125
编辑器加载中... 本电子词典功能：查单词，单词复习，单词学习，单词填空，根据汉语输入英文,有时间提示的单词风暴 第一部分：main函数编写#include <stdio.h>#include <string.h>#include "list.h"#include "tool.h"#include "game.h"#include <stdlib.h>int...
[BZOJ]1819: [JSOI]Word Query电子字典 trie+链表
TYB的博客
10-10 378
trie+链表
c语言词频统计单链表,浅析基于单链表和散列表比较的词频统计研究.doc
weixin_31781061的博客
05-21 295
技术应用论文：基于单链表和散列表比较的词频统计研究摘要:针对操作系统课程中的词频统计实验,介绍两种分别采用单链表和散列表进行词频统计的方法,并着重说明后一种方法在效率方面的优越性。关键词:单链表;散列表;词频统计;效率在操作系统课程中,词频统计实验具有重要的理论价值和实用价值,一直受到广大师生的重视。该实验要求编写程序,读取一个文件,对该文件中的英文文章进行词频统计,并把统计结果存放到另一个文件中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值