使用C语言实现vector动态数组的实例分享_C 语言

下面是做项目时实现的一个动态数组，先后加入了好几个之后的项目，下面晒下代码。

头文件：

# ifndef __CVECTOR_H__
# define __CVECTOR_H__
# define MIN_LEN 256
# define CVEFAILED -1
# define CVESUCCESS 0
# define CVEPUSHBACK 1
# define CVEPOPBACK 2
# define CVEINSERT  3
# define CVERM    4
# define EXPANED_VAL 1
# define REDUSED_VAL 2 

typedef void *citerator;
typedef struct _cvector *cvector; 

# ifdef _cplusplus
# define EXTERN_ extern "C"
# else
# define EXTERN_ extern
# endif 

EXTERN_ cvector  cvector_create  (const size_t size              );
EXTERN_ void   cvector_destroy (const cvector cv              );
EXTERN_ size_t  cvector_length  (const cvector cv              );
EXTERN_ int    cvector_pushback (const cvector cv, void *memb        );
EXTERN_ int    cvector_popback (const cvector cv, void *memb        );
EXTERN_ size_t  cvector_iter_at (const cvector cv, citerator iter      );
EXTERN_ int    cvector_iter_val (const cvector cv, citerator iter, void *memb);
EXTERN_ citerator cvector_begin  (const cvector cv              );
EXTERN_ citerator cvector_end   (const cvector cv              );
EXTERN_ citerator cvector_next   (const cvector cv, citerator iter      );
EXTERN_ int    cvector_val_at  (const cvector cv, size_t index, void *memb );
EXTERN_ int    cvector_insert  (const cvector cv, citerator iter, void *memb);
EXTERN_ int    cvector_insert_at(const cvector cv, size_t index, void *memb );
EXTERN_ int    cvector_rm    (const cvector cv, citerator iter      );
EXTERN_ int    cvector_rm_at  (const cvector cv, size_t index       );  

/* for test */
EXTERN_ void   cv_info     (const cvector cv              );
EXTERN_ void   cv_print     (const cvector cv              );
#endif /* EOF file cvector.h */

C文件：

# include <stdio.h>
# include <stdlib.h>
# include <string.h>
# include <unistd.h>
# define MIN_LEN 256
# define CVEFAILED -1
# define CVESUCCESS 0
# define CVEPUSHBACK 1
# define CVEPOPBACK 2
# define CVEINSERT  3
# define CVERM    4
# define EXPANED_VAL 1
# define REDUSED_VAL 2 

typedef void *citerator;
typedef struct _cvector
{
  void *cv_pdata;
  size_t cv_len, cv_tot_len, cv_size;
} *cvector; 

# define CWARNING_ITER(cv, iter, file, func, line) \
  do {\
    if ((cvector_begin(cv) > iter) || (cvector_end(cv) <= iter)) {\
      fprintf(stderr, "var(" #iter ") warng out of range, "\
          "at file:%s func:%s line:%d!!/n", file, func, line);\
      return CVEFAILED;\
    }\
  } while (0) 

# ifdef _cplusplus
# define EXTERN_ extern "C"
# else
# define EXTERN_ extern
# endif 

EXTERN_ cvector  cvector_create  (const size_t size              );
EXTERN_ void   cvector_destroy (const cvector cv              );
EXTERN_ size_t  cvector_length  (const cvector cv              );
EXTERN_ int    cvector_pushback (const cvector cv, void *memb        );
EXTERN_ int    cvector_popback (const cvector cv, void *memb        );
EXTERN_ size_t  cvector_iter_at (const cvector cv, citerator iter      );
EXTERN_ int    cvector_iter_val (const cvector cv, citerator iter, void *memb);
EXTERN_ citerator cvector_begin  (const cvector cv              );
EXTERN_ citerator cvector_end   (const cvector cv              );
EXTERN_ citerator cvector_next   (const cvector cv, citerator iter      );
EXTERN_ int    cvector_val_at  (const cvector cv, size_t index, void *memb );
EXTERN_ int    cvector_insert  (const cvector cv, citerator iter, void *memb);
EXTERN_ int    cvector_insert_at(const cvector cv, size_t index, void *memb );
EXTERN_ int    cvector_rm    (const cvector cv, citerator iter      );
EXTERN_ int    cvector_rm_at  (const cvector cv, size_t index       ); 

