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.mzph.cn/news/898308.shtml

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

相关文章

Linux 查看及测试网络命令

Linux 查看及测试网络命令

使用 ifconfig 命令查看网络接口地址 查看指定的网络接口信息 执行 ifconfig ens33 命令可以只查看网卡 ens33 的配置信息
阅读更多...
ABAP语言的动态编程（4) - 综合案例：管理费用明细表

ABAP语言的动态编程（4) - 综合案例：管理费用明细表

本篇来实现一个综合案例&#xff1a;管理费用明细表。报表在实际项目中&#xff0c;也有一定的参考意义&#xff0c;一方面展示类似的报表&#xff0c;比如管理费用、研发费用等费用的明细&#xff0c;使用业务比较习惯的展示格式&#xff1b;另一方面正好综合运用前面学习的动…
阅读更多...
【Redis】Redis的数据删除(过期)策略，数据淘汰策略。

【Redis】Redis的数据删除(过期)策略，数据淘汰策略。

如果问到&#xff1a;假如Redis的key过期之后&#xff0c;会立即删除吗&#xff1f; 其实就是想问数据删除(过期)策略。 如果面试官问到&#xff1a;如果缓存过多&#xff0c;内存是有限的&#xff0c;内存被占满了怎么办&#xff1f; 其实就是问&#xff1a;数据的淘汰策略。…
阅读更多...
Linux配置yum仓库，服务控制,防火墙

Linux配置yum仓库，服务控制,防火墙

一、yum仓库 1.在安装软件时&#xff0c;首先第一步就是要考虑软件的版本的问题&#xff01; 2.软件的安装&#xff1a;最安全可靠的方法就是去软件对应的官网上查看安装手册&#xff08;包括的软件的下载&#xff09; 红帽系软件安装的常见的3种方式 &#xff08;1&#x…
阅读更多...
[从零开始学习JAVA] Stream流

[从零开始学习JAVA] Stream流

前言&#xff1a; 本文我们将学习Stream流&#xff0c;他就像流水线一样&#xff0c;可以对我们要处理的对象进行逐步处理&#xff0c;最终达到我们想要的效果&#xff0c;是JAVA中的一大好帮手&#xff0c;值得我们了解和掌握。&#xff08;通常和lambda 匿名内部类 方法引用相…
阅读更多...
设计模式(创建型)-抽象工厂模式

设计模式(创建型)-抽象工厂模式

摘要 在软件开发的复杂世界中，设计模式作为解决常见问题的最佳实践方案，一直扮演着至关重要的角色。抽象工厂模式，作为一种强大的创建型设计模式，在处理创建一系列或相关依赖对象的场景时，展现出了独特的优势和灵活性。它通过提供一个创建对象的接口，让开发者能够在不指定…
阅读更多...
【JavaEE】-- SpringBoot快速上手

【JavaEE】-- SpringBoot快速上手

文章目录 1. Maven1.1 什么是Maven1.2 为什么要学Maven1.3 创建一个Maven项目1.4 Maven核心功能1.4.1 项目创建1.4.2 依赖管理1.4.3 Maven Help插件 1.5 Maven仓库1.5.1 本地仓库1.5.2 中央仓库1.5.3 私有服务器&#xff08;私服&#xff09; 1.6 Maven设置国内源1.6.1 配置当前…
阅读更多...
TCP/IP 协议精讲-精华总结版本

TCP/IP 协议精讲-精华总结版本

序言 本文旨在介绍一下TCP/IP涉及得所有基础知识&#xff0c;为大家从宏观上俯瞰TCP/IP提供一个基石&#xff0c;文档属于《TCP/IP图解&#xff08;第五版&#xff09;》的精简版本。 专业术语 缩写 全称 WAN Wide area network广域网 LAN Local area network局域网 TC…
阅读更多...
Leetcode 160 Intersection of Two Linked Lists

Leetcode 160 Intersection of Two Linked Lists

题意 给定两个链表&#xff0c;找这两个链表第一个公共节点&#xff0c;如果没有返回nullptr 题目链接 https://leetcode.com/problems/intersection-of-two-linked-lists/description/ 题解 两个指针分别从两个链表&#xff08;记录为表A&#xff0c;表B&#xff09;的表…
阅读更多...
C语言——结构体、联合、枚举

C语言——结构体、联合、枚举

C语言中自定义类型 结构体结构体变量的创建和初始化结构体传参结构体内存对齐(如何存储) 联合体(共用体)联合体创建和初始化联合体大小(如何存储) 枚举类型枚举类型创建枚举类型初始化枚举的优点(相较于define) 前言 C语言中有内置类型和自定义类型&#xff0c;内置类型就像int…
阅读更多...
利用pprof对golang进行性能分析

利用pprof对golang进行性能分析

