7种数据结构

news2025/3/20 4:54:54

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;
    }
    //strcpy
    memcpy(&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.coloradmin.cn/o/2318146.html

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

相关文章

3.17BUUCTF练习day1

3.17BUUCTF练习day1

BUUCTF练习day1 [极客大挑战 2019]EasySQL1&#xff08;字符型&#xff0c;账号密码型&#xff0c;get型&#xff09; 判断闭合方式 在用户名输入1‘&#xff0c;此时密码先输入任何数字时&#xff0c;出现语法错误 说明闭合方式为单引号闭合&#xff0c;在判断完闭合方式后…
阅读更多...
【贪心算法】柠檬水找零

【贪心算法】柠檬水找零

1.题目解析 860. 柠檬水找零 - 力扣&#xff08;LeetCode&#xff09; 2.讲解算法原理 分情况讨论 5---》直接收下 10---》找五元&#xff0c;收下 20----》105△ ----》555 由于5元更有用&#xff0c;则尽可能保留5元 3.代码 class Solution {public boolean lemonadeCh…
阅读更多...
黑马跟学.苍穹外卖.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…
阅读更多...
ABAP语言的动态编程（4) - 综合案例：管理费用明细表

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

本篇来实现一个综合案例&#xff1a;管理费用明细表。报表在实际项目中&#xff0c;也有一定的参考意义&#xff0c;一方面展示类似的报表&#xff0c;比如管理费用、研发费用等费用的明细&#xff0c;使用业务比较习惯的展示格式&#xff1b;另一方面正好综合运用前面学习的动…
阅读更多...
通过Geopandas进行地理空间数据可视化

通过Geopandas进行地理空间数据可视化

目录 引言 安装与导入 数据加载与探索 数据预处理 基本地图可视化 添加其他数据到地图上 空间分析与查询 地图叠加与分组 空间缓冲区 交互式地图可视化 实际应用案例 城市规划 环境监测 结论 引言 在数据科学领域，地理空间数据可视化扮演着至关重要的角色。它不…
阅读更多...
在Vue3中使用Echarts的示例

在Vue3中使用Echarts的示例