/* for test */
EXTERN_ void   cv_info     (const cvector cv              );
EXTERN_ void   cv_print     (const cvector cv              ); 

cvector cvector_create(const size_t size)
{
  cvector cv = (cvector)malloc(sizeof (struct _cvector)); 

  if (!cv) return NULL; 

  cv->cv_pdata = malloc(MIN_LEN * size); 

  if (!cv->cv_pdata)
  {
    free(cv);
    return NULL;
  } 

  cv->cv_size = size;
  cv->cv_tot_len = MIN_LEN;
  cv->cv_len = 0; 

  return cv;
} 

void cvector_destroy(const cvector cv)
{
  free(cv->cv_pdata);
  free(cv);
  return;
} 

size_t cvector_length(const cvector cv)
{
  return cv->cv_len;
} 

int cvector_pushback(const cvector cv, void *memb)
{
  if (cv->cv_len >= cv->cv_tot_len)
  {
    void *pd_sav = cv->cv_pdata;
    cv->cv_tot_len <<= EXPANED_VAL;
    cv->cv_pdata = realloc(cv->cv_pdata, cv->cv_tot_len * cv->cv_size); 

    if (!cv->cv_pdata)
    {
      cv->cv_pdata = pd_sav;
      cv->cv_tot_len >>= EXPANED_VAL;
      return CVEPUSHBACK;
    }
  } 

  memcpy(cv->cv_pdata + cv->cv_len * cv->cv_size, memb, cv->cv_size);
  cv->cv_len++; 

  return CVESUCCESS;
} 

int cvector_popback(const cvector cv, void *memb)
{
  if (cv->cv_len <= 0) return CVEPOPBACK; 

  cv->cv_len--;
  memcpy(memb, cv->cv_pdata + cv->cv_len * cv->cv_size, cv->cv_size); 

  if ((cv->cv_tot_len >= (MIN_LEN << REDUSED_VAL))
      && (cv->cv_len <= (cv->cv_tot_len >> REDUSED_VAL)))
  {
    void *pd_sav = cv->cv_pdata;
    cv->cv_tot_len >>= EXPANED_VAL;
    cv->cv_pdata = realloc(cv->cv_pdata, cv->cv_tot_len * cv->cv_size); 

    if (!cv->cv_pdata)
    {
      cv->cv_tot_len <<= EXPANED_VAL;
      cv->cv_pdata = pd_sav;
      return CVEPOPBACK;
    }
  } 

  return CVESUCCESS;
} 

size_t cvector_iter_at(const cvector cv, citerator iter)
{
  CWARNING_ITER(cv, iter, __FILE__, __func__, __LINE__);
  return (iter - cv->cv_pdata) / cv->cv_size;
} 

int cvector_iter_val(const cvector cv, citerator iter, void *memb)
{
  CWARNING_ITER(cv, iter, __FILE__, __func__, __LINE__);
  memcpy(memb, iter, cv->cv_size);
  return 0;
} 

citerator cvector_begin(const cvector cv)
{
  return cv->cv_pdata;
} 

citerator cvector_end(const cvector cv)
{
  return cv->cv_pdata + (cv->cv_size * cv->cv_len);
} 

static inline void cvmemove_foreward(const cvector cv, void *from, void *to)
{
  size_t size = cv->cv_size;
  void *p;
  for (p = to; p >= from; p -= size) memcpy(p + size, p, size);
  return;
} 

static inline void cvmemove_backward(const cvector cv, void *from, void *to)
{
  memcpy(from, from + cv->cv_size, to - from);
  return;
} 

