最近在学习数据结构中树的概念，迟迟不得入门，应该是自己的懒惰和没有勤加练习导致的，以后应该多加练习
 
以下是我对二叉树的一些总结内容
 二叉树的特点有：
 
每一个节点最多有两棵子树，所以二叉树中不存在度大于2的节点，注意，是最多有两棵，没有也是可以的
 左子树和右子树是有顺序的，次序不能颠倒，这点可以在哈夫曼编码中体现， 顺序不同编码方式不同
 
-即使树中某个节点中只有一个子树的花，也要区分它是左子树还是右子树
 二叉树一般有五种形态
 1.空二叉树
 2.只有一个根节点
 3.根结点只有左子树
 4.根节点只有右子树
 
 
二叉树的性质
 1：在二叉树的第i层上最多有2^(i-1)个节点
 2：深度为K的二叉树之多有2^(k-1)个节点
 
注：这里的深度K意思就是有K层的二叉树
 
3：对于任何一棵二叉树T，如果其终端节点有No个，度为2的节点数有N2，则No=N2+1
 4: 具有n个节点的完全二叉树的深度为[log2n]+1([x]表示不大于x的最大整数）
 
1，二叉树的存储结构（二叉链表）
 
//二叉树的存储结构，一个数据域，2个指针域
 typedef struct BiTNode
{
     char data;
     struct BiTNode *lchild,*rchild;
  }BiTNode,*BiTree;

 
 2，首先要建立一个二叉树，建立二叉树必须要了解二叉树的遍历方法。，我在这里展示的是二叉树的递归建立方式
 
//我在这里实现的是，二叉树的前序遍历方式创建，如果要使用中序或者后序的方式建立二叉树，只需将生成结点和构造左右子树的顺序改变即可
 void CreateBiTree(BiTree *T)
  {
      char ch;
      scanf("%c",&ch);
      if(ch=='#')
          *T=NULL;
      else
     {
         *T=(BiTree  )malloc(sizeof(BiTNode));
         if(!*T)
             exit(-1);
          (*T)->data=ch;
          CreateBiTree(&(*T)->lchild);
         CreateBiTree(&(*T)->rchild);
      }
 }

 

 3。二叉树的遍历方式（递归建立）
 
void PreOrderTraverse(BiTree T)//二叉树的先序遍历
{
    if(T==NULL)
        return ;
    printf("%c ",T->data);
    PreOrderTraverse(T->lchild);
    PreOrderTraverse(T->rchild);
}
void InOrderTraverse(BiTree T)//二叉树的中序遍历
{
   if(T==NULL)
       return ;
   InOrderTraverse(T->lchild);
    printf("%c ",T->data);
   InOrderTraverse(T->rchild);
}
void PostOrderTraverse(BiTree T)//后序遍历
{
    if(T==NULL)
        return;
    PostOrderTraverse(T->lchild);
    PostOrderTraverse(T->rchild);
    printf("%c ",T->data);
}
 
4.完整代码
 
#include<stdio.h>
#include<stdlib.h>
typedef struct BiTNode
{
    char data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void PreOrderTraverse(BiTree T)//二叉树的先序遍历
{
    if(T==NULL)
        return ;
    printf("%c ",T->data);
    PreOrderTraverse(T->lchild);
    PreOrderTraverse(T->rchild);
}
void InOrderTraverse(BiTree T)//二叉树的中序遍历
{
   if(T==NULL)
       return ;
   InOrderTraverse(T->lchild);
    printf("%c ",T->data);
   InOrderTraverse(T->rchild);
}
void PostOrderTraverse(BiTree T)//后序遍历
{
    if(T==NULL)
        return;
    PostOrderTraverse(T->lchild);
    PostOrderTraverse(T->rchild);
    printf("%c ",T->data);
}
void CreateBiTree(BiTree *T)
{
    char ch;
    scanf("%c",&ch);
    if(ch=='#')
        *T=NULL;
    else
    {
        *T=(BiTree  )malloc(sizeof(BiTNode));
        if(!*T)
            exit(-1);
        (*T)->data=ch;
        CreateBiTree(&(*T)->lchild);
        CreateBiTree(&(*T)->rchild);
    }
}
int main()
{
    BiTree T;
    CreateBiTree(&T);
    PreOrderTraverse (T);
    InOrderTraverse(T);
    PostOrderTraverse(T);
    return 0;
}

 
对知识点的补充：
 （1）建立二叉树时，这里是以前序遍历的方式，输入的是扩展二叉树，也就是要告诉计算机什么是叶结点，否则将一直递归，当输入“#”时，指针指向NULL，说明是叶结点。
 
如图为扩展二叉树：（前序遍历为：ABDG##H###CE#I##F##）
 

最近在学习机器人运动控制学,用到了矩阵运算,并用C语言实现之
 首先声明该代码在Ubuntu18.04下运行通过, 如若在windows下运行失败请考虑编译器版本问题
 
一个矩阵最基本的有行数line,列数row和 行数乘以列数个数据(row*line), 所以用一个最基本的结构体变量来表示一个矩阵;
 矩阵的结构体:
 
typedef struct 
{
	int row,line;			//line为行,row为列
	double *data;
}Matrix;
 
这样在创建一个矩阵的时候只需要分配row,line和data的内存就好.
 然后…好像也没啥好说的… 直接根据所学矩阵的基本运算只是写代码就好…
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

double value[] = {1,2,3,4,5,6,7,8,9};
double value2[] = {9,8,7,6,5,4,3,2,1};

typedef struct 
{
	int row,line;		//line为行,row为列
	double *data;
}Matrix;

Matrix* InitMatrix(Matrix *matrix,int row,int line);		//初始化矩阵
void ValueMatrix(Matrix *matrix,double *array);				//给一个矩阵赋值
int SizeMatrix(Matrix *matrix);								//获得一个矩阵的大小
void FreeMatrix(Matrix *matrix);							//释放一个矩阵
void CopyMatrix(Matrix *matrix_A, Matrix *matrix_B);		//复制一个矩阵的值
void PrintMatrix(Matrix *matrix);							//打印一个矩阵

//矩阵的基本运算
Matrix* AddMatrix(Matrix *matrix_A,Matrix *matrix_B);		//矩阵的加法
Matrix* MulMatrix(Matrix *matrix_A,Matrix *matrix_B);		//矩阵的乘法
void TransMatrix(Matrix *matrix);			//条件为方阵

int main(int argc,char* argv[])
{
	Matrix *matrix1 = InitMatrix(matrix1,3,3);
	Matrix *matrix2 = InitMatrix(matrix2,3,3);

	ValueMatrix(matrix1,value);
	// CopyMatrix(matrix1,matrix2);	//复制赋值
	ValueMatrix(matrix2,value2);

	printf("矩阵1 乘以 矩阵2: \n");
	Matrix *matrix3 = MulMatrix(matrix1,matrix2);	//乘法
	PrintMatrix(matrix3);	
	printf("矩阵1 加上 矩阵2: \n");
	Matrix *matrix4 = AddMatrix(matrix1,matrix2);	//加法
	PrintMatrix(matrix4);
	printf("矩阵1进行转置: \n");
	TransMatrix(matrix1);					//转置
	PrintMatrix(matrix1);
	
	return 0;
}

Matrix* InitMatrix(Matrix *matrix,int row,int line)				//初始化一个矩阵
{
	if (row>0 && line>0)
	{
		matrix = (Matrix*)malloc(sizeof(Matrix));
		matrix->row = row;
		matrix->line = line;
		matrix->data = (double*)malloc(sizeof(double)*row*line);
		memset(matrix->data,0,sizeof(double)*row*line);
		return matrix;
	}
	else 
		return NULL;
} 

void ValueMatrix(Matrix *matrix,double *array) 		//给矩阵赋值
{
	if (matrix->data != NULL)
	{
		memcpy(matrix->data, array, matrix->row*matrix->line*sizeof(double));
	}
}

int SizeMatrix(Matrix *matrix)
{
	return matrix->row*matrix->line;
}

void FreeMatrix(Matrix *matrix)
{
	free(matrix->data);		//释放掉矩阵的data存储区
	matrix->data = NULL;
	printf("释放成功\n");
}

void CopyMatrix(Matrix *matrix_A, Matrix *matrix_B)
{
	matrix_B->row = matrix_A->row;
	matrix_B->line = matrix_A->line;
	memcpy(matrix_B->data, matrix_A->data, SizeMatrix(matrix_A)*sizeof(double));
}

void PrintMatrix(Matrix *matrix)
{
	for (int i=0;i<SizeMatrix(matrix);i++)
	{
		printf("%lf\t", matrix->data[i]);
		if ((i+1)%matrix->line == 0)
			printf("\n");
	}
			
}
//加法
Matrix* AddMatrix(Matrix *matrix_A,Matrix *matrix_B)
{
	if (matrix_A->row == matrix_B->row && matrix_A->line == matrix_B->line)
	{
		Matrix *matrix_C = InitMatrix(matrix_C,matrix_A->row,matrix_A->line);
		for (int i=0;i<matrix_A->line;i++)
		{
			for (int j=0;j<matrix_A->row;j++)
			{
				matrix_C->data[i*matrix_C->row + j] = \
				matrix_A->data[i*matrix_A->row + j] + matrix_B->data[i*matrix_A->row + j];
			}
		}
		return matrix_C;
	}
	else 
	{
		printf("不可相加\n");
		return NULL;
	}
}

//乘法
Matrix* MulMatrix(Matrix *matrix_A,Matrix *matrix_B)
{
	if (matrix_A->row == matrix_B->line)		//列==行
	{
		Matrix *matrix_C = InitMatrix(matrix_C,matrix_B->row,matrix_A->line);
		// matrix_C->line = matrix_A->line;		//A行
		// matrix_C->row = matrix_B->row;			//B列
		for (int i=0;i<matrix_A->row;i++)
		{
			for (int j=0;j<matrix_B->line;j++)
			{
				for (int k=0;k<matrix_A->line;k++)
				{
					matrix_C->data[i*matrix_C->line + j] += \
					matrix_A->data[i*matrix_A->line + k] * matrix_B->data[k*matrix_B->row + j];
				}
			}
		}
		return matrix_C;
	}
	else
	{
		printf("不可相乘\n");
		return NULL;
	}
}

//矩阵转置
void TransMatrix(Matrix *matrix)			//条件为方阵
{
	if (matrix->row == matrix->line)
	{
		Matrix *matrixTemp = InitMatrix(matrixTemp, matrix->row,matrix->line);       	//创建一个临时矩阵
		CopyMatrix(matrix,matrixTemp);	//将目标矩阵的data复制给临时矩阵

		for (int i=0;i<matrix->row;i++)
		{
			for (int j=0;j<matrix->line;j++)
			{
				matrix->data[i*matrix->row + j] = matrixTemp->data[j*matrix->row + i];
			}
		}
	}
	else
	{
		printf("转置的矩阵必须为方阵\n");
	}
}

 
恩…都是代码…尽情享用吧!

循环队列–C语言实现–数据结构
 
 
目录
 

 
 
循环队列C语言实现数据结构
   

     
目录
 
一 要求
二 循环队列
三 循环队列的算法设计
     
1 建立循环队列
2 置空队列
3 入队
4 出队
5 打印队
 
四 程序
     
1 程序的结构
2 程序源码
 
五 程序测试
     
1 入队列
2 出队列
3 打印队列
 
六 源程序及封装软件下载
     
下载地址
       
格格是一枚智能专业的本科在校生很愿意和各位大佬交流如果大家有愿意交朋友的可以加格格的QQ446019725声明是CSDN即可
 
 
 
 
 
 
 
（一） 要求
 
 
 
假设以数组sequ[m]存放循环队列的元素，同时设变量rear和quelen 分别指示循环队列中队尾元素的位置和内含元素的个数。编写实现该循环队列的入队和出队操作的算法。提示：队空的条件：sq->quelen==0；队满的条件：sq->quelen==m。
 
 
 
（二） 循环队列
 
 
 
定义：为充分利用向量空间，克服”假溢出”现象的方法是：将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量。存储在其中的队列称为循环队列（Circular Queue）。这种循环队列可以以单链表的方式来在实际编程应用中来实现, 当然也可以利用顺序表来实现。顺序表就是我们熟悉的数组 eg. sun[] 。 
 回顾：我们再来回顾一下关于顺序队列的重要知识点。队列通常与栈对应，栈是一种后进先出的单端（尾端）处理的数据结构；那么与之对应的队列是一种先进先出的双端（头尾两端）的数据结构。队列的特点就是在一段进行入队（存储数据）操作，在另一端进行出队（删除数据）操作。 
 为什么设计循环队列：大家在处理队列的时候，会遇到如下情况。例如说：我们的队列空间能够容纳1000个元素。首先，格格入队1000个元素，队列上溢，此时为“真溢出”。那么现在我们进行出队操作，我们一直出队，一直出队， 知道1000个元素全部被删除，此时我们发现队列仍然处于“上溢”状态，why？ 其实原因很简单，在非循环队列当中，无论我们的front指（偏移）到哪里，只要我们的rear指（偏移）向上阙，那么队列就是“满溢”的。这就造成了空间明明还被占据着，但是队列却已经无用武之地的窘境。对于空间有限的计算机来说，这无疑是一种浪费。也不是一个优秀的程序猿想要看到的。所以在这种情况下，循环队列诞生了。循环队列当中的“满溢”只有一种情况，那就是所有数据空降都被占领了。而不会存在非循环队列当中的“假溢出”现象。
 
 
 
 
 
我们所常见的顺序循环队列通常有两种数据结构。
 
 
结构一
 
typedef struct
{
    datatype sequ[m];
    //sequ[]为我们所建立的顺序表（sequence）
    int  front,rear;
    //front表示队列头的偏移量，rear表示队列的尾的偏移量
}qu;//qu是队列（queue）的缩写
 
 
结构二
 
typedef struct
{
    datatype sequ[m];
    //sequ[]为我们所建立的顺序表（sequence）
    int  rear, quelen;
    //rear表示队列的尾的偏移量，quelen表示的是队列中元素的个数
}qu;//qu是队列（queue）的缩写
 
 
 
 
那通过观察这两种机构我们能够很容易的发现，数据结构并不是固定的。我们觉得那种算法比较更合理，我们觉得哪种数据结构方便我们设计算法，那么我们就建立哪种数据结构。在本文当中，我们采用第二种数据结构。显而易见的是，当我们采用第二种数据结构时，我们建立的一个队列指针（qu*sq）队空的条件：sq->quelen==0；队满的条件：sq->quelen==m。
 
 
 
（三） 循环队列的算法设计
 
 
在上面我们了解了循环队列的数据机构，但是仅仅学会了数据结构还远远不够。我们设计数据结构的目的是为了更好的存储数据，并利用数据。下面我们来看一看关于循环队列我们要掌握哪些最基本的算法（利用数据机构）。
 
 
3.1 建立循环队列
 
//建立队
qu* creatqueue();//函数声明
qu* creatqueue()//函数实现
{
    qu *sq;
    sq=(qu*)malloc(sizeof(qu));
    return sq;  
}
 
 
3.2 置空队列
 
//置空队
void setnull(qu*);//函数声明
void setnull(qu *sq)//函数实现
{
    sq->rear = m - 1;
    sq->quelen = 0;
}
 
 
3.3 入队
 
//入队
void enqueue(qu*, datatype);//函数声明
void enqueue(qu*sq, datatype x)//函数实现
{
    if (sq->quelen == 5)
        printf("Errot! The queue will be overflow! \n");
    else if((sq->rear+1)==m)
    {
        sq->rear = (sq->rear + 1) % m;
        sq->sequ[sq->rear] = x;
        sq->quelen++;
        printf("过5入队成功!\n");
    }
    else
    {
        sq->rear++;
        sq->sequ[sq->rear] = x;
        sq->quelen++;
        printf("入队成功！\n");
    }
}
 
 
 
3.4 出队
 
//出队
datatype *dequeue(qu*);//函数声明
datatype *dequeue(qu*sq)//函数实现
{
    datatype sun=0;
    if (sq->quelen == 0)
    {
        printf("Error! The queue will be under flow!\n");
        return 0;
    }
    else if ((sq->rear + 1) >= sq->quelen)
    {
        sq->quelen--;
        sun = sq->sequ[sq->rear - sq->quelen];
        return(&sun);
    }
    else    //  if(sq->rear < sq->quelen)
    {
        sq->quelen--;
        sun = sq->sequ[sq->rear - sq->quelen + m];
        return(&sun);
    }
}
 
 
 
3.5 打印队
 
//打印队
void print(qu*);//函数声明
void print(qu*sq)//函数定义
{
    if (sq->quelen == 0)
        printf("Error! The queue is Null!\n");
    else if ((sq->rear + 1) >= sq->quelen)
    {
        int i = sq->rear + 1 - sq->quelen;
        for (i; i <= sq->rear; i++)
            printf("%d   ", sq->sequ[i]);
    }
    else
    {
        int t = sq->rear - sq->quelen + m +1;
        int time = 1;
        for (t; time <= (sq->quelen); time++)
        {
            printf("%d   ", sq->sequ[t]);
            t++;
            if (t == m)
            {
                t = 0;
                continue;
            }
            else
            {
                continue;
            }
        }
    }
    printf("\n");
}
 
 
（四） 程序
 
 
下面我们来设计一个程序测试我们的数据机构与算法
 
 
4.1 程序的结构
 
 
 
4.2 程序源码
 
注意：该程序由Microsoft Visual Studio Enterprise 2015编译器进行调试。受制于编译器品牌及版本不同等不可抗因素造成的编译失败，请自行调整。
 
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define m 5

//循环队列的结构类型定义
typedef int datatype;
typedef struct
{
    datatype sequ[m];
    int  rear, quelen;
}qu;

//函数声明
qu* creatqueue();
void setnull(qu*);
void enqueue(qu*, datatype);
datatype *dequeue(qu*);
void print(qu*);

//主函数
void main()
{
    qu *sq= creatqueue();

    datatype x, *p;
    int key;

    setnull(sq);
    do
    {
        printf("1.Enter Queue   2.Delete Queue   3.clc display   4.print queue   -1.Quit:");
        scanf_s("%d", &key);
        switch (key)
        {
        case 1:  printf("Enter the Data:"); scanf_s("%d", &x);
            enqueue(sq, x);  break;
        case 2:  p = dequeue(sq);
            if (p != NULL) printf("%d\n", *p);
            break;
        case 3:system("cls"); break;
        case 4:print(sq); break;
        case -1: exit(0);
        }
    } while (1);
}

//建立队
qu* creatqueue()
{
    qu *sq;
    sq=(qu*)malloc(sizeof(qu));
    return sq;  
}
//置空队
void setnull(qu *sq)
{
    sq->rear = m - 1;
    sq->quelen = 0;
}

//入队
void enqueue(qu*sq, datatype x)
{
    if (sq->quelen == 5)
        printf("Errot! The queue will be overflow! \n");
    else if((sq->rear+1)==m)
    {
        sq->rear = (sq->rear + 1) % m;
        sq->sequ[sq->rear] = x;
        sq->quelen++;
        printf("过5入队成功!\n");
    }
    else
    {
        sq->rear++;
        sq->sequ[sq->rear] = x;
        sq->quelen++;
        printf("入队成功！\n");
    }
}


//出队
datatype *dequeue(qu*sq)
{
    datatype sun=0;
    if (sq->quelen == 0)
    {
        printf("Error! The queue will be under flow!\n");
        return 0;
    }
    else if ((sq->rear + 1) >= sq->quelen)
    {
        sq->quelen--;
        sun = sq->sequ[sq->rear - sq->quelen];
        return(&sun);
    }
    else    //  if(sq->rear < sq->quelen)
    {
        sq->quelen--;
        sun = sq->sequ[sq->rear - sq->quelen + m];
        return(&sun);
    }
}

//打印队列
void print(qu*sq)
{
    if (sq->quelen == 0)
        printf("Error! The queue is Null!\n");
    else if ((sq->rear + 1) >= sq->quelen)
    {
        int i = sq->rear + 1 - sq->quelen;
        for (i; i <= sq->rear; i++)
            printf("%d   ", sq->sequ[i]);
    }
    else
    {
        int t = sq->rear - sq->quelen + m +1;
        int time = 1;
        for (t; time <= (sq->quelen); time++)
        {
            printf("%d   ", sq->sequ[t]);
            t++;
            if (t == m)
            {
                t = 0;
                continue;
            }
            else
            {
                continue;
            }
        }
    }
    printf("\n");
}

 
 
（五） 程序测试
 
 
5.1 入队列
 
 
 
5.2 出队列
 
 
 
5.3 打印队列
 
 
 
前面已经用到了打印队列，所以格格不再赘述，大家由5.2&5.3可知打印队列是成功的。
 
 
 
(六) 源程序及封装软件下载
 
 
 
下载地址
 
 
 
 
 
格格是一枚智能专业的本科在校生，很愿意和各位大佬交流。如果大家有愿意交朋友的，可以加格格的QQ：446019725，声明是CSDN即可。
 
 
 

 
C语言实现HashMap
 

        在做算法题时,需要使用到HashMap这种数据结构，虽然高级语言中大都实现了这种数据结构，但是为了理解HashMap的底层原理，于是打算自己实现HashMap，使用C语言实现了HashMap的创建（CreateHashMap）、取键值对（Get）、插入键值对（Put）、输出（PrintHashMap）以及销毁（DestoryHashMap）,具体程序如下： 
1.结点类型定义：
 
typedef struct{
	int key;  //键
	int val;  //值
}DataType; //对基本数据类型进行封装，类似泛型
typedef struct{
	DataType data;
	struct HashNode *next;  //key冲突时，通过next指针进行连接
}HashNode;
typedef struct{
	int size;
	HashNode *table;
}HashMap,*hashmap;
 
2.HashMap基本操作：
 
①CreateHashMap
 
//f1_createHashMap
//将给定的整形数组构建为HashMap,size为数组长度
HashMap *CreateHashMap(int *nums,int size){
	//分配内存空间
	HashMap *hashmap=(HashMap*)malloc(sizeof(HashMap));
	hashmap->size=2*size;
	//hash表分配空间
	hashmap->table=(HashNode *)malloc(sizeof(HashNode)*hashmap->size);
	//初始化
	int j=0;
	for(j=0;j<hashmap->size;j++){
		hashmap->table[j].data.val=INT_MIN;
		hashmap->table[j].next=NULL;
	}
	int i=0;
	//建立HashMap
	while(i<size){
	    //根据数组元素的值计算其在hashMap中的位置
		int pos=abs(nums[i])%hashmap->size;
		//判断是否冲突
		if(hashmap->table[pos].data.val==INT_MIN){
		    //不冲突
		    //把元素在数组中的索引作为key
			hashmap->table[pos].data.key=i;
			//把元素值作为value
			hashmap->table[pos].data.val=nums[i];
		}
		//冲突
		else{
		    //给当前元素分配一个结点，并为结点复制
			HashNode *lnode=(HashNode*)malloc(sizeof(HashNode)),*hashnode;
			lnode->data.key=i;
			lnode->data.val=nums[i];
			lnode->next=NULL;
			//从冲突位置开始，遍历链表
			hashnode=&(hashmap->table[pos]);
			while(hashnode->next!=NULL){
				hashnode=hashnode->next;
			}
			//将当前结点连接到链表尾部
			hashnode->next=lnode;
		}
		//处理下一个元素
		i++; 	
	}
	//处理完成，返回HashMap
	return hashmap;
}
 
       对于hashmap->size=2*size; hashmap中table的长度为什么是给定数组长度的2倍？这涉及到hash表的装填因子，详细可以参考严蔚敏《数据结构》中第九章查找的哈希表章节，这里做简单介绍：
 
 
哈希的装填因子:
 

 
         其中n 为关键字个数，m为表长. 

       装填因子是表示Hsah表中元素的填满的程度。加载因子越大,填满的元素越多,空间利用率提高,但冲突的机会加大了。反之,加载因子越小,填满的元素越少,冲突的机会减小了,但空间浪费多了。冲突的机会越大,则查找的成本越高。反之,查找的成本越小.因而,查找时间就越小.因此,必须在 "冲突的机会"与"空间利用率"之间寻找一种平衡。
 
②Get
 
//f2_GetHashNode
int Get(HashMap hashmap，int value){
    //根据元素值，计算其位置
	int pos=abs(key)%hashmap.size;
	HashNode *pointer=&(hashmap.table[pos]);
	//在当前链表遍历查找该结点
	while(pointer!=NULL){
			if(pointer->data.value==value) 
	            return pointer->data.key;
	        else
	        	pointer=pointer->next;
		} 
	//未找到，返回-1
	return -1;
}
 
③Put
 
//f3_Put，与建立HashMap时插入元素的方法相同
int Put(HashMap hashmap,int key,int value){
     int pos=abs(value)%hashmap.size;
     HashNode *pointer=&(hashmap.table[pos]);
     if(pointer->data.val==INT_MIN) 
        {
         pointer->data.val=value;
         pointer->data.key=key;
        }
	else{
        while(pointer->next!=NULL)
             pointer=pointer->next;
        HashNode *hnode=(HashNode *)malloc(sizeof(HashNode));
        hnode->data.key=key;
        hnode->data.val=value;
        hnode->next=NULL;
        pointer->next=hnode;
   } 
   return 1;
}	
 
④PrintHashMap
 
//f4_PrintHashMap 
void PrintHashMap(HashMap* hashmap){
    printf("%===========PrintHashMap==========\n");
	int i=0;
	HashNode *pointer;
	while(i<hashmap->size){
		pointer=&(hashmap->table[i]);
		while(pointer!=NULL){
            if(pointer->data.val!=INT_MIN)
              printf("%10d",pointer->data.val);
			else 
              printf("        [ ]");
			pointer=pointer->next;
		}
        printf("\n---------------------------------");
		i++;
		printf("\n");
	}
    printf("===============End===============\n");
}
 
⑤DestoryHashMap
 
//f5_DestoryHashMap
void DestoryHashMap(HashMap *hashmap){
    int i=0;
    HashNode *hpointer;
    while(i<hashmap->size){
        hpointer=hashmap->table[i].next;
        while(hpointer!=NULL){
            
            hashmap->table[i].next=hpointer->next;
            //逐个释放结点空间，防止内存溢出
            free(hpointer);
            hpointer=hashmap->table[i].next;
            }
        //换至下一个结点
        i++;
    }
    free(hashmap->table);
    free(hashmap);
    printf("Destory hashmap Success!");
}
 
3.运行示例
 
主函数如下：
 
int main(int argc, char **argv)
{
		int nums[]={34,54,32,32,56,78};
		//创建HashMap
   	    HashMap *hashmap=CreateHashMap(nums,6);
    	PrintHashMap(hashmap);
    	//查找元素
    	printf("%d\n",Get(*hashmap,78));

    	DestoryHashMap(hashmap);
    	getchar();
		return 0;
}
 
运行结果：