Implemention of data structure and algorithm in c language.?
See Github for the complete project:[Data_Structre_and_Algorithm]
dyn_array.h:
/*dynamic_array.h:This is an implemention of dynamic array in C language.
*Characteristic:
* 1.Give an initial size when defining an array
* 2.Support for dynamic expansion
* 3.Support for adding and deleting operations
*author:stdcoutzrh
*emai:stdcoutzrh@gmail.com
*/
#ifndef DYNAMIC_ARRAY_H
#define DYNAMIC_ARRAY_H
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdbool.h>
typedef struct
{
int cur_length;//current length of array
int size; //the number of elements in array
int *arr; //the memeory address of arr
}dyn_array;
dyn_array* dy_createArr(int x); //create a dynamic array
void dy_destroyArr(dyn_array* dyn_array); //destory a dynamic array
int dy_curLength(dyn_array* dyn_array); //return the current length of elements in array
int dy_size(dyn_array* dyn_array); //return the number of elements in array
bool dy_isEmpty(dyn_array* dyn_array); //judge if the array is empty
void dy_print(dyn_array* dyn_array); //print dyn_array
int dy_getValueAt(dyn_array* dyn_array,int index); //return the value of loc index element
int dy_search(dyn_array *dyn_array, int element); //search for element
int dy_pushBack(dyn_array* dyn_array,int element); //push back
int dy_popBack(dyn_array* dyn_array); //pop back
int dy_insert(dyn_array* dyn_array,int index,int element);
int dy_delete(dyn_array* dyn_array,int index);
#endif //DYNAMIC_ARRAY_H
dyn_array.c:
#include"dyn_array.h"
dyn_array* dy_createArr(int x)
{
const int min_size_of_dynamic_array = 1;
if(x<min_size_of_dynamic_array)
{
x=min_size_of_dynamic_array;
}
dyn_array* array = (dyn_array*)malloc(sizeof(dyn_array));
if(!array)
{
perror("malloc:");
exit(-1);
}
array->cur_length = x;
array->size = 0;
array->arr = (int*)malloc(sizeof(int)*array->cur_length);
if(!array->arr)
{
perror("malloc:");
exit(-1);
}
//printf("init size:%d, init length:%d\n",array->size,array->cur_length);
return array;
}
void dy_destroyArr(dyn_array* dyn_array)
{
free(dyn_array->arr);
free(dyn_array);
}
int dy_size(dyn_array* dyn_array)
{
return dyn_array->size;
}
int dy_curLength(dyn_array* dyn_array)
{
return dyn_array->cur_length;
}
bool dy_isEmpty(dyn_array* dyn_array)
{
if(dyn_array->size == 0)
return true;
return false;
}
void dy_print(dyn_array* dyn_array)
{
if(dyn_array->size ==0)
{
printf("no elements in this array!\n");
}
else
{
for(int i=0;i<dyn_array->size;++i)
{
printf("array[%d]:%d\n",i,dyn_array->arr[i]);
}
}
}
int dy_getValueAt(dyn_array* dyn_array,int index)
{
if(index>dyn_array->size || index<0)
return -1;
return dyn_array->arr[index];
}
int dy_search(dyn_array *dyn_array, int element)
{
for(int i=0;i<dyn_array->size;++i)
{
if(dyn_array->arr[i] == element)
return i;
}
return -1;
}
int dy_pushBack(dyn_array* dyn_array,int element)
{
//printf("size:%d, length:%d\n",dyn_array->size,dyn_array->cur_length);
if(dyn_array->size >= dyn_array->cur_length)
{
int *p = dyn_array->arr;
dyn_array->cur_length*=2;
dyn_array->arr = (int*)malloc(sizeof(int)*dyn_array->cur_length);
if(!dyn_array->arr)
{
perror("malloc:");
exit(-1);
}
memmove(dyn_array->arr,p,dyn_array->size*(sizeof(int)));
dyn_array->arr[dyn_array->size++]=element;
free(p);
return element;
}
else
{
dyn_array->arr[dyn_array->size++]=element;
return element;
}
}
int dy_popBack(dyn_array* dyn_array)
{
if(dyn_array->size == 0)
{
printf("no elements in this array!\n");
return -1;
}
else
{
return dyn_array->arr[--dyn_array->size];
}
}
int dy_insert(dyn_array* dyn_array,int index,int element)
{
if(index<0||index>dyn_array->size)
{
printf("index > size!\n");
return -1;
}
if(dyn_array->size >= dyn_array->cur_length)
{
int *p = dyn_array->arr;
dyn_array->cur_length*=2;
dyn_array->arr = (int*)malloc(sizeof(int)*dyn_array->cur_length);
if(!dyn_array->arr)
{
perror("malloc:");
exit(-1);
}
memmove(dyn_array->arr,p,index*(sizeof(int)));
dyn_array->arr[index]=element;
memmove(&dyn_array->arr[index+1],&p[index],(dyn_array->size-index)*(sizeof(int)));
++dyn_array->size;
free(p);
return element;
}
else
{
memmove(&dyn_array->arr[index+1],&dyn_array->arr[index],(dyn_array->size-index)*(sizeof(int)));
dyn_array->arr[index]=element;
++dyn_array->size;
return element;
}
}
int dy_delete(dyn_array* dyn_array,int index)
{
if(index<0||index>dyn_array->size)
{
printf("index > size!\n");
return -1;
}
int value = dyn_array->arr[index];
memmove(&dyn_array->arr[index],&dyn_array->arr[index+1],(dyn_array->size-index)*(sizeof(int)));
--dyn_array->size;
return value;
}