int cvector_insert(const cvector cv, citerator iter, void *memb)
{
  CWARNING_ITER(cv, iter, __FILE__, __func__, __LINE__); 

  if (cv->cv_len >= cv->cv_tot_len)
  {
    void *pd_sav = cv->cv_pdata;
    cv->cv_tot_len <<= EXPANED_VAL;
    cv->cv_pdata = realloc(cv->cv_pdata, cv->cv_tot_len * cv->cv_size); 

    if (!cv->cv_pdata)
    {
      cv->cv_pdata = pd_sav;
      cv->cv_tot_len >>= EXPANED_VAL;
      return CVEINSERT;
    }
  } 

  cvmemove_foreward(cv, iter, cv->cv_pdata + cv->cv_len * cv->cv_size);
  memcpy(iter, memb, cv->cv_size);
  cv->cv_len++; 

  return CVESUCCESS;
} 

int cvector_insert_at(const cvector cv, size_t index, void *memb)
{
  citerator iter; 

  if (index >= cv->cv_tot_len)
  {
    cv->cv_len = index + 1;
    while (cv->cv_len >= cv->cv_tot_len) cv->cv_tot_len <<= EXPANED_VAL;
    cv->cv_pdata = realloc(cv->cv_pdata, cv->cv_tot_len * cv->cv_size);
    iter = cv->cv_pdata + cv->cv_size * index;
    memcpy(iter, memb, cv->cv_size);
  }
  else
  {
    iter = cv->cv_pdata + cv->cv_size * index;
    cvector_insert(cv, iter, memb);
  } 

  return 0;
} 

citerator cvector_next(const cvector cv, citerator iter)
{
  return iter + cv->cv_size;
} 

int cvector_val(const cvector cv, citerator iter, void *memb)
{
  memcpy(memb, iter, cv->cv_size);
  return 0;
} 

int cvector_val_at(const cvector cv, size_t index, void *memb)
{
  memcpy(memb, cv->cv_pdata + index * cv->cv_size, cv->cv_size);
  return 0;
} 

int cvector_rm(const cvector cv, citerator iter)
{
  citerator from;
  citerator end;
  CWARNING_ITER(cv, iter, __FILE__, __func__, __LINE__);
  from = iter;
  end = cvector_end(cv);
  memcpy(from, from + cv->cv_size, end - from);
  cv->cv_len--; 

  if ((cv->cv_tot_len >= (MIN_LEN << REDUSED_VAL))
      && (cv->cv_len <= (cv->cv_tot_len >> REDUSED_VAL)))
  {
    void *pd_sav = cv->cv_pdata;
    cv->cv_tot_len >>= EXPANED_VAL;
    cv->cv_pdata = realloc(cv->cv_pdata, cv->cv_tot_len * cv->cv_size); 

    if (!cv->cv_pdata)
    {
      cv->cv_tot_len <<= EXPANED_VAL;
      cv->cv_pdata = pd_sav;
      return CVERM;
    }
  } 

  return CVESUCCESS;
} 

int cvector_rm_at(const cvector cv, size_t index)
{
  citerator iter;
  iter = cv->cv_pdata + cv->cv_size * index;
  CWARNING_ITER(cv, iter, __FILE__, __func__, __LINE__);
  return cvector_rm(cv, iter);
} 

void cv_info(const cvector cv)
{
  printf("/n/ntot :%s : %d/n", __func__, cv->cv_tot_len);
  printf("len :%s : %d/n",   __func__, cv->cv_len);
  printf("size:%s : %d/n/n",  __func__, cv->cv_size);
  return;
} 

void cv_print(const cvector cv)
{
  int num;
  citerator iter; 

  if (cvector_length(cv) == 0)
    fprintf(stderr, "file:%s func:%s line:%d error, null length cvector!!/n", __FILE__, __func__, __LINE__); 

  for (iter = cvector_begin(cv);
      iter != cvector_end(cv);
      iter = cvector_next(cv, iter))
  {
    cvector_iter_val(cv, iter, &num);
    printf("var:%d at:%d/n", num, cvector_iter_at(cv, iter));
  } 

  return;
}

