做海淘的网站做海淘的网站有哪些/北京网站优化公司哪家好

做海淘的网站做海淘的网站有哪些,北京网站优化公司哪家好,长沙新媒体公司排名,全新微信号2元一个自动下单7种数据结构 顺序表sqlite.hseqlite.c 单链表linklist.clinklist.h 双链表doulinklist.cdoulinklist.h 链式栈linkstack.clinkstack.h 队列SeqQueue.cSeqQueue.h 树tree.c 哈希表hash.c 顺序表 sqlite.h #ifndef __SEQLIST_H__ #define __SEQLIST_H__ typedef struct person…

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…
阅读更多...
设计模式(创建型)-抽象工厂模式

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

摘要 在软件开发的复杂世界中，设计模式作为解决常见问题的最佳实践方案，一直扮演着至关重要的角色。抽象工厂模式，作为一种强大的创建型设计模式，在处理创建一系列或相关依赖对象的场景时，展现出了独特的优势和灵活性。它通过提供一个创建对象的接口，让开发者能够在不指定…
阅读更多...
【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…
阅读更多...
C语言——结构体、联合、枚举

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

C语言中自定义类型 结构体结构体变量的创建和初始化结构体传参结构体内存对齐(如何存储) 联合体(共用体)联合体创建和初始化联合体大小(如何存储) 枚举类型枚举类型创建枚举类型初始化枚举的优点(相较于define) 前言 C语言中有内置类型和自定义类型&#xff0c;内置类型就像int…
阅读更多...
【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
阅读更多...
HTML5扫雷游戏开发实战

HTML5扫雷游戏开发实战

HTML5扫雷游戏开发实战 这里写目录标题 HTML5扫雷游戏开发实战项目介绍技术栈项目架构1. 游戏界面设计2. 核心类设计 核心功能实现1. 游戏初始化2. 地雷布置算法3. 数字计算逻辑4. 扫雷功能实现 性能优化1. DOM操作优化2. 算法优化 项目亮点技术难点突破1. 首次点击保护2. 连锁…
阅读更多...
Qt之自定义界面组件 一

Qt之自定义界面组件 一

通过qt中的painter绘图事件绘制一个电池电量图的变化。效果如下图 创建一个基于界面widget工程&#xff0c;在wdiget界面添加一个widget界面,将添加的widget界面的类提升为Tbattery.在Tbattery类中重写painEvent电池电量代码 文件目录结构 主要部分代码 //Tbattery.cpp #inc…
阅读更多...
LeRobot源码剖析——对机器人各个动作策略的统一封装：包含ALOHA ACT、Diffusion Policy、VLA模型π0

LeRobot源码剖析——对机器人各个动作策略的统一封装：包含ALOHA ACT、Diffusion Policy、VLA模型π0

前言 过去2年多的深入超过此前7年&#xff0c;全靠夜以继日的勤奋&#xff0c;一天当两天用&#xff0c;抠论文 抠代码 和大模型及具身同事讨论&#xff0c;是目前日常 而具身库里&#xff0c;idp3、π0、lerobot值得反复研究&#xff0c;故&#xff0c;近期我一直在抠π0及l…
阅读更多...
数据结构篇——线索二叉树

数据结构篇——线索二叉树

一、引入 遍历二叉树是按一定规则将二叉树结点排成线性序列&#xff0c;得到先序、中序或后序序列&#xff0c;本质是对非线性结构线性化&#xff0c;使结点&#xff08;除首尾&#xff09;在线性序列中有唯一前驱和后继&#xff1b;但以二叉链表作存储结构时&#xff0c;只能获…
阅读更多...
汽车保养记录用什么软件记录，汽车维修记录查询系统，佳易王汽车保养维护服务记录查询管理系统操作教程

汽车保养记录用什么软件记录，汽车维修记录查询系统，佳易王汽车保养维护服务记录查询管理系统操作教程

一、概述 本实例以佳易王汽车保养维护服务记录查询管理系统为例说明&#xff0c;其他版本可参考本实例。试用版软件资源可到文章最后了解&#xff0c;下载的文件为压缩包文件&#xff0c;请使用免费版的解压工具解压即可试用。 软件特点&#xff1a;1、功能实用&#xff0c;操…
阅读更多...
Python IP解析器 ip2region使用

Python IP解析器 ip2region使用

说明&#xff1a;最近需要在python项目内使用IP定位所在城市的需求&#xff0c;没有采用向外部ISP服务商API请求获取信息的方案&#xff0c;则翻了翻&#xff0c;在搞Java时很多的方案&#xff0c;在Python端反而可选择范围很小。 # 示例查询 ips ["106.38.188.214"…
阅读更多...
python开发订单查询功能（flask+orm bee）

python开发订单查询功能（flask+orm bee）

1. 搭建python环境。 可以参考其它文档。 此处python使用 3.12 IDE随意&#xff0c;PyCharm 或 Eclipse PyDev也可以。 2. Flask 2.1 安装Flask pip install Flask 2.2 一个最简单的flask实例 创建一个工程&#xff0c; 新建一个 main.py文件&#xff0c; 输入以下内容…
阅读更多...
哈尔滨服务器租用托管流程

哈尔滨服务器租用托管流程

哈尔滨服务器租用托管流程可分为三个阶段实施&#xff0c;具体操作如下&#xff1a; 一、前期准备阶段 业务需求评估 明确计算资源需求&#xff1a;CPU核心数/线程数、内存容量、存储类型(HDD/SSD/NVMe)及容量、带宽标准(独享/共享) 确定网络架构要求&#xff1a;多线接入、国际…
阅读更多...
音频大语言模型可作为描述性语音质量评价器

音频大语言模型可作为描述性语音质量评价器

论文《AUDIO LARGE LANGUAGE MODELS CAN BE DESCRIPTIVE SPEECH QUALITY EVALUATORS》学习 推动多模态代理从"能听"到"懂好坏"的进化 摘要&#xff1a; . 研究背景与问题 核心内容&#xff1a;现有音频大语言模型缺乏对输入语音质量的感知能力&#xff…
阅读更多...
我在哪，要去哪

我在哪，要去哪

在直播间听到一首好听的歌《我在哪&#xff0c;要去哪》-汤倩。 遇见的事&#xff1a;21~24号抽调去招生。 感受到的情绪&#xff1a;公假吗&#xff1f;给工作量吗&#xff1f;月工作量不够扣钱吗&#xff1f;报销方便吗&#xff1f;有事情&#xff0c;从来不解决后顾&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023