利用pprof进行性能分析 pprof性能分析的5个方面 一、性能分析的五个核心维度 CPU分析 - 剖析程序的CPU使用情况&#xff0c;定位高耗时函数 内存分析 - 追踪内存分配与泄露&#xff0c;优化内存使用模式 IO分析 - 监控文件/网络IO操作&#xff0c;发现瓶颈资源 Goroutine分…
阅读更多...
IntelliJ IDEA 调试技巧指南

IntelliJ IDEA 调试技巧指南

在日常开发中&#xff0c;调试是不可或缺的一部分。掌握调试工具的使用可以让我们更高效地定位和解决问题。本文将介绍一些在 IntelliJ IDEA 中常用的调试技巧&#xff0c;希望能帮助你在开发过程中更顺畅地解决问题。 1. 方法断点&#xff1a;快速定位实现类 方法断点可以帮…
阅读更多...
gitlab 提交pr

gitlab 提交pr

在 GitLab 中&#xff0c;提交合并请求&#xff08;Merge Request, MR&#xff09;的大致流程如下&#xff1a; 1. 创建新分支 如果你还没有创建新的功能分支&#xff0c;可以使用以下命令创建并切换到新分支&#xff1a; git checkout -b feature-branch说明&#xff1a;f…
阅读更多...
halcon几何测量(二)计算距离和角度的函数

halcon几何测量(二)计算距离和角度的函数

目录 一、计算两条线之间的夹角二、计算一条直线和水平轴之间的夹角三、计算两个轮廓之间的最小距离四、计算两个轮廓之间的最小距离和对应的点五、计算直线和区域之间的最小和最大距离六、计算点到轮廓线之间的距离七、计算点到直线的距离八、计算点到点的距离九、计算点和区域…
阅读更多...
【Linux操作系统——学习笔记二】Linux简单导航命令操作

【Linux操作系统——学习笔记二】Linux简单导航命令操作

一、前言 学习Linux&#xff0c;本质上是学习在命令行下熟练使用Linux的各类命令。 命令行&#xff1a;是一种通过输入命令和参数与计算机系统进行交互的方式&#xff0c;可以使用各种字符化命令对系统发出操作指令&#xff0c;打开Linux终端&#xff0c;进入命令行界面。 …
阅读更多...
新安装的cursor安装不了插件

新安装的cursor安装不了插件

我安装的cursor版本0.47.5 直接说解决办法 找到安装路径cursor\resources\app下的product.json 修改https://marketplace.cursorapi.com为https://marketplace.visualstudio.com
阅读更多...
算法基础篇（蓝桥杯常考点）

算法基础篇（蓝桥杯常考点）

算法基础篇 前言 算法内容还有搜索&#xff0c;数据结构&#xff08;进阶&#xff09;&#xff0c;动态规划和图论 数学那个的话大家也知道比较难&#xff0c;放在最后讲 这期包含的内容可以看目录 模拟那个算法的话就是题说什么写什么&#xff0c;就不再分入目录中了 注意事…
阅读更多...
《解锁华为黑科技：MindSpore+鸿蒙深度集成奥秘》

《解锁华为黑科技：MindSpore+鸿蒙深度集成奥秘》

在数字化浪潮汹涌澎湃的当下&#xff0c;人工智能与操作系统的融合已成为推动科技发展的核心驱动力。华为作为科技领域的先锋&#xff0c;其AI开发框架MindSpore与鸿蒙系统的深度集成备受瞩目&#xff0c;开启了智能生态的新篇章。 华为MindSpore&#xff1a;AI框架的创新先锋…
阅读更多...
双3060、Ubuntu22.04、cuda12.8安装deepseek 32b-Q8

双3060、Ubuntu22.04、cuda12.8安装deepseek 32b-Q8

以下是针对双RTX 3060显卡&#xff08;12GB显存&#xff09;在Ubuntu 22.04系统部署DeepSeek-R1-32b-qwen-distill-q8模型的完整流程&#xff0c;结合最新技术规范与魔塔社区资源&#xff1a; 一、驱动与CUDA环境配置 1. 禁用开源驱动 bash sudo tee /etc/modprobe.d/blackli…
阅读更多...
K8S学习之基础三十四：K8S之监控Prometheus部署pod版

K8S学习之基础三十四：K8S之监控Prometheus部署pod版

使用 Kubernetes Pod 的方式部署 Prometheus 是一种常见的方法&#xff0c;尤其是在容器化和微服务架构中。以下是详细的步骤&#xff1a; 1. 创建命名空间&#xff08;可选&#xff09; 为了方便管理&#xff0c;可以为 Prometheus 创建一个单独的命名空间。 yaml 复制 a…
阅读更多...
最新文章

Copyright @ 2022~2023