改进版
上面那份代码是在Linux下写的，如果是在Windows的Visul C++环境下编译似乎会出些问题，所以特别做了个改进版：
下面是更新后的代码：

cvector.h

# ifndef __CVECTOR_H__
# define __CVECTOR_H__ 

# include <stdio.h>
# include <stdlib.h>
# include <string.h>  

# define MIN_LEN 256
# define CVEFAILED -1
# define CVESUCCESS 0
# define CVEPUSHBACK 1
# define CVEPOPBACK 2
# define CVEINSERT  3
# define CVERM    4
# define EXPANED_VAL 1
# define REDUSED_VAL 2 

typedef void *citerator;
typedef struct _cvector *cvector; 

# ifdef __cplusplus
extern "C" {
# endif 

  cvector  cvector_create  (const size_t size              );
  void   cvector_destroy (const cvector cv              );
  size_t  cvector_length  (const cvector cv              );
  int    cvector_pushback (const cvector cv, void *memb        );
  int    cvector_popback (const cvector cv, void *memb        );
  size_t  cvector_iter_at (const cvector cv, citerator iter      );
  int    cvector_iter_val (const cvector cv, citerator iter, void *memb);
  citerator cvector_begin  (const cvector cv              );
  citerator cvector_end   (const cvector cv              );
  citerator cvector_next   (const cvector cv, citerator iter      );
  int    cvector_val_at  (const cvector cv, size_t index, void *memb );
  int    cvector_insert  (const cvector cv, citerator iter, void *memb);
  int    cvector_insert_at(const cvector cv, size_t index, void *memb );
  int    cvector_rm    (const cvector cv, citerator iter      );
  int    cvector_rm_at  (const cvector cv, size_t index       ); 

  /* for test */
  void   cv_info     (const cvector cv              );
  void   cv_print     (const cvector cv              ); 

# ifdef __cplusplus
}
# endif 

#endif /* EOF file cvector.h */

cvector.c

#include "cvector.h" 

#ifndef __gnu_linux__
#define __func__ "unknown"
#define inline __forceinline
#endif 

# define CWARNING_ITER(cv, iter, file, func, line) \
  do {\
  if ((cvector_begin(cv) > iter) || (cvector_end(cv) <= iter)) {\
  fprintf(stderr, "var(" #iter ") warng out of range, "\
  "at file:%s func:%s line:%d!!\n", file, func, line);\
  return CVEFAILED;\
  }\
  } while (0) 

struct _cvector
{
  void *cv_pdata;
  size_t cv_len, cv_tot_len, cv_size;
}; 

cvector cvector_create(const size_t size)
{
  cvector cv = (cvector)malloc(sizeof (struct _cvector)); 

  if (!cv) return NULL; 

  cv->cv_pdata = malloc(MIN_LEN * size); 

  if (!cv->cv_pdata)
  {
    free(cv);
    return NULL;
  } 

  cv->cv_size = size;
  cv->cv_tot_len = MIN_LEN;
  cv->cv_len = 0; 

  return cv;
}  

void cvector_destroy(const cvector cv)
{
  free(cv->cv_pdata);
  free(cv);
  return;
}  

size_t cvector_length(const cvector cv)
{
  return cv->cv_len;
}  

int cvector_pushback(const cvector cv, void *memb)
{
  if (cv->cv_len >= cv->cv_tot_len)
  {
    void *pd_sav = cv->cv_pdata;
    cv->cv_tot_len <<= EXPANED_VAL;
    cv->cv_pdata = realloc(cv->cv_pdata, cv->cv_tot_len * cv->cv_size);  

    if (!cv->cv_pdata)
    {
      cv->cv_pdata = pd_sav;
      cv->cv_tot_len >>= EXPANED_VAL;
      return CVEPUSHBACK;
    }
  }  

  memcpy((char *)cv->cv_pdata + cv->cv_len * cv->cv_size, memb, cv->cv_size);
  cv->cv_len++;  

  return CVESUCCESS;
}  

int cvector_popback(const cvector cv, void *memb)
{
  if (cv->cv_len <= 0) return CVEPOPBACK;  

  cv->cv_len--;
  memcpy(memb, (char *)cv->cv_pdata + cv->cv_len * cv->cv_size, cv->cv_size);  

  if ((cv->cv_tot_len >= (MIN_LEN << REDUSED_VAL))
    && (cv->cv_len <= (cv->cv_tot_len >> REDUSED_VAL)))
  {
    void *pd_sav = cv->cv_pdata;
    cv->cv_tot_len >>= EXPANED_VAL;
    cv->cv_pdata = realloc(cv->cv_pdata, cv->cv_tot_len * cv->cv_size);  

    if (!cv->cv_pdata)
    {
      cv->cv_tot_len <<= EXPANED_VAL;
      cv->cv_pdata = pd_sav;
      return CVEPOPBACK;
    }
  }  

  return CVESUCCESS;
}  

size_t cvector_iter_at(const cvector cv, citerator iter)
{
  CWARNING_ITER(cv, iter, __FILE__, __func__, __LINE__);
  return ((char *)iter - (char *)cv->cv_pdata) / cv->cv_size;
}  

int cvector_iter_val(const cvector cv, citerator iter, void *memb)
{
  CWARNING_ITER(cv, iter, __FILE__, __func__, __LINE__);
  memcpy(memb, iter, cv->cv_size);
  return 0;
}  

citerator cvector_begin(const cvector cv)
{
  return cv->cv_pdata;
}  

citerator cvector_end(const cvector cv)
{
  return (char *)cv->cv_pdata + (cv->cv_size * cv->cv_len);
}  

static inline void cvmemove_foreward(const cvector cv, void *from, void *to)
{
  size_t size = cv->cv_size;
  char *p;
  for (p = (char *)to; p >= (char *)from; p -= size) memcpy(p + size, p, size);
  return;
}  

static inline void cvmemove_backward(const cvector cv, void *from, void *to)
{
  memcpy(from, (char *)from + cv->cv_size, (char *)to - (char *)from);
  return;
}  

int cvector_insert(const cvector cv, citerator iter, void *memb)
{
  CWARNING_ITER(cv, iter, __FILE__, __func__, __LINE__);  

  if (cv->cv_len >= cv->cv_tot_len)
  {
    void *pd_sav = cv->cv_pdata;
    cv->cv_tot_len <<= EXPANED_VAL;
    cv->cv_pdata = realloc(cv->cv_pdata, cv->cv_tot_len * cv->cv_size);  

    if (!cv->cv_pdata)
    {
      cv->cv_pdata = pd_sav;
      cv->cv_tot_len >>= EXPANED_VAL;
      return CVEINSERT;
    }
  }  

  cvmemove_foreward(cv, iter, (char *)cv->cv_pdata + cv->cv_len * cv->cv_size);
  memcpy(iter, memb, cv->cv_size);
  cv->cv_len++;  

  return CVESUCCESS;
}  

int cvector_insert_at(const cvector cv, size_t index, void *memb)
{
  citerator iter;  

  if (index >= cv->cv_tot_len)
  {
    cv->cv_len = index + 1;
    while (cv->cv_len >= cv->cv_tot_len) cv->cv_tot_len <<= EXPANED_VAL;
    cv->cv_pdata = realloc(cv->cv_pdata, cv->cv_tot_len * cv->cv_size);
    iter = (char *)cv->cv_pdata + cv->cv_size * index;
    memcpy(iter, memb, cv->cv_size);
  }
  else
  {
    iter = (char *)cv->cv_pdata + cv->cv_size * index;
    cvector_insert(cv, iter, memb);
  }  

  return 0;
}  

citerator cvector_next(const cvector cv, citerator iter)
{
  return (char *)iter + cv->cv_size;
}  

int cvector_val(const cvector cv, citerator iter, void *memb)
{
  memcpy(memb, iter, cv->cv_size);
  return 0;
}  

int cvector_val_at(const cvector cv, size_t index, void *memb)
{
  memcpy(memb, (char *)cv->cv_pdata + index * cv->cv_size, cv->cv_size);
  return 0;
}  

int cvector_rm(const cvector cv, citerator iter)
{
  citerator from;
  citerator end;
  CWARNING_ITER(cv, iter, __FILE__, __func__, __LINE__);
  from = iter;
  end = cvector_end(cv);
  memcpy(from, (char *)from + cv->cv_size, (char *)end - (char *)from);
  cv->cv_len--;  

  if ((cv->cv_tot_len >= (MIN_LEN << REDUSED_VAL))
    && (cv->cv_len <= (cv->cv_tot_len >> REDUSED_VAL)))
  {
    void *pd_sav = cv->cv_pdata;
    cv->cv_tot_len >>= EXPANED_VAL;
    cv->cv_pdata = realloc(cv->cv_pdata, cv->cv_tot_len * cv->cv_size);  

    if (!cv->cv_pdata)
    {
      cv->cv_tot_len <<= EXPANED_VAL;
      cv->cv_pdata = pd_sav;
      return CVERM;
    }
  }  

  return CVESUCCESS;
}  

int cvector_rm_at(const cvector cv, size_t index)
{
  citerator iter;
  iter = (char *)cv->cv_pdata + cv->cv_size * index;
  CWARNING_ITER(cv, iter, __FILE__, __func__, __LINE__);
  return cvector_rm(cv, iter);
}  

void cv_info(const cvector cv)
{
  printf("\n\ntot :%s : %d\n", __func__, cv->cv_tot_len);
  printf("len :%s : %d\n",   __func__, cv->cv_len);
  printf("size:%s : %d\n\n",  __func__, cv->cv_size);
  return;
}  

void cv_print(const cvector cv)
{
  int num;
  citerator iter;  

  if (cvector_length(cv) == 0)
    fprintf(stderr, "file:%s func:%s line:%d error, null length cvector!!\n", __FILE__, __func__, __LINE__);  

  for (iter = cvector_begin(cv);
    iter != cvector_end(cv);
    iter = cvector_next(cv, iter))
  {
    cvector_iter_val(cv, iter, &num);
    printf("var:%d at:%d\n", num, cvector_iter_at(cv, iter));
  }  

  return;
}

main.cpp

#include "cvector.h" 

int main()
{
  int i = 1;
  cvector cv = cvector_create(sizeof(int));
  cvector_pushback(cv, &i);
  cvector_pushback(cv, &i);
  cvector_pushback(cv, &i);
  cvector_pushback(cv, &i);
  cv_print(cv);
  cvector_destroy(cv);
  return 0;
}

以上是小编为您精心准备的的内容，在的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索c语言
，数组
， vector
动态数组
c语言vector、c语言 vector用法、c语言实现vector、qt vector实例、vector二维数组，以便于您获取更多的相关知识。

时间： 2024-09-07 00:18:28

使用C语言实现vector动态数组的实例分享_C 语言的相关文章

C++中关于[]静态数组和new分配的动态数组的区别分析_C 语言

本文以实例分析了C++语言中关于[]静态数组和new分配的动态数组的区别,可以帮助大家加深对C++语言数组的理解.具体区别如下: 一.对静态数组名进行sizeof运算时,结果是整个数组占用空间的大小: 因此可以用sizeof(数组名)/sizeof(*数组名)来获取数组的长度. int a[5]; 则sizeof(a)=20,sizeof(*a)=4.因为整个数组共占20字节,首个元素(int型)占4字节. int *a=new int[4];则sizeof(a)=sizeof(*a)=4,因为

一波C语言二元查找树算法题目解答实例汇总_C 语言

按层次遍历二元树问题描述:输入一颗二元树,从上往下按层打印树的每个结点,同一层中按照从左往右的顺序打印. 例如输入: 8 / / 6 10 / / / / 5 7 9 11 输出 8 6 10 5 7 9 11 定义二元树(其实是二元搜索树,但并不遍历算法)的结点为: struct BSTreeNode { int value; BSTreeNode *left; BSTreeNode *right; }; 思路:利用队列的先进先出,很容易实现.每次取出队列的首

一些C语言中字符串的算法问题解决实例小结_C 语言

字符串问题是面试中经常出现的问题,这类问题有很多,难以不一.下面是几道字符串的题目,网上都能找到解答,自己实现了一下,供网友参考.感觉算法重要的是要有正确的思路,实现起来不是问题.自己一定要多思考,这样收获可能会更多一点. 问题1:找两个字符串的最长公共子串. 具体描述,如果字符串一的所有字符按其在字符串中的顺序出现在另外一个字符串二中,则字符串一称之为字符串二的子串.注意,并不要求子串(字符串一)的字符必须连续出现在字符串二中.请编写一个函数,输入两个字

C++中字符串查找操作的两则实例分享_C 语言

在一个字符串中找到第一个只出现一次的字符题目: 在一个字符串中找到第一个只出现一次的字符.如输入 abaccdeff,则输出 b. 分析: 一个字符串存储的都是ASCII字符,其ASCII范围不超过255. 因此可以再创建一个255个元素的数组存储字符串中字符出现的个数. 通过两次遍历即可求得. 代码实现(GCC编译通过): #include "stdio.h" #include "stdlib.h" //查找字符串中第一个只出现一次

C语言时间处理实例分享_C 语言

一.简介时间处理在编程中经常遇到,包括程序的运行时间和显示时间等.在标准C中, 日期和时间的处理包含在 time.h 的头文件中,需要使用日期和时间相关的类型的函数的话, 需要导入time.h. 二.实例 1.计算时差 #include <stdio.h> #include <sys/time.h> #include <unistd.h> int main() { struct timeval start, end; unsigned long spend_time;

线程按指定顺序输出字符到数组的实例代码_C 语言

题目: 有三个线程,线程1的功能就是向字符数组输出A,线程2的功能就是向字符数组输出B,线程2的功能就是向字符数组输出C,要求按顺序向数组赋值ABCABCABC,ABC的个数由线程函数1的参数指定. 接口说明: void Init(); //初始化函数 void Release(); //资源释放函数 unsignedint__stdcall ThreadFun1(PVOID pM) ; //线程函数1,传入一个int类型的指针,用于初始化输出A次数,资源需要线程释放 unsignedint

C语言中实现KMP算法的实例讲解_C 语言

一般的算法为什么这么低效呢?那是因为主串指针回溯情况过多: 主串指针如果不回溯的话,速度就会加快,那我们就会想: 如何让主串指针不回溯? KMP算法就是解决了这个问题,所以速度变得更快速了. 它是这样子的: 用一个数组:next[] 求得失配时的位置,然后保存下来. 要说清楚KMP算法,可以从朴素的模式匹配算法说起. 朴素的模式匹配算法比较容易理解,其实现如下 int Index(char s[], char p[], int pos) { int i, j, slen, plen; i

C语言之双向链表详解及实例代码_C 语言

1,双向链表简介. 双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱.所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点.一般我们都构造双向循环链表. 2,例子要求: 完成双向链表的插入.删除以及查找,将学生管理系统使用的数组,以双向链表的方式实现,能够支持无限制的学生人数的增删改查以及保存. 3,代码实现. #include <stdio.h> #include <string.h> #include <

C语言求向量和的两则问题解答分享_C 语言

求一个向量的任何连续子向量的最大和比如向量(31,-41,59,26,-53,58,97,-93,-23,84); 最大和是从59到97即为187 #include<stdio.h> #include<stdlib.h> //两者的最大值 int max( int x, int y ); //三者的最大值 int max2( int x, int y, int z ); //最原始的算法,复杂度为T(n)=O(n*n) int oringinal( int v[], int le