7种数据结构

顺序表

sqlite.h

#ifndef __SEQLIST_H__
#define __SEQLIST_H__  typedef struct	person {char name[32];char sex;int age;int score;
}DATATYPE;
// typedef int DATAYPE;
typedef struct list {DATATYPE *head;int tlen;int clen;
}SeqList;SeqList *CreateSeqList(int len);
int DestroySeqList(SeqList *list);
int ShowSeqList(SeqList *list); 
int InsertTailSeqList(SeqList *list, DATATYPE* data);
int IsFullSeqList(SeqList *list);
int IsEmptySeqList(SeqList *list);
int InsertPosSeqList(SeqList *list, DATATYPE* data, int pos);
int FindSeqList(SeqList *list, char *name);
int ModifySeqList(SeqList *list, char *old, DATATYPE *newdata);
int DeleteSeqList(SeqList *list, char *name);
int ClearSeqList(SeqList *list);
int GetSizeSeqList(SeqList*list);
DATATYPE* GetDataType(SeqList*list,int pos);
#endif

seqlite.c

#include "seqlist.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
SeqList *CreateSeqList(int len)
{SeqList* sl = (SeqList*)malloc(sizeof(SeqList));if(NULL == sl){printf("malloc 1 error\n");return NULL;}sl->head = (DATATYPE*)malloc(sizeof(DATATYPE)*len);if(NULL == sl->head){printf("malloc 1 error\n");return NULL;}sl->tlen = len;sl->clen = 0;return sl;}
int InsertTailSeqList(SeqList *list, DATATYPE* data)
{   if(IsFullSeqList(list)){return 1;}//strcpymemcpy(&list->head[list->clen],data,sizeof(DATATYPE));list->clen++;return 0;
}
int IsFullSeqList(SeqList* list)
{return list->clen  == list->tlen ;
}
int GetSizeSeqList(SeqList*list)
{return list->clen ;
}
int ShowSeqList(SeqList *list)
{int i = 0 ;int len = GetSizeSeqList(list);for(i = 0;i<len;i++){printf("%s %c %d %d\n",list->head[i].name,list->head [i].sex,list->head[i].age,list->head[i].score );}
}int IsEmptySeqList(SeqList *list)
{return 0 ==list->clen ;
}int InsertPosSeqList(SeqList *list, DATATYPE *data, int pos)
{if(pos<0 ||pos>list->clen){return 1;}if(IsFullSeqList(list)){return 1;}for(int i= list->clen ;i>pos;i--){list->head[i]= list->head[i-1];}memcpy(&list->head[pos],data,sizeof(DATATYPE));list->clen ++;return 0;
}
int FindSeqList(SeqList *list, char *name)
{int len = GetSizeSeqList(list);int i = 0 ;for(i=0;i<len;i++){if(0== strcmp(list->head [i].name,name)){return i;}}return -1;
}
DATATYPE* GetDataType(SeqList*list,int pos)
{return &list->head[pos]; 
}
int ClearSeqList(SeqList *list)
{list->clen = 0; return 0;   
}int DestroySeqList(SeqList *list)
{free(list->head);free(list);return 0;
}int ModifySeqList(SeqList *list, char *old, DATATYPE *newdata)
{int i = FindSeqList(list,old);if(-1 == i){return 1;}//list->head[i] = *newdata;memcpy(&list->head[i],newdata,sizeof(DATATYPE));return 0;}int DeleteSeqList(SeqList *list, char *name)
{int pos = FindSeqList(list, name);if(-1 == pos){return 1;}int len  =GetSizeSeqList(list);int i = 0 ;for(i=pos;i<len;i++)    {memcpy(&list->head[i],&list->head[i+1],sizeof(DATATYPE));}list->clen--;return 0;
}

单链表

linklist.c

#include "linklist.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>LinkList *CreateLinkList() {LinkList *ll = (LinkList *)malloc(sizeof(LinkList));if (NULL == ll) {printf("CreateLinkList malloc\n");return NULL;}ll->head = NULL;ll->clen = 0;return ll;
}int InsertHeadLinkList(LinkList *list, DATATYPE *data) {LinkNode *newnode = (LinkNode *)malloc(sizeof(LinkNode));if (NULL == newnode) {printf("InsertHeadLinkList malloc\n");return 1;}memcpy(&newnode->data, data, sizeof(DATATYPE));newnode->next = NULL;if (IfEmptyLinkList(list)) // empty{list->head = newnode;} else {newnode->next = list->head;list->head = newnode;}list->clen++;return 0;
}int IfEmptyLinkList(LinkList *list) { return 0 == list->clen; }int ShowLinkList(LinkList *list) {LinkNode *tmp = list->head;while (tmp) {printf("%s %d\n", tmp->data.name, tmp->data.age);tmp = tmp->next; // i++}return 0;
}// LinkNode *FindLinkList(LinkList *list, char *name)
LinkNode *FindLinkList(LinkList *list, PFUN fun, void *arg) {LinkNode *tmp = list->head;while (tmp) {// if(0==strcmp(tmp->data.name,name))if (fun(&tmp->data, arg)) {return tmp;}tmp = tmp->next; // i++}return NULL;
}int InsertTailLinkList(LinkList *list, DATATYPE *data) {LinkNode *newnode = (LinkNode *)malloc(sizeof(LinkNode));if (NULL == newnode) {printf("InsertTailLinkList malloc\n");return 1;}memcpy(&newnode->data, data, sizeof(DATATYPE));newnode->next = NULL;if (IfEmptyLinkList(list)) {list->head = newnode;} else {LinkNode *tmp = list->head;while (tmp->next) {tmp = tmp->next;}tmp->next = newnode;}list->clen++;return 0;
}int InsertPosLinkList(LinkList *list, DATATYPE *data, int pos) {int len = GetSizeLinkList(list);if (pos < 0 || pos > len) {return 1;}if (0 == pos) {return InsertHeadLinkList(list, data);} else if (pos == len) {return InsertTailLinkList(list, data);} else //中间位置{LinkNode *newnode = (LinkNode *)malloc(sizeof(LinkNode));if (NULL == newnode) {printf("InsertTailLinkList malloc\n");return 1;}memcpy(&newnode->data, data, sizeof(DATATYPE));newnode->next = NULL;LinkNode *tmp = list->head;int i = 0;for (i = 0; i < pos - 1; i++) {tmp = tmp->next;}newnode->next = tmp->next;tmp->next = newnode;}list->clen++;return 0;
}int GetSizeLinkList(LinkList *list) { return list->clen; }int DeleteHeadLinklist(LinkList *list) {if (IfEmptyLinkList(list)) {return 1;}LinkNode *tmp = list->head;list->head = tmp->next;free(tmp);list->clen--;return 0;
}int DeleteTailLinkList(LinkList *list) {if (IfEmptyLinkList(list)) {return 1;}int len = GetSizeLinkList(list);if (1 == len) {free(list->head);list->head = NULL;} else {LinkNode *tmp = list->head;LinkNode *tmp1 = list->head;while (tmp->next) {tmp1 = tmp; // tmp1 比tmp晚一步tmp = tmp->next;}free(tmp);tmp1->next = NULL;}list->clen--;return 0;
}int DeletePosLinkList(LinkList *list, int pos) {int len = GetSizeLinkList(list);if (IfEmptyLinkList(list)) {return 1;}if (0 == pos) {DeleteHeadLinklist(list);} else if (len - 1 == pos) // len 4{DeleteTailLinkList(list);} else //中间{LinkNode *tmp = list->head;LinkNode *tmp1 = list->head;for (int i = 0; i < pos; i++) {tmp1 = tmp;tmp = tmp->next;}tmp1->next = tmp->next;free(tmp);list->clen--;}return 0;
}int ModifyLinkList(LinkList *list, PFUN fun, void *arg, DATATYPE *newdata) {LinkNode *tmp = FindLinkList(list, fun, arg);if (NULL == tmp) {return 1;}memcpy(&tmp->data, newdata, sizeof(DATATYPE));return 1;
}int DestroyLinkList(LinkList *list) {int len = GetSizeLinkList(list);for (int i = 0; i < len; i++) {DeleteHeadLinklist(list);}free(list);return 0;
}LinkNode *FindMidLinkList(LinkList *list) {if (IfEmptyLinkList(list)) {return NULL;}LinkNode *pfast = list->head;LinkNode *pslow = list->head;while (pfast) {pfast = pfast->next; // pfast = pfast->next->next;if (pfast) {pfast = pfast->next;pslow = pslow->next;} else {break;}}return pslow;
}LinkNode *FindRevKLinkList(LinkList *list, int k) {if (IfEmptyLinkList(list)) {return NULL;}LinkNode *pfast = list->head;LinkNode *pslow = list->head;int i = 0;for (i = 0; i < k; i++) {pfast = pfast->next;if (NULL == pfast) {return pslow;}}while (pfast) {pfast = pfast->next;// if (NULL==pfast)// {//   break;// }pslow = pslow->next;}return pslow;
}int RevertLinkList(LinkList *list) {LinkNode *prev = NULL;LinkNode *tmp = list->head;LinkNode *next = list->head->next;while (1) {tmp->next = prev;prev = tmp;tmp = next;if (NULL == tmp) {break;}next = next->next;}list->head = prev;return 0;
}int InsertSortLinkList(LinkList *list) 
{LinkNode* phead = list->head;LinkNode* pinsert = phead->next;LinkNode* pnext = pinsert->next;phead->next = NULL; while(1){phead = list->head;while(phead->next != NULL && pinsert->data.age > phead->data.age &&pinsert->data.age > phead->next->data.age) {phead = phead->next;}if(pinsert->data .age <phead -> data.age) // head insert{pinsert->next = list->head;list->head = pinsert;}else {pinsert->next = phead->next;phead->next = pinsert;}pinsert = pnext;if(NULL == pinsert) { break; }pnext = pnext->next;}return 0;
}

linklist.h

#ifndef __LINKLIST_H__
#define __LINKLIST_H__typedef struct person 
{char name[32];char sex;int age;int score;
}DATATYPE;typedef struct node 
{DATATYPE data;struct node *next;
}LinkNode;
//typedef int u32;
typedef struct list{LinkNode *head;int clen;
}LinkList;
typedef int (*PFUN)(DATATYPE*,void* arg);
LinkList *CreateLinkList();
int InsertHeadLinkList(LinkList *list, DATATYPE *data);
int ShowLinkList(LinkList *list);
//LinkNode *FindLinkList(LinkList *list, char *name);
LinkNode *FindLinkList(LinkList *list, PFUN fun, void * arg);
int DeleteHeadLinklist(LinkList *list);
int DeleteTailLinkList(LinkList *list);
int DeletePosLinkList(LinkList *list, int pos);
int ModifyLinkList(LinkList *list,  PFUN fun, void * arg,DATATYPE*newdata);
int DestroyLinkList(LinkList *list);
int InsertTailLinkList(LinkList *list, DATATYPE *data);
int IfEmptyLinkList(LinkList *list);
int InsertPosLinkList(LinkList *list, DATATYPE *data,int Pos);
int GetSizeLinkList(LinkList *list);LinkNode* FindMidLinkList(LinkList *list);
LinkNode* FindRevKLinkList(LinkList *list,int k);
int RevertLinkList(LinkList *list);
int InsertSortLinkList(LinkList *list) ;
#endif  // /__LINKLIST_H__/ !

双链表

doulinklist.c

#include "doulinklist.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>DouLinkList *CreateDouLinkList() {DouLinkList *dl = (DouLinkList *)malloc(sizeof(DouLinkList));if (NULL == dl) {printf("CreateDouLinkList malloc\n");return NULL;}dl->head = NULL;dl->clen = 0;return dl;
}
int IsEmptyDouLinkList(DouLinkList *list) { return 0 == list->clen; }
int GetSizeDouLinkList(DouLinkList *list) { return list->clen; }int InsertHeadDouLinkList(DouLinkList *list, DATATYPE *data) {DouLinkNode *newnode = (DouLinkNode *)malloc(sizeof(DouLinkNode));if (NULL == newnode) {printf("InsertHeadDouLinkList malloc\n");return 1;}memcpy(&newnode->data, data, sizeof(DATATYPE));newnode->next = NULL;newnode->prev = NULL;if (IsEmptyDouLinkList(list)) {list->head = newnode;} else {newnode->next = list->head;list->head->prev = newnode;list->head = newnode;}list->clen++;return 0;
}int ShowDouLinkList(DouLinkList *list, SHOW_DIR dir) {DouLinkNode *tmp = list->head;if (DIR_FORWARD == dir) {while (tmp) {printf("%s %d\n", tmp->data.name, tmp->data.score);tmp = tmp->next;}} else {while (tmp->next) {tmp = tmp->next;}while (tmp) {printf("%s %d\n", tmp->data.name, tmp->data.score);tmp = tmp->prev;}}return 0;
}int InsertTailDouLinkList(DouLinkList *list, DATATYPE *data) {if (IsEmptyDouLinkList(list)) {return InsertHeadDouLinkList(list, data);}DouLinkNode *tmp = list->head;while (tmp->next) {tmp = tmp->next;}DouLinkNode *newnode = (DouLinkNode *)malloc(sizeof(DouLinkNode));if (NULL == newnode) {printf("InsertTailDouLinkList malloc\n");return 1;}memcpy(&newnode->data, data, sizeof(DATATYPE));newnode->next = NULL;newnode->prev = NULL;newnode->prev = tmp;tmp->next = newnode;list->clen++;return 0;
}
/*func:param:retval:
*/
int InsertPosDouLinkList(DouLinkList *list, DATATYPE *data, int pos) {int len = GetSizeDouLinkList(list);if (pos < 0 || pos > len) {return 1;}if (0 == pos) {return InsertHeadDouLinkList(list, data);} else if (len == pos) {return InsertTailDouLinkList(list, data);} else {DouLinkNode *tmp = list->head;for (int i = 0; i < pos; i++) {tmp = tmp->next;}DouLinkNode *newnode = malloc(sizeof(DATATYPE));if (NULL == newnode) {printf("InsertPosDouLinkList malloc\n");return 1;}memcpy(&newnode->data, data, sizeof(DATATYPE));newnode->next = NULL;newnode->prev = NULL;newnode->next = tmp;newnode->prev = tmp->prev;tmp->prev = newnode;newnode->prev->next = newnode;}list->clen++;return 0;
}int DeleteHeadDouLinkList(DouLinkList *list) {if (IsEmptyDouLinkList(list)) {return 1;}DouLinkNode *tmp = list->head;list->head = list->head->next;if (list->head != NULL) {list->head->prev = NULL;}free(tmp);list->clen--;return 0;
}
int DeleteTailDouLinkList(DouLinkList *list) {if (IsEmptyDouLinkList(list)) {return 1;}DouLinkNode *tmp = list->head;while (tmp->next) {tmp = tmp->next;}if (tmp->prev != NULL) {tmp->prev->next = NULL;} else {list->head = NULL;}free(tmp);list->clen--;return 0;
}int DeletePosDouLinkList(DouLinkList *list, int pos) {int len = GetSizeDouLinkList(list);if (pos < 0 || pos > len - 1) {return 1;}if (0 == pos) {return DeleteHeadDouLinkList(list);} else if (pos == len - 1) {return DeleteTailDouLinkList(list);} else // mid del{DouLinkNode *tmp = list->head;for (int i = 0; i < pos; i++) {tmp = tmp->next;}tmp->next->prev = tmp->prev;tmp->prev->next = tmp->next;free(tmp);list->clen--;}return 0;
}DouLinkNode *FindDouLinkList(DouLinkList *list, char *name)
{if(IsEmptyDouLinkList(list)){return NULL;}DouLinkNode* tmp = list->head;while(tmp){if(0 == strcmp(tmp->data.name,name)){return tmp;}tmp=tmp->next;}return NULL;
}int ModifyDouLinkList(DouLinkList *list, char *name, DATATYPE* data)
{DouLinkNode* tmp = FindDouLinkList(list, name);if(NULL == tmp){return 1;}memcpy(&tmp->data,data,sizeof(DATATYPE));return 0;
}int DestroyDouLinkList(DouLinkList *list)
{int len = GetSizeDouLinkList(list);for(int i = 0 ;i<len;i++){DeleteHeadDouLinkList(list);}free(list);return 0;
}

doulinklist.h

#ifndef __DOULINKLIST_H__
#define __DOULINKLIST_H__
typedef struct person {char name[32];char sex;int age;int score;
}DATATYPE;typedef struct dounode {DATATYPE data;struct dounode *next,*prev;
}DouLinkNode;typedef struct list {DouLinkNode *head;int clen;
}DouLinkList;
typedef enum{DIR_FORWARD,DIR_BACKWARD} SHOW_DIR;
DouLinkList *CreateDouLinkList();
int InsertHeadDouLinkList(DouLinkList *list, DATATYPE* data);
int InsertTailDouLinkList(DouLinkList *list, DATATYPE* data);
int InsertPosDouLinkList(DouLinkList *list, DATATYPE* data,int pos);
int ShowDouLinkList(DouLinkList *list,SHOW_DIR dir);
DouLinkNode *FindDouLinkList(DouLinkList *list, char *name);
int DeleteHeadDouLinkList(DouLinkList *list) ;
int DeleteTailDouLinkList(DouLinkList *list);
int DeletePosDouLinkList(DouLinkList *list,int pos);
int ModifyDouLinkList(DouLinkList *list, char *name, DATATYPE* data);
int DestroyDouLinkList(DouLinkList *list);
int IsEmptyDouLinkList(DouLinkList *list);
int GetSizeDouLinkList(DouLinkList *list);#endif

链式栈

linkstack.c

#include "linkstack.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>LinkStack* CreateLinkStack()
{LinkStack* ls = (LinkStack*)malloc(sizeof(LinkStack));if(NULL == ls){printf("CreateLinkStack malloc");return NULL;}ls->top = NULL;ls->clen= 0 ;return ls;}int PushLinkStack(LinkStack*ls,DATATYPE*data)
{LinkStackNode* newnode = (LinkStackNode*)malloc(sizeof(LinkStackNode));if(NULL == newnode){printf("PushLinkStack malloc");return 1;}memcpy(&newnode->data,data,sizeof(DATATYPE));newnode->next = NULL;newnode->next = ls->top;ls->top = newnode;ls->clen++;return 0;}int IsEmptyLinkStack(LinkStack*ls)
{return 0 == ls->clen;
}
int PopLinkStack(LinkStack*ls)
{if(IsEmptyLinkStack(ls)){return 1;}LinkStackNode* tmp = ls->top;ls->top = ls->top->next;free(tmp);ls->clen--;return 0;
}DATATYPE*GetTopLinkStack(LinkStack*ls)
{if(IsEmptyLinkStack(ls)){return NULL;}return &ls->top->data;
}
int GetSizeLinkStack(LinkStack*ls)
{return ls->clen;
}

linkstack.h

#ifndef __LINKSTACK_H__
#define __LINKSTACK_H__typedef struct person 
{char name[32];char sex;int age;int score;
}DATATYPE;typedef struct stacknode 
{DATATYPE data;struct stacknode *next;
}LinkStackNode;typedef struct list{LinkStackNode *top;// 和单向链表中的head,一个意思int clen;
}LinkStack;
LinkStack* CreateLinkStack();
int DestroyLinkStack(LinkStack*ls);
int PushLinkStack(LinkStack*ls,DATATYPE*data);
int PopLinkStack(LinkStack*ls);
int IsEmptyLinkStack(LinkStack*ls);
DATATYPE*GetTopLinkStack(LinkStack*ls);
int GetSizeLinkStack(LinkStack*ls);
#endif  // /__LINKLIST_H__/ !

队列

SeqQueue.c

#include "SeqQueue.h"
SeqQueue *CreateSeqQueue(int len)
{SeqQueue* sq = (SeqQueue*)malloc(sizeof(SeqQueue));if(NULL == sq){printf("CreateSeqQueue malloc\n");return NULL;}sq->ptr  = (DATATYPE*)malloc(sizeof(DATATYPE)*len);if(NULL == sq->ptr ){printf("CreateSeqQueue malloc2\n");return NULL;}sq->tlen = len;sq->head  = 0 ;sq->tail = 0;return sq;
}int IsEmptySeqQueue(SeqQueue *queue)
{return queue->head == queue->tail ;
}
int IsFullSeqQueue(SeqQueue *queue)
{return (queue->tail +1) % queue->tlen  == queue->head;
}
int QuitSeqQueue(SeqQueue *queue)
{if(IsEmptySeqQueue(queue)){return 1;}queue->head = (queue->head+1)%queue->tlen;return 0;
}
int EnterSeqQueue(SeqQueue *queue, DATATYPE *data)
{if(IsFullSeqQueue(queue)){return 1;}memcpy(&queue->ptr[queue->tail],data,sizeof(DATATYPE));queue->tail = (queue->tail +1) % queue->tlen ; return 0;
}
DATATYPE* GetHeadSeqQueue(SeqQueue* que)
{if(IsEmptySeqQueue(que)){return NULL;}return &que->ptr[que->head];
}

SeqQueue.h

#ifndef __SEQQUEUE_H__
#define __SEQQUEUE_H__ #include <stdio.h>
#include <stdlib.h>
#include <string.h>typedef int DATATYPE;
typedef struct queue {DATATYPE *ptr;int tlen;int head;int tail;
}SeqQueue;SeqQueue *CreateSeqQueue(int len);
int DestroySeqQueue(SeqQueue *queue);
int QuitSeqQueue(SeqQueue *queue);
int EnterSeqQueue(SeqQueue *queue, DATATYPE *data);
int IsEmptySeqQueue(SeqQueue *queue);
int IsFullSeqQueue(SeqQueue *queue);
DATATYPE* GetHeadSeqQueue(SeqQueue* que);#endif

树

tree.c

#include <stdio.h>
#include <stdlib.h>
typedef char DATATYPE;
typedef struct BiTNode  /* 结点结构 */
{DATATYPE data;		/* 结点数据 */struct BiTNode *lchild,*rchild; /* 左右孩子指针 */
}BiTNode;
char data[]="Ab#df###ceg##h###";
int ind =  0;
void CreateBiTree(BiTNode** root)
{char c = data[ind++];if('#'==c){*root = NULL;return ;}*root = (BiTNode*)malloc(sizeof(BiTNode));if(NULL == *root){perror("malloc");return ;}(*root)->data = c;CreateBiTree(&((*root)->lchild));CreateBiTree(&((*root)->rchild));return ;}
void DestroyBiTree(BiTNode * root)
{if(NULL ==root){return ;}DestroyBiTree(root->lchild);DestroyBiTree(root->rchild);free(root);}void PreOrderTraverse(BiTNode * root)
{if(NULL == root){return ;}printf("%c",root->data);PreOrderTraverse(root->lchild);PreOrderTraverse(root->rchild);
}
void InOrderTraverse(BiTNode * root)
{if(NULL == root){return ;}InOrderTraverse(root->lchild);printf("%c",root->data);InOrderTraverse(root->rchild);}
void PostOrderTraverse(BiTNode * root)
{if(NULL == root){return ;}PostOrderTraverse(root->lchild);PostOrderTraverse(root->rchild);printf("%c",root->data);}int	main(int argc, char **argv)
{BiTNode* root=NULL;CreateBiTree(&root);PreOrderTraverse(root);printf("\n");InOrderTraverse(root);printf("\n");PostOrderTraverse(root);printf("\n");DestroyBiTree(root);root = NULL;//system("pause");return 0;
}

哈希表

hash.c

#include <stdio.h>
#include <stdlib.h>typedef int DATATYPE;typedef struct 
{DATATYPE* head;int tlen;
}HS_TABLE;HS_TABLE* CreateHsTable(int len)
{HS_TABLE* hs = malloc(sizeof(HS_TABLE));if(NULL == hs){perror("CreateHsTable malloc1");return NULL;}hs->head = malloc(sizeof(DATATYPE)*len);if(NULL == hs->head){perror("CreateHsTable malloc2");return NULL;}hs->tlen = len;int i = 0 ;for(i=0;i<len;i++){hs->head[i] = -1;}return hs;
}
int HS_fun(HS_TABLE* hs,DATATYPE* data)
{return *data %hs->tlen;
}
int HS_insert(HS_TABLE* hs,DATATYPE* data)
{int ind = HS_fun(hs,data);while(hs->head[ind]!= -1){printf("values:%d  conllision pos:%d\n",*data,ind);ind = (ind+1) %hs->tlen;}hs->head[ind] = *data;return 0;
}
int HS_search(HS_TABLE* hs,DATATYPE* data)
{int ind = HS_fun(hs,data);int oldind = ind;while(hs->head[ind]!=*data ){ind = (ind+1) %hs->tlen;if(oldind == ind){return -1;}}return ind;
}
int	main(int argc, char **argv)
{HS_TABLE* hs = CreateHsTable(12);int data[12]={12,67,56,16,25,37,22,29,15,47,48,34};int i = 0;for(i=0;i<12;i++){HS_insert(hs, &data[i]);}int want_int = 44;int ind = HS_search(hs, &want_int);if(-1 == ind){printf("cant find %d\n",want_int);}else {printf("find it ,pos %d\n",ind);}return 0;
}