1.常用-引用ts文件方式 1.1 导出ts文件-一个简单的柱状图 export const baseBarChart (xdata: string[], data: number[][], legendData: string[]) > {if (data.length 0) {return noData;}// 定义颜色数组const color [#00CCCC,#FF9900,#1677DC,#FF6666,#B366FF,#666…
阅读更多...
GHCTF web方向题解

GHCTF web方向题解

upload?SSTI! import os import refrom flask import Flask, request, jsonify,render_template_string,send_from_directory, abort,redirect from werkzeug.utils import secure_filename import os from werkzeug.utils import secure_filenameapp Flask(__name__)# 配置…
阅读更多...
Logic-RL：小参数qwen模型复现DeepSeek R1 zero

Logic-RL：小参数qwen模型复现DeepSeek R1 zero

最近很多参照DeepSeek模型训练推理模型的工作，本文将深入 “Logic-RL: Unleashing LLM Reasoning with Rule-Based Reinforcement Learning” 的论文，该论文提出了一种Rule-Based Reinforcement Learning, Logic-RL框架，旨在提升 LLM 的逻辑推理能力，在qwen2.5-7b-instruct…
阅读更多...
CVE-2017-5645(使用 docker 搭建)

CVE-2017-5645(使用 docker 搭建)

介绍: 是一个与 Apache Log4j2 相关的安全漏洞,属于远程代码执行,它可能允许攻击者通过构造恶意的日志信息 在目标系统上执行任意代码 Log4j2 介绍 Log4j2 是 Apache 的一个日志记录工具,属于 Java 应用的日志框架,它是 Log4j 的升级版,性能更好,功能更多.它被广泛的适用于 J…
阅读更多...
蓝桥杯备考：特殊01背包问题——》集合subset

蓝桥杯备考：特殊01背包问题——》集合subset

我们划分成两个集合&#xff0c;实际上我们只需要看一部分就行了&#xff0c;也就是从集合的所有元素里挑出恰好满足集合总和的一半儿&#xff0c;当然&#xff0c;如果我们的集合总和是奇数的话&#xff0c;我们是无论如何也挑不出刚好一半儿的&#xff0c;因为我们没有小数&a…
阅读更多...
C#设计模式Demo——MVC

C#设计模式Demo——MVC

设计模式Demo——MVC 1.View1.1页面示例1.2View代码1.3修改界面以及代码 2.Model3.Controller4.数据结构5.枚举类型6.工具类6.1缓存信息6.2扩展类. 文件结构图 1.View 1.1页面示例 1.2View代码 using System; using System.Data; using System.Windows.Forms; using MVC模式…
阅读更多...
【sql靶场】第18-22关-htpp头部注入保姆级教程

【sql靶场】第18-22关-htpp头部注入保姆级教程

目录 【sql靶场】第18-22关-htpp头部注入保姆级教程 1.回顾知识 1.http头部 2.报错注入 2.第十八关 1.尝试 2.爆出数据库名 3.爆出表名 4.爆出字段 5.爆出账号密码 3.第十九关 4.第二十关 5.第二十一关 6.第二十二关 【sql靶场】第18-22关-htpp头部注入保姆级教程…
阅读更多...
LabVIEW棉花穴播器排种自动监测系统

LabVIEW棉花穴播器排种自动监测系统

一、项目背景与行业痛点 1. 农业需求驱动 我国棉花主产区&#xff0c;种植面积常年超250万公顷&#xff0c;传统人工播种存在两大核心问题&#xff1a; 效率瓶颈&#xff1a;人均日播种面积不足0.5公顷&#xff0c;难以匹配规模化种植需求&#xff1b; 精度缺陷&#xff1a;人…
阅读更多...
【程序人生】成功人生架构图（分层模型）

【程序人生】成功人生架构图（分层模型）

文章目录 ⭐前言⭐一、根基层——价值观与使命⭐二、支柱层——健康与能量⭐三、驱动层——学习与进化⭐四、网络层——关系系统⭐五、目标层——成就与财富⭐六、顶层——意义与传承⭐外层&#xff1a;调节环——平衡与抗风险⭐思维导图 标题详情作者JosieBook头衔CSDN博客专家…
阅读更多...
速通大厂测开

速通大厂测开

最近26届暑期实习招聘和25届春招已经开始&#xff0c;测开学习圈也有同学拿到offer了 今天分享一位25届秋招圈友快速拿到大厂测开offer的经历&#xff0c;希望对大家有所帮助 我是某211本科生&#xff0c;在去年暑假准备考研的间隙意外收获了某大厂测开实习offer&#xff0c;…
阅读更多...
基于Netty实现高性能HTTP反向代理

基于Netty实现高性能HTTP反向代理

以下将分步骤实现一个基于Netty的高性能HTTP反向代理&#xff0c;支持动态路由、负载均衡和基础鉴权功能。 1. 项目依赖配置&#xff08;Maven&#xff09; 2. 定义路由规则 3. 实现HTTP反向代理服务端 4. 实现反向代理处理器 5. 实现基础鉴权 6. 性能优化策略 连接池管理…
阅读更多...
【NLP 37、实践 ⑨ NER 命名实体识别任务 LSTM + CRF 实现】

【NLP 37、实践 ⑨ NER 命名实体识别任务 LSTM + CRF 实现】

难过的事情我要反复咀嚼&#xff0c;嚼到它再也不能困扰我半分 —— 25.3.13 数据文件&#xff1a; 通过网盘分享的文件&#xff1a;Ner命名实体识别任务 链接: https://pan.baidu.com/s/1fUiin2um4PCS5i91V9dJFA?pwdyc6u 提取码: yc6u --来自百度网盘超级会员v3的分享 一、配…
阅读更多...
再学：函数可见性、特殊函数、修饰符

再学：函数可见性、特殊函数、修饰符

目录 1.可见性 2.合约特殊函数 constructor && getter 3. receive && fallback 4.view && pure 5.payable 6.自定义函数修饰符 modifier 1.可见性 public&#xff1a;内外部 private&#xff1a;内部 external&#xff1a;外部访问 internal&…
阅读更多...
基于Spring Boot的项目申报系统的设计与实现（LW+源码+讲解）

基于Spring Boot的项目申报系统的设计与实现（LW+源码+讲解）

专注于大学生项目实战开发,讲解,毕业答疑辅导&#xff0c;欢迎高校老师/同行前辈交流合作✌。 技术范围&#xff1a;SpringBoot、Vue、SSM、HLMT、小程序、Jsp、PHP、Nodejs、Python、爬虫、数据可视化、安卓app、大数据、物联网、机器学习等设计与开发。 主要内容&#xff1a;…
阅读更多...
Web元件库 ElementUI元件库+后台模板页面（支持Axure9、10、11）

Web元件库 ElementUI元件库+后台模板页面（支持Axure9、10、11）

Axure是一款非常强大的原型设计工具&#xff0c;它允许设计师和开发者快速创建高保真原型&#xff0c;以展示应用或网站的设计和功能。通过引入各种元件库&#xff0c;如ElementUI元件库&#xff0c;可以极大地丰富Axure的原型设计能力&#xff0c;使其更加贴近实际开发中的UI组…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023