九 哈希表、图、图的遍历

最新推荐文章于 2023-10-31 16:02:42 发布
最新推荐文章于 2023-10-31 16:02:42 发布
阅读量688 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41375318/article/details/105889880
版权

哈希（散列）表概述

散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。

给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈希(Hash) 函数。

哈希表作为一种数据结构其实并不难，其本质就是一顺序存储的循序表。
只要牢牢抓住 M为哈希(Hash）表，函数f(key)为哈希(Hash) 函数 在代码中的实现就行
在这里插入图片描述
哈希表是顺序存储

散列函数的设计

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package demo13;

public class StuInfo {

	private int age;
	private int count;

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getCount() {
		return count;
	}

	public void setCount(int count) {
		this.count = count;
	}
	
	/**
	 * 散列函数
	 */
	public int hashCode() {
		return age;
	}

	public StuInfo(int age, int count) {
		super();
		this.age = age;
		this.count = count;
	}

	public StuInfo(int age) {
		super();
		this.age = age;
	}

	@Override
	public String toString() {
		return "StuInfo [age=" + age + ", count=" + count + "]";
	}

}


===================================================================================

package demo13;

import java.util.Arrays;

public class TestHashTable {

	public static void main(String[] args) {
		StuInfo s1 = new StuInfo(16, 3);
		StuInfo s2 = new StuInfo(17, 11);
		StuInfo s3 = new StuInfo(18, 23);
		StuInfo s4 = new StuInfo(19, 24);
		StuInfo s5 = new StuInfo(20, 9);
		
		HashTable ht = new HashTable();
		ht.put(s1);
		ht.put(s2);
		ht.put(s3);
		ht.put(s4);
		ht.put(s5);

		System.out.println(ht);
		
		//想要获取的目标数据
		StuInfo target = new StuInfo(18);
		StuInfo info = ht.get(target);
		System.out.println(info);
		
	}
	
}

===================================================================================

package demo13;

import java.util.Arrays;

public class HashTable {
	private StuInfo[] data = new StuInfo[100];
	
	/**
	 * 向散列表中添加元素
	 * @param stuInfo
	 */
	public void put(StuInfo stuInfo) {
		//调用散列函数获取存储位置
		int index = stuInfo.hashCode();
		//添加元素
		data[index]=stuInfo;
	}
	
	public StuInfo get(StuInfo stuInfo) {
		return data[stuInfo.hashCode()];
	}

	@Override
	public String toString() {
		return "HashTable [data=" + Arrays.toString(data) + "]";
	}
	
	

}

散列冲突的解决方案

在这里插入图片描述
在这里插入图片描述
链地址法会更常用一些

图结构概述

图虽然作为比较难的数据结构，但是如果能把握住图中主要含有的 顶点组 和 邻接矩阵就会容易理解和使用
在这里插入图片描述

图结构代码实现

在这里插入图片描述

public class Graph {

	// 定义所有顶点
      private Vertex[] vertex;
	// 定义当前顶点多少
      public int currentSize;
	// 定义邻接矩阵
      public int[][] adjMat;
   // 图的构造函数，用于初始化
      public  Graph(int size){
      	vertex=new Vertex[size];
      	adjMat=new int[size][size];
	  }

 // 加入顶点,就是加入顶点集合里
	public void addVertex(Vertex v){
      	vertex[currentSize++]=v;
	}


    // 确定邻接矩阵，即确定边
	 public void addEdge(String v1,String v2) {
		 //找出两个顶点的下标
		 int index1=0;
		 int index2=0;
		 for(int i=0;i<vertex.length;i++){
		 	if(vertex[i].getValue().equals(v1)){
		 		index1=i;
		 		break;
			}
		 }
		 for(int i=0;i<vertex.length;i++){
			 if(vertex[i].getValue().equals(v2)){
				 index2=i;
				 break;
			 }
		 }
		 for(int i=0;i<vertex.length;i++){
			 adjMat[i][i]=1;
		 }
		 adjMat[index1][index2]=1;
		 adjMat[index2][index1]=1;
	 }
}

package demo14;

import demo2.MyStack;

/**
 * 图
 * @author Richard
 *
 */
public class Graph {

	private Vertex[] vertex;
	private int currentSize;
	public int[][] adjMat;
	private MyStack stack = new MyStack();
	//当前遍历的下标
	private int currentIndex;
	
	public Graph(int size) {
		vertex=new Vertex[size];
		adjMat=new int[size][size];
	}
	
	/**
	 * 向图中加入一个顶点
	 * @param v
	 */
	public void addVertex(Vertex v) {
		vertex[currentSize++]=v;
	}
	
	public void addEdge(String v1,String v2) {
		//找出两个顶点的下标
		int index1=0;
		for(int i=0;i<vertex.length;i++) {
			if(vertex[i].getValue().equals(v1)) {
				index1=i;
				break;
			}
		}
		int index2=0;
		for(int i=0;i<vertex.length;i++) {
			if(vertex[i].getValue().equals(v2)) {
				index2=i;
				break;
			}
		}
		adjMat[index1][index2]=1;
		adjMat[index2][index1]=1;
	}
	
	/**
	 * 深度优先搜索算法遍历图
	 */
	public void dfs() {
		//把第0个顶点标记为已访问状态
		vertex[0].visited=true;
		//把第0个顶点的下标。
		stack.push(0);
		//打印顶点的值
		System.out.println(vertex[0].getValue());
		//遍历
		out:while(!stack.isEmpty()) {
			for(int i=currentIndex+1;i<vertex.length;i++) {
				//如果和下一个遍历的元素是通的
				if(adjMat[currentIndex][i]==1&&vertex[i].visited==false) {
					//把下一个元素压入栈中
					stack.push(i);
					vertex[i].visited=true;
					System.out.println(vertex[i].getValue());
					continue out;
				}
			}
			//弹出栈顶元素
			stack.pop();
			//修改当前位置为栈顶元素的位置
			if(!stack.isEmpty()) {
				currentIndex=stack.peek();
			}
		}
	}
	
}


package demo14;

import java.util.Arrays;

public class TestGraph {

	public static void main(String[] args) {
		Vertex v1 = new Vertex("A");
		Vertex v2 = new Vertex("B");
		Vertex v3 = new Vertex("C");
		Vertex v4 = new Vertex("D");
		Vertex v5 = new Vertex("E");
		Graph g = new Graph(5);
		g.addVertex(v1);
		g.addVertex(v2);
		g.addVertex(v3);
		g.addVertex(v4);
		g.addVertex(v5);
		
		//增加边
		g.addEdge("A", "C");
		g.addEdge("B", "C");
		g.addEdge("A", "B");
		g.addEdge("B", "D");
		g.addEdge("B", "E");
		
		for(int[] a:g.adjMat) {
			System.out.println(Arrays.toString(a));
		}
		//深度优先遍历
		g.dfs();
	}
	
}


package demo14;

/**
 * 顶点类
 * @author Richard
 */
public class Vertex {

	private String value;
	public boolean visited;

	public String getValue() {
		return value;
	}

	public void setValue(String value) {
		this.value = value;
	}

	public Vertex(String value) {
		super();
		this.value = value;
	}

	@Override
	public String toString() {
		return value;
	}

}

图的遍历原理

深度优先遍历，使用的是栈
广度优先遍历，使用的是队列
在这里插入图片描述

在这里插入图片描述

图的遍历代码实现

*Major*
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
遍历哈希表
日积月累
10-29 3341
  遍历哈希表遍历哈希表需要用到DictionaryEntry Object，代码如下： foreach(DictionaryEntry de in ht) //ht为一个Hashtable实例 {   Console.WriteLine(de.Key);//de.Key对应于key/value键值对key   Console.WriteLine(de.Value);//d
什么？哈希表查询相当于一次遍历？
key_coding的博客
08-21 315
相信大家都知道哈希表的原理。哈希表通过哈希函数将键值转化为哈希值，再通过哈希值就可以找到存储的内容，从而使键值起到类似于数组下标的作用。这样哈希表通过O(1)的时间复杂度就能找到存储元素。 我们来想一下这个过程，当键通过哈希函数匹配到了其相应的存储元素的时候，它同时也意味着键与其它的所有存储元素都不匹配（姑且认为一个槽只存储一个元素，不考虑哈希碰撞）。而如果不用哈希表要达到同样的效果，必须进行时间复杂度为O(n)的遍历才行（当然用搜索树进行查询时间复杂度为log(n), 也能达到同样的效果。这里主要考
让哈希表(Hashtable)顺序输出。
聚合博客室
02-18 8414
 System.Collections.Hashtable是用来表示一组组key/value结构的容器，可能别的语言会把它叫做Map，Dictionary的，其结构中Key用来快速查找，所以，叫它Dictionary可能更加合适。 Hashtable的方法、属性并不多，大多数也可以望文生正义，只是有一点，Hashtable提供了hashTable[aKey]的方式引用其包含的对象，却并没有提供数字
【数据结构】顺序哈希表与链式哈希表
weixin_34202952的博客
08-03 357
顺序哈希表 头文件 1 //@　author　成鹏致远 2 //@　net http://infodown.tap.cn 3 //@　qq 552158509 4 //@ blog　lcw.cnblogs.com 5 6 #ifndef __HASHSQ_H 7 #define __HASHSQ_H 8 9 #include &lt;stdio.h...
数据结构与算法总结三：哈希表、图结构、简单排序（冒泡/选择/插入）、高级排序（希尔/快速）
qq_42045868的博客
08-27 875
数据结构——图结构
java哈希遍历_哈希遍历_
09-29
在Java编程中，哈希遍历（Hash Traversal）通常是指对哈希表或映射数据结构（如HashMap）中的键值对进行访问的过程。哈希表是一种高效的数据存储方式，它通过计算对象的哈希码来快速定位数据，使得查找、插入和删除...
C#使用foreach遍历哈希表（hashtable）的方法
09-03
在实际开发中，我们常常需要遍历哈希表来访问或处理其中的数据。本文将详细介绍如何使用`foreach`语句遍历C#中的哈希表。 `foreach`循环是C#中一种简洁的遍历集合元素的语法，它可以自动处理迭代器的工作。对于哈希...
C语言实现哈希表（源码+解析）
03-13
哈希表节点结构 struct Node：表示哈希表中的一个节点，包含键、值以及指向下一个节点的指针。 哈希表结构 struct HashTable：表示哈希表，包含一个存储节点指针的数组。 创建哈希表函数 createHashTable：动态...
哈希表Hash table 用于哈希表等的 C 宏
01-15
`uthash`宏库提供了一系列的宏定义，用于声明哈希表结构、初始化、插入元素、查找元素、删除元素以及遍历哈希表等操作。例如： 1. **声明哈希表结构**：首先，你需要定义一个结构体，其中包含你想要存储的数据以及`...
哈希表的增、删、查、遍历
花开归矣的博客
10-07 3201
package com.zzb.hashtable; import java.io.Serializable; /** * @Auther: Administrator * @Date: 2019/10/7 00:44 * @Description: 哈希表的增、删、查、遍历 * * 哈希表数据结构 就是 数组数据结构 与 链表数据结构 的组合而构成的，即 * 哈希表 = 数组 ...
哈希表及二叉树遍历
qq_58679358的博客
09-15 254
完全二叉树：所有叶子节点都在最后一层或者在倒数第二层，且最后一层左边连续，倒数第二层叶子节点在右边连续。满二叉树：所有叶子节点都在最后一层，节点数为2n次方-1 n为层数。最多有两个子节点的树叫二叉树。： 叶子节点：没有子节点的节点。2.初始化哈希表上的链。
java中哈希表HashMap详解遍历操作
qq_44871442的博客
07-26 3501
一.主题外谈     在进入主题之前，先讲一点与哈希表相关的一些东西： 1.Hash算法， 通常还可用作快速查找。 2.哈希函数，是支撑哈希表的一类「函数」。 3.哈希表(Hash Table)，是一种**「数据结构」**。 ps:hash家族中 HashMap和Hash table 是有异同的，可参考：https://blog.csdn.net/ahach...
Java——遍历哈希表方法详解
喻师傅的学习笔记
10-31 892
java遍历哈希表方法详解
Java小知识：哈希图的遍历顺序
https://github.com/blingbling-110
12-23 328
项目中遇到一个排序问题，发现遍历HashMap所输出的元素顺序错了，并没有按照添加顺序输出。 原来，HashMap按有利于随机查找的散列(hash)的顺序而并非按输入顺序遍历。 要使其遍历顺序按“先进先出”的规则，则需使用LinkedHashMap ...
LeetCodeTwo Sum IV 树的遍历+Hash大法好
稻云麦花的博客
02-18 171
题意 给定一颗二叉搜索树，取是否存在两个节点的值之和为给定值K. 思路 同Two Sum.使用Hash表解决。只是要写个树的遍历而已，选取DFS. 源码 class Solution { public boolean findTarget(TreeNode root, int k) { return work(root,k,new HashSet&amp;amp;lt;Integer&amp;amp;gt...
数据结构-散列表-图
se7en_q的博客
03-04 718
一、散列表如Java中的map,Python中的dict SHA函数： 待定。。。 你几乎根本不用自己去实现散列表，因为你使用的编程语言提供了散列表实现。你可使用 Python提供的散列表，并假定能够获得平均情况下的性能:常量时间。 散列表是一种功能强大的数据结构，其操作速度快，还能让你以不同的方式建立数据模型。 你可能很快会发现自己经常在使用它。 总结：  你可以结合散列函...
hashMap六种遍历方式
m0_57868773的博客
02-11 409
hashMap的一堆k-v放在HashMap$Node，其类型为EntrySet<entry>.而其中的k为set类型，v为collection类型。所以在遍历的时候，第一种方法是可以先取出key，用set的方法遍历key再找到value。第二种方法使直接用map的getValue，再用collection的方法遍历。第三种是通过EntrySet来获取k-v。具体实现代码如下： public static void main(String[] args) { HashMap h
#1020. Tree Traversals【树的遍历 + DFS 建树 + 哈希】
geraltofrivia123的博客
10-14 131
原题链接 Problem Description： Suppose that all the keys in a binary tree are distinct positive integers. Given the postorder and inorder traversal sequences, you are supposed to output the level order traversal sequence of the corresponding binary tree. Input
c语言如何遍历哈希表
最新发布
03-18
在C语言中，哈希表是一种常用的数据结构，用于存储键值对。遍历哈希表可以通过以下步骤实现： 1. 创建一个指向哈希表的指针，并初始化为哈希表的起始位置。 2. 使用循环遍历哈希表的每个桶（bucket）或槽（slot），直到遍历完所有的桶。 3. 在每个桶中，遍历链表或其他数据结构，以访问存储在哈希表中的键值对。 4. 对于每个键值对，可以执行相应的操作，如打印键和值。 5. 继续遍历下一个桶，直到遍历完整个哈希表。 以下是一个示例代码，演示了如何遍历一个简单的哈希表： ```c #include <stdio.h> #define SIZE 10 // 定义哈希表节点结构 typedef struct Node { int key; int value; struct Node* next; } Node; // 创建哈希表 Node* createHashTable() { Node* hashTable[SIZE] = { NULL }; return hashTable; } // 向哈希表中插入键值对 void insert(Node** hashTable, int key, int value) { // 计算哈希值 int index = key % SIZE; // 创建新节点 Node* newNode = (Node*)malloc(sizeof(Node)); newNode->key = key; newNode->value = value; newNode->next = NULL; // 插入节点到哈希表中 if (hashTable[index] == NULL) { hashTable[index] = newNode; } else { Node* temp = hashTable[index]; while (temp->next != NULL) { temp = temp->next; } temp->next = newNode; } } // 遍历哈希表 void traverseHashTable(Node** hashTable) { for (int i = 0; i < SIZE; i++) { Node* temp = hashTable[i]; while (temp != NULL) { printf("Key: %d, Value: %d\n", temp->key, temp->value); temp = temp->next; } } } int main() { Node** hashTable = createHashTable(); // 向哈希表中插入键值对 insert(hashTable, 1, 10); insert(hashTable, 2, 20); insert(hashTable, 11, 30); // 遍历哈希表并打印键值对 traverseHashTable(hashTable); return 0; } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值