7种数据结构

7种数据结构

  • 顺序表
    • sqlite.h
    • seqlite.c
  • 单链表
    • linklist.c
    • linklist.h
  • 双链表
    • doulinklist.c
    • doulinklist.h
  • 链式栈
    • linkstack.c
    • linkstack.h
  • 队列
    • SeqQueue.c
    • SeqQueue.h
  • 树
    • tree.c
  • 哈希表
    • hash.c

顺序表

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;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/36133.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

基于扣子（coze.cn）搭建一个古文化学习助手

基于扣子（coze.cn）搭建一个古文化学习助手

highlight: a11y-dark 扣子Coze 是由字节跳动推出的一个AI聊天机器人和应用程序编辑开发平台&#xff0c;可以理解为字节跳动版的GPTs。 下面进行Coze的登录&#xff0c;初步使用&#xff0c;创建定制化的Bot&#xff08;聊天机器人&#xff09;&#xff0c;插件使用等操作。…
阅读更多...
Modbus TCP到RTU：轻松转换指南！

Modbus TCP到RTU：轻松转换指南！

Modbus TCP 到 RTU&#xff1a;轻松转换指南&#xff01; 在现代工业自动化领域&#xff0c;Modbus TCP和Modbus RTU两种通信协议因其高效、稳定的特点被广泛应用。然而&#xff0c;随着技术的发展和设备升级的需求&#xff0c;经常会遇到需要将这两种协议进行互相转换的场景。…
阅读更多...
云钥科技工业相机定制服务，助力企业实现智能智造

云钥科技工业相机定制服务，助力企业实现智能智造

在工业自动化、智能制造和机器视觉快速发展的今天&#xff0c;工业相机作为核心感知设备&#xff0c;其性能直接决定了检测精度、生产效率和产品质量。然而&#xff0c;标准化工业相机往往难以满足复杂多样的应用场景需求&#xff0c;‌工业相机定制‌逐渐成为企业突破技术瓶颈…
阅读更多...
HAL库STM32常用外设—— CAN通信（一）

HAL库STM32常用外设—— CAN通信（一）

文章目录 一、CAN是什么&#xff1f;1.1 CAN应用场景1.2 CAN通信优势 二、CAN基础知识介绍2.1 CAN总线结构2.2 CAN总线特点2.2.1 CAN总线的数据传输特点2.2.2 位时序和波特率 2.3 CAN位时序和波特率2.3 CAN物理层2.3.1 CAN 物理层特性2.3.2 CAN 收发器芯片介绍 2.4 CAN协议层2.…
阅读更多...
设计模式 二、创建型设计模式

设计模式 二、创建型设计模式

GoF是 “Gang of Four”&#xff08;四人帮&#xff09;的简称&#xff0c;它们是指4位著名的计算机科学家&#xff1a;Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides。他们合作编写了一本非常著名的关于设计模式的书籍《Design Patterns: Elements of Reusable…
阅读更多...
微软远程桌面即将下架？Splashtop：更稳、更快、更安全的 RDP 替代方案

微软远程桌面即将下架？Splashtop：更稳、更快、更安全的 RDP 替代方案

近日&#xff0c;Windows 官方博客宣布&#xff1a;将于2025年5月27日起&#xff0c;在 Windows 10 和 Windows 11 应用商店中下架“Microsoft 远程桌面”应用&#xff0c;建议用户迁移至新的 Windows App。这一变动引发了广大用户对远程访问解决方案的关注。作为全球领先的远程…
阅读更多...
黑马跟学.苍穹外卖.Day08

黑马跟学.苍穹外卖.Day08

黑马跟学.苍穹外卖.Day08 苍穹外卖-day8课程内容1. 工作台1.1 需求分析和设计1.1.1 产品原型1.1.2 接口设计 1.2 代码导入1.2.1 Controller层1.2.2 Service层接口1.2.3 Service层实现类1.2.4 Mapper层 1.3 功能测试1.3.1 接口文档测试1.3.2 前后端联调测试 1.4 代码提交 2. Ap…
阅读更多...
技术路线图ppt模板_流程图ppt图表_PPT架构图

技术路线图ppt模板_流程图ppt图表_PPT架构图

技术路线图ppt模板 / 学术ppt模板 - 院士增选、国家科技奖、杰青、长江学者特聘教授、校企联聘教授、重点研发、优青、青长、青拔.. / 学术ppt案例 WordinPPT / 持续为双一流高校、科研院所、企业等提供PPT制作系统服务。 - 科学技术奖ppt&#xff1a;自然科学奖 | 技术…
阅读更多...
差分专题练习 ——基于罗勇军老师的《蓝桥杯算法入门C/C++》

差分专题练习 ——基于罗勇军老师的《蓝桥杯算法入门C/C++》

一、1.重新排序 - 蓝桥云课 算法代码&#xff1a; #include <bits/stdc.h> using namespace std; const int N 1e5 3;int a[N], d[N], cnt[N];int main() {int n; scanf("%d", &n);for (int i 1; i < n; i) scanf("%d", &a[i]);int m…
阅读更多...
【蓝桥杯】每天一题，理解逻辑（4/90）【Leetcode 二进制求和】

【蓝桥杯】每天一题，理解逻辑（4/90）【Leetcode 二进制求和】

题目描述 我们解析一下题目 我们可以理解到两个主要信息 给的是二进制的字符串返回他们的和 我们知道&#xff0c;十进制的加减法需要进位&#xff0c;例如&#xff1a;9716是因为91之后进了一位&#xff0c;二进制也是如此&#xff0c;只不过十进制是逢10进1&#xff0c;二…
阅读更多...
.NET 9 中 OpenAPI 替代 Swagger 文档生成

.NET 9 中 OpenAPI 替代 Swagger 文档生成

微软已经放弃了对 .NET 9 中 Swagger UI 包 Swashbuckle 的支持。他们声称该项目“不再由社区所有者积极维护”并且“问题尚未得到解决”。 这意味着当您使用 .NET 9 模板创建 Web API 时&#xff0c;您将不再拥有 UI 来测试您的 API 端点。 我们将调查是否可以在 .NET 9 中使用…
阅读更多...
MySQL -- 复合查询

MySQL -- 复合查询

数据库的查询是数据库使用中比较重要的环节&#xff0c;前面的基础查询比较简单&#xff0c;不做介绍&#xff0c;可自行查阅。本文主要介绍复合查询&#xff0c;并结合用例进行讲解。 本文的用例依据Soctt模式的经典测试表&#xff0c;可以自行下载&#xff0c;也可以自己创建…
阅读更多...
蓝桥杯第13届真题2

蓝桥杯第13届真题2

由硬件框图可以知道我们要配置LED 和按键 一.LED 先配置LED的八个引脚为GPIO_OutPut&#xff0c;锁存器PD2也是&#xff0c;然后都设置为起始高电平&#xff0c;生成代码时还要去解决引脚冲突问题 二.按键 按键配置&#xff0c;由原理图按键所对引脚要GPIO_Input 生成代码&a…
阅读更多...
Linux的Shell编程

Linux的Shell编程

一、什么是Shell 1、为什么要学习Shell Linux运维工程师在进行服务器集群管理时&#xff0c;需要编写Shell程序来进行服务器管理。 对于JavaEE和Python程序员来说&#xff0c;工作的需要。Boss会要求你编写一些Shell脚本进行程序或者是服务器的维护&#xff0c;比如编写一个…
阅读更多...
PDFMathTranslate 安装、使用及接入deepseek

PDFMathTranslate 安装、使用及接入deepseek

PDFMathTranslate 安装、使用及接入deepseek 介绍安装及使用接入deepseek注意 介绍 PDFMathTranslate 是非常好用的科学 PDF 文档翻译及双语对照工具&#xff0c;可以将论文按照其原本的排版结构执行多种语言翻译&#xff0c;并且可以接入如&#xff1a;谷歌翻译、deepl、deep…
阅读更多...
如何查看安卓版本号的方法（例如查看是13、12、11、10...）

如何查看安卓版本号的方法（例如查看是13、12、11、10...）

开发过程中需要了解到安卓版本号是多少&#xff0c;那么以下有三种方法可以知晓安卓手机的Android版本号。 方法1&#xff1a;手机设置直接查看 1.打开【设置】 --> 滑动到手机最底部 --> 点击【关于手机】或 【系统】--> 选择【Android版本】 2.直接查看版本号&am…
阅读更多...
Python----计算机视觉处理（Opencv：形态学变换）

Python----计算机视觉处理（Opencv：形态学变换）

一、形态学变化 形态学变换&#xff08;Morphological Transformations&#xff09;是一种基于形状的图像处理技术&#xff0c;主要处理的对象为二值化图像。 形态学变换有两个输入和一个输出&#xff1a;输入为原始图像和核&#xff08;即结构化元素&#xff09;&#xff0c;输…
阅读更多...
【新能源汽车“心脏”赋能：三电系统研发、测试与应用匹配的恒压恒流源技术秘籍】

【新能源汽车“心脏”赋能：三电系统研发、测试与应用匹配的恒压恒流源技术秘籍】

新能源汽车“心脏”赋能&#xff1a;三电系统研发、测试与应用匹配的恒压恒流源技术秘籍 在新能源汽车蓬勃发展的浪潮中&#xff0c;三电系统&#xff08;电池、电机、电控&#xff09;无疑是其核心驱动力。而恒压源与恒流源&#xff0c;作为电源管理的关键要素&#xff0c;在…
阅读更多...
Android的消息机制

Android的消息机制

Android的消息机制-从入门到精通 前言Android消息机制概述Android 的消息机制分析ThreadLocal 的工作原理消息队列的工作原理Looper的工作原理Handler的工作原理 主线程的消息循环 前言 作为开发者&#xff0c;提及Android的消息机制&#xff0c;必然绕不开Handler&#xff0c;…
阅读更多...
es-将知识库中的数据转换为向量存储到es并进行相似性检索

es-将知识库中的数据转换为向量存储到es并进行相似性检索

目录 为什么要将数据转为向量存入es? 数据准备 创建索引库 向量存储 验证 为什么要将数据转为向量存入es? 我之前把数据作为文档存入 ES&#xff0c;主要用于全文检索&#xff08;BM25 算法&#xff09;&#xff0c;但是它不适合语义匹配&#xff0c;比如如果用户输入的…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023