精华内容
下载资源
问答
  • 1.哈希表 数据储存在一片连续区域:单个节点保存键名(用于校验)和键值(目标数据)。 2.键名通过哈希函数变成索引,索引指定该数据储存位置。 3.常见的哈希函数方法有: 对于数值:线性变换,选取若干位,取余法。...

    1.哈希表  数据储存在一片连续区域:单个节点保存键名(用于校验)和键值(目标数据)。

    2.键名通过哈希函数变成索引,索引指定该数据储存位置。

    3.常见的哈希函数方法有:

       对于数值:线性变换,选取若干位,取余法。

       对于字符串,可以转换成数值,映射。

    4.键名通过函数映射成索引,经常会发生冲突,常见的处理方法:

    (1)试探性往后或往前找空位。

    (2)单独建个列表存放冲突的数据,当在原表中没有找到,则到该表找。

    (3)对于同一个索引,用链表连接,存放这些冲突哈希,链表便利搜索即可。

    转载于:https://www.cnblogs.com/welen/p/6422146.html

    展开全文
  • 数据结构 杂凑编程实现 完美运行 完美注释
  • (1)哈希函数:本案例选取“除留余数法”。 (2)碰撞问题:采用“线性探测法”解决。 2 实现代码 public class HaXi<E> { private class Node<E>{ public E e; public Node next; public...

    1 前置条件

    (1)哈希函数:本案例选取“除留余数法”。

    (2)碰撞问题:采用“线性探测法”解决。

    2 实现代码

    public class HaXi<E> {
    	
    	private class Node<E>{
    		public E e;
    		public Node next;
    		public Node(E e){
    			this.e = e;
    			this.next = null;
    		}
    	}
    	
    	private static final int M = 7;
    	private Node[] data;
    	
    	public HaXi(){
    		data = new Node[M];
    	}
    	
    	/**
    	 * 创建哈希表
    	 * @param e
    	 */
    	public void add(E e){
    		int hash = e.hashCode()  % M;
    		Node cur = data[hash];
    		if(cur==null){
    			cur = new Node(e);
    			data[hash] = cur;
    		}else{
    			while(cur!=null){
    				cur = cur.next;
    			}
    			cur = new Node(e);
    		}
    	}
    	
    	/**
    	 * 哈希查找
    	 */
    	public int find(E e){
    		int i=0, hash = e.hashCode() % M;
    		Node cur = data[hash];
    		while(cur!=null){
    			if(cur.e.equals(e)){
    				i++;
    				return i;
    			}else{
    				cur = cur.next;
    			}
    		}
    		return -1;
    	}
    	
    }
    

     

    展开全文
  • 哈希表是记录的存储位置和关键字之间建立的一种映射关系,这个映射关系就是hash函数.1:构建hash函数的方法:直接定植法:平方取中法除留余数法折叠法随机数法在构建hash函数的时候,会存在关键字不一样,但是记录会...

    哈希表是记录的存储位置和关键字之间建立的一种映射关系,这个映射关系就是hash函数.

    1:构建hash函数的方法:

    • 直接定植法:
    • 平方取中法
    • 除留余数法
    • 折叠法
    • 随机数法

    在构建hash函数的时候,会存在关键字不一样,但是记录会是一样的情况.key1≠key2,但是f(key1)=f(key2),这里的f就是哈希函数.这种现象就是冲突.

    解决这种冲突有如下办法:

    • 开放定址法(线性探测法)
    • 再散列函数法
    • 链地址法
    • 公共溢出区法

    下面建立一个用hash查找,删除,增加的字典程序.便于在实际使用中对词典进行更新.

    建立hash函数的方法是除留余数法

    解决冲突的方法是线性探测法.

    如下是简单的cpp代码.

    #include <iostream>
    #include <fstream>
    #include <string>
    #include <sstream>   //getline 包含在 sstream 中,要include!
    using namespace std;
    
    // 该工程是创建词典,查询词典
    
    #define LEN 		8		//中文字长度,中文字拼音长度 (中:zh ong1,声韵母结构)
    #define READ_NUM 	4		// 每个中文汉字最多有4种读音
    #define SUM_LEN 	LEN*READ_NUM
    #define SUCCESS		1
    #define FAILED		-1	
    #define TABLE_LEN	1024 	//散列表长度
    
    struct word{
    	char cwrd[LEN];
    	char phn[SUM_LEN];
    	int isExist;
    };
    
    class myHashTable{
    	public:
    		myHashTable();
    		~myHashTable();
    		void init();
    		bool loadDict(const char* dictFn);
    		int getHashAddr(const char* mwrd);
    		void updateDict(const char* mwrd);
    		void deleteWord(const char* mwrd);
    		void searchDict(const char* mwrd);
    		void logDict();
    		void saveDict(const char* outFn);
    		void getStdinStr(string &mstr);
    	private:
    		struct word mcwrd[TABLE_LEN];		
    }wrdHashTable;
    
    myHashTable::myHashTable()
    {
    	init();
    }
    myHashTable::~myHashTable()
    {
    	
    }
    void myHashTable::init(void)
    {
    	memset(mcwrd,0,sizeof(*mcwrd)*TABLE_LEN);
    }
    /*
    * 从当前的词典中加载进来
    */
    bool myHashTable::loadDict(const char* dictFn)
    {
    	ifstream fin;
    	fin.open(dictFn,ios::in);
    	string rdLine = "";
    	if(!fin.is_open())
    	{
    		cout <<"open " << dictFn << " failed" <<endl;
    		return false;
    	}
    	else
    	{
    		while(!getline(fin,rdLine))
    		{
    			//TODO
    		}
    	}
    	fin.close();
    	return true;
    }
    
    /*
    * 获取hash地址,以单字建立hash函数
    */
    int myHashTable::getHashAddr(const char* mwrd)
    {
    	int n = strlen(mwrd);
    	if(n == 0)
    		return FAILED;
    	int a = 0, ichar = 0;
    	for(int i = 0; i < n;++i)
    	{
    		ichar = mwrd[i];
    		if(ichar < 0)
    			ichar = -ichar;
    		a += ichar;
    	}
    	return a%TABLE_LEN; //除留余数法
    }
    void myHashTable::getStdinStr(string &mstr)
    {
    	mstr.clear();
    	getline(cin,mstr);
    	fflush(stdin);
    }
    /*
    * 更新字典
    */
    void myHashTable::updateDict(const char* mwrd)
    {
    	int n = getHashAddr(mwrd);
    	string s = "";
    	while(mcwrd[n].isExist)
    		n++;
    	memset(mcwrd[n].cwrd,0,sizeof(*mcwrd[n].cwrd)*LEN);
    	strcpy(mcwrd[n].cwrd,mwrd);
    	cout << "请输入该字的拼音:" << endl;
    	getStdinStr(s);
    	strcpy(mcwrd[n].phn,s.c_str());
    	fflush(stdin);
    	mcwrd[n].isExist = 1;
    	return ;
    }
    
    /*
    * 删除某个字
    */
    void myHashTable::deleteWord(const char* mwrd)
    {
    	int addr = getHashAddr(mwrd);
    	string s;
    	for(int i = 0;i < TABLE_LEN;++i)
    	{
    		s = (string)mcwrd[addr].cwrd;
    		if((s.compare(mwrd) == 0) &&(mcwrd[addr].isExist))
    		{
    			mcwrd[addr].isExist = 0;
    			return;
    		}
    		addr++;
    		if(addr == TABLE_LEN)
    			addr = 0;
    	}
    	cout <<"该字不存在字典中"<<endl;
    }
    
    /*
    * 查字典
    */
    void myHashTable::searchDict(const char* mwrd)
    {
    	int addr = getHashAddr(mwrd);
    	string s;
    	for(int i = 0;i < TABLE_LEN;++i)
    	{
    		s = (string)mcwrd[addr].cwrd;
    		if((s.compare(mwrd) == 0) &&(mcwrd[addr].isExist))
    		{
    			cout << mcwrd[addr].cwrd << "\t" << mcwrd[addr].phn<< endl;
    			return ;
    		}
    		addr++;
    		if(addr == TABLE_LEN)
    			addr = 0;
    	}
    	cout <<"checkDict:" << "该字不存在字典中" << endl;	
    }
    
    /*
    * 打印字典
    */
    void myHashTable::logDict(void)
    {
    	for(int i = 0; i < TABLE_LEN; ++i)
    	{
    		if(mcwrd[i].isExist)
    			cout << mcwrd[i].cwrd << "\t" << mcwrd[i].phn << "\t" << i << endl;
    	}
    }
    
    /*
    * 保存词典
    */
    void myHashTable::saveDict(const char* outFn)
    {
    	fstream fout;
    	fout.open(outFn,ios::out);
    	if(fout.is_open())
    	{
    		for(int i = 0; i < TABLE_LEN; ++i)
    		{
    			if(mcwrd[i].isExist)
    				cout << mcwrd[i].cwrd << "\t" << mcwrd[i].phn << endl;
    		}
    		fout.close();
    	}
    	else
    	cout <<"open " <<outFn << " failed" << endl;
    }
    
    void menu() //菜单 
    {
    	cout<<"菜单:"<<endl;
    	cout<<"1.添加"<<endl; 
    	cout<<"2.查找"<<endl;
    	cout<<"3.删除记录"<<endl;
    	cout<<"4.显示字典"<<endl;
    	cout<<"5.储存字典"<<endl;
    	cout<<"6.退出系统"<<endl;
    } 
    
    
    int main(void)
    {
    	myHashTable mHashTable;
    	//int x;
    	string wrd = "";
    	string x = "";
    	while(1)
    	{
    		menu();
    			//cin>>x;
    			//cout << x << endl;
    		getline(cin,x);
    		cout << x << endl;
    		//if (x<1 || x>5)
    		//{
    		//	cout<<"请从新输入:"<<endl;
    		//	cin>>x;
    		//}
    		if (x=="1")
    		{
    			cout<<"请输入新字:"<<endl;
    			mHashTable.getStdinStr(wrd);
    			mHashTable.updateDict(wrd.c_str());
    		}
    		if(x=="2") 
    		{	
    			cout<<"请输入你要查找的字:"<<endl; 
    			mHashTable.getStdinStr(wrd);
    			cout<<"输出查找的信息:"<<endl; 
    			mHashTable.searchDict(wrd.c_str());
    		}
    		if(x=="3")
    		{ 
    			cout<<"请输入要删除的字:"<<endl;
    			mHashTable.getStdinStr(wrd);
    			mHashTable.deleteWord(wrd.c_str());
    			cout<<"记录已删除!"<<endl;
    		}
    		if(x=="4")
    		{ 
    			cout<<"显示所有记录:"<<endl; 
    			mHashTable.logDict(); 
    		}
    		if(x=="5")
    		{ 
    			cout<<"通信录已保存:"<<endl; 
    			mHashTable.saveDict("./new.dct"); 
    		}
    		if(x=="6") 
    			return 0; 
    		fflush(stdin);
    	}
    }
    
    
    
    
    



    展开全文
  • 因此可以在读入一个雪花的时候把这些情况全部放入哈希表中,如果某次插入的时候发生冲突,则说明存在重复的雪花,并且后面的不需要再处理。 */ #include #include #include #include using namespace std; ...

    http://poj.org/problem?id=3349

    Description

    You may have heard that no two snowflakes are alike. Your task is to write a program to determine whether this is really true. Your program will read information about a collection of snowflakes, and search for a pair that may be identical. Each snowflake has six arms. For each snowflake, your program will be provided with a measurement of the length of each of the six arms. Any pair of snowflakes which have the same lengths of corresponding arms should be flagged by your program as possibly identical.

    Input

    The first line of input will contain a single integer n, 0 < n ≤ 100000, the number of snowflakes to follow. This will be followed by n lines, each describing a snowflake. Each snowflake will be described by a line containing six integers (each integer is at least 0 and less than 10000000), the lengths of the arms of the snow ake. The lengths of the arms will be given in order around the snowflake (either clockwise or counterclockwise), but they may begin with any of the six arms. For example, the same snowflake could be described as 1 2 3 4 5 6 or 4 3 2 1 6 5.

    Output

    If all of the snowflakes are distinct, your program should print the message:
    No two snowflakes are alike.
    If there is a pair of possibly identical snow akes, your program should print the message:
    Twin snowflakes found.

    Sample Input

    2
    1 2 3 4 5 6
    4 3 2 1 6 5

    Sample Output

    Twin snowflakes found.
    /**
    poj 3349  数字hash
    题目大意:每个雪花都有六个分支,用六个整数代表,这六个整数是从任意一个分支开始,朝顺时针或逆时针方向遍历得到的。输入多个雪花,判断是否有形状一致的雪花存在。
    解题思路:数字哈希,要注意的是每种雪花可以由多种数字组合表示。
    比如输入的是1 2 3 4 5 6,
    则2 3 4 5 6 1,3 4  5 6 1 2,……,6 5 4 3 2 1,5 4 3 2 1 6等都是相同形状的。
    因此可以在读入一个雪花的时候把这些情况全部放入哈希表中,如果某次插入的时候发生冲突,则说明存在重复的雪花,并且后面的不需要再处理。
    */
    #include <stdio.h>
    #include <string.h>
    #include <algorithm>
    #include <iostream>
    using namespace std;
    typedef long long LL;
    const int maxn=1200010;
    const int mod=1200007;
    
    int head[maxn],ip;
    
    void init()
    {
        memset(head,-1,sizeof(head));
        ip=0;
    }
    struct note
    {
        int num[6];
        int next;
    } edge[1200010];
    
    int get_hash(int *num)
    {
        int h=0;
        for(int i=0; i<6; i++)
            h+=num[i];///哈希函数,也可以用其他的构造方式
        return h%mod;
    }
    
    void insert_hash(int *num,int h)
    {
        for(int i=0; i<6; i++)
            edge[ip].num[i]=num[i];
        edge[ip].next=head[h];
        head[h]=ip;
        ip++;
    
    }
    
    bool compare(int *a,int *b)
    {
        for(int i=0; i<6; i++)
        {
            if(a[i]!=b[i])
                return false;
        }
        return true;
    }
    
    bool search_hash(int *num)
    {
        int h=get_hash(num);
        for(int i=head[h]; i!=-1; i=edge[i].next)
        {
            if(compare(num,edge[i].num))
                return true;
        }
        insert_hash(num,h);
        return false;
    }
    
    int main()
    {
        int n,num[2][15];
        scanf("%d",&n);
        init();
        int flag=0;
        while(n--)
        {
            for(int i=0; i<6; i++)
            {
                scanf("%d",&num[0][i]);
                num[0][i+6]=num[0][i];
            }
            if(flag) continue;
            for(int i=0; i<6; i++)
            {
                num[1][i+6]=num[1][i]=num[0][5-i];
            }
            for(int i=0; i<6; i++)
            {
                if(search_hash(num[0]+i)||search_hash(num[1]+i))
                {
                    flag=1;
                    break;
                }
            }
        }
        if(flag)printf("Twin snowflakes found.\n");
        else printf("No two snowflakes are alike.\n");
        return 0;
    }
    


    展开全文
  • 哈希表建立和查找哈希表建立和查找哈希表建立和查找哈希表建立和查找
  • 哈希表建立与运用C语言实现哈希表建立与运用C语言实现哈希表建立与运用C语言实现哈希表建立与运用C语言实现哈希表建立与运用C语言实现
  • 对一批关键字集合采用开放定址哈希表的存储结构来建立相应的哈希表和完成查找过程。 (1) 熟练掌握哈希表的构造方法 (2) 理解哈希表与其他结构表的实质性差别。
  • 易语言哈希表学习例程源码,哈希表学习例程,InitNameList,CreateHashList,子程序1,FindList,Display
  • 哈希表

    2017-02-20 16:44:04
    哈希表建立了关键字和存储地址之间的一种映射关系,是一种“空间换时间“的做法。 常用的哈希函数(多用于信息安全领域):MD4、MD5、SHA-1. 后两个称为哈希安全算法。 注:哈希算法不是一种加密算法,但由于其...
  • /usr/bin/env python#coding=utf-8#实现哈希表(线性地址再散列)def ChangeKey(key,m,di):key01=(key+di) % mreturn key01a=raw_input("Please entry the numbers:\n").split()m=len(a)dict01={}for i in a:key=int...
  • 哈希表建立与查询

    2014-06-16 08:47:23
    本代码主要是数据结构中哈希表建立与查询
  • 哈希表建立和查找

    2015-06-10 23:21:00
    建立哈希表的相关函数,用线性探查和二次探查解决冲突
  • python实现哈希表

    千次阅读 2019-06-12 19:26:49
    文章目录哈希表的概念...也就是说,哈希表建立了关键字和存储地址之间的一种直接映射关系。 哈希表的实现 假设哈希表长度为11,分别用两个列表来保存关键字和数据。 代码中的print()函数是为了方便理解,才加上的...
  • 哈希表(散列表) 通过哈希函数使元素的存储位置与它 的关键码之间能够建立一一映射的关系,在查找时可以很快找到该元素。 哈希表hash table(key,value) 的做法其实很简单,就是把Key通过一个固定的算法函数既...
  • #-*- coding: utf-8 -*-classArray(object):def __init__(self, size=32, init=None):self._size=sizeself._items= [init] *sizedef __getitem__(self, index):returnself._items[index]def __setitem__(self, index...
  • 哈希函数和哈希表

    2015-07-20 09:35:00
    哈希表建立了关键字和存储地址的映射。 哈希函数的方法: 直接定址法,除留余数法,数字分析法,平方取中法,折叠法 处理冲突的方法 开放定址法: 线性探测(容易聚集和堆积) 平方探测 拉链法: 转载于:...
  • 数据结构课设,实现哈希表建立,用的是人名,固定输入,用的话改一下代码里的输入即可,c++的
  • 文本文件可能有重复项,这将覆盖字典中现有的键(哈希表的python名称)。您可以创建一组唯一的键,然后使用字典理解来填充字典。在样本_文件.txtabccPython代码^{pr2}$这是一个包含100万个长度为10的随机字母字符的...
  • //功能,利用哈希表制作电话查询系统,根据姓名查询电话//建立哈希表之后,我想打印出这个表,但是没输出结果#include#include#include#include//功能,利用哈希表制作电话查询系统,根据姓名查询电话//建立哈希...
  • 数据结构课程设计 之姓名哈希表的建 立及查找 课程设计任务书 学生姓名 刘颖 专业班级 计科1003班 指导教师 谭新明 工作单位 计算机科学系 题目哈希表的设计与实现 初始条件 针对某个集体比如你所在的班级中的人名...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,569
精华内容 1,027
关键字:

哈希表建立