数据结构
数组
struct Element
{
//…………
};
struct Eelement *create(size_t len);
int add(struct Element,struct Element e);
int del(struct Elements,size_t index);
outAll(struct Elements)；
void desttory(struct Element);
队列
struct Node
{
Element e;
struct Node *next;
}
create
destroy
enqueue
dequeue
size
iterate //遍历
front //查看
Node：结点，数据结构中用与保存数据的单元。
栈结构 stack
push：亚栈
pop：弹栈
create()
destroy()
size()
top()
iterate()
链表list
create()
destroy()
insert()
delete()
size()
iterate()
ARRAY
array.h
#ifndef __ARRAY_H
#define __ARRAY_H
#include “element.h”
typedef struct array
{
Element *eHead;
size_t max_size;
size_t counter;
}Array;
//创建并初始化数据
Array *create(size_t len);
//销毁数据
void destroy(Array *arr);
//增加数组元素
ssize_t add(Array *arr,Element e);
//删除数组元素
ssize_t del(Array *arr,size_t index);
//输出数组信息
void out(Array *arr);
//
ssize_t size(Array *arr);
ssize_t update(Array *arr,size_t index,Element e);
#endif
element.h
#ifndef __ELEMENT_H__
#define __ELEMENT_H__
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<memory.h>
typedef struct employee
{
char name[20];
int age;
float salary;
}Element;
#endif
array.c
#include”array.h”
#define INIT_MAX_SIZE 5
//创建并初始化数据
Array *create(size_t len)
{
Array *arr = (Array *)malloc(sizeof(Array));
assert(arr != NULL);
memset(arr,0,sizeof(Array));
Element *eHead =
(Element *)malloc(len*sizeof(Element));
assert(eHead != NULL);
memset(eHead,0,len*sizeof(Element));
arr->eHead = eHead;
arr->max_size = len;
return arr;
}
//销毁数据
void destroy(Array *arr)
{
assert(arr != NULL);
if(arr->eHead != NULL)
free(arr->eHead);
free(arr);//不会修改arr = NULL 不会修改函数外的指针
arr = NULL;
}
//增加数组元素
ssize_t add(Array *arr,Element e)
{
assert(arr != NULL);
if(arr->counter >= arr->max_size)
{
Element *eNew = (Element *)
realloc(arr->eHead,(arr->max_size+1)*sizeof(Element));
if(eNew == NULL)
return -1;
arr->eHead = eNew;
arr->max_size++;
}
//添加数组元素
*(arr->eHead+arr->counter) = e;
arr->counter++;
return 0;
}
//删除数组元素
ssize_t del(Array *arr,size_t index)
{
assert(arr != NULL);
//越界
if(index >= arr->counter)
return -1;
int i;
//移动数组，填补空隙
for(i =index;i < arr->counter;i++)
{
*(arr->eHead+i) = *(arr->eHead+i+1);
}
arr->counter–;
return 0;
}
static void out_element(Element *e)
{
printf(“=============Element info=================\n”);
printf(“Name:%s “,e->name);
printf(“Age:%d “,e->age);
printf(“Salary:%f\n “,e->salary);
printf(“\n”);
}
//输出数组u信息
void out(Array *arr)
{
assert(arr != NULL);
int i;
for(i = 0;i<arr->counter;i++)
{
printf(“===%d===”,i);
out_element(arr->eHead+i);
}
}
array_test.c
#include”element.h”
#include”array.h”
int main(void)
{
Array *arr = create(2);
Element e1 = {“Zhangsan”,22,10000.0};
Element e2 = {“Lisi”,23,8000.0};
Element e3 = {“wangwu”,33,99999.0};
add(arr,e1);
add(arr,e2);
out(arr);
return 0;
}
LIST
list.h
#ifndef __LIST_H__
#define __LIST_H__
#include”element.h”
typedef struct node Node;
struct node
{
Element *e;
Node *next;
};
Node *create();
void destroy(Node *head);
void insert(Node *head,Element *e);
void delete(Node *head,Element *e);
Node *find(Node *head,Element *e);
int size(Node *head);
void iterate(Node *head);
#endif
element.h
#ifndef __ELEMENT_H__
#define __ELEMENT_H__
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<memory.h>
typedef struct employee
{
int id;
char name[20];
int age;
float salary;
}Element;
void out_element(Element *e);
Element *make_element(Element *e,int id,char *name,int age,float salary);
#endif
element.c
#include”element.h”
void out_element(Element *e)
{
printf(“\n==========Element info===============\n”);
printf(“ID:%d “,e->id);
printf(“Name:%s “,e->name);
printf(“Age:%d “,e->age);
printf(“Salary:%.2f”,e->salary);
printf(“\n”);
}
Element *make_element(Element *e,int id,char *name,int age,float salary)
{
assert(e != NULL);
e->id = id;
strcpy(e->name,name);
e->age = age;
e->salary = salary;
return e;
}
list.c
#include”list.h”
/*
* 创建链表
*/
Node *create()
{
Node *head = (Node *)malloc(sizeof(Node));
assert(head != NULL);
memset(head,0,sizeof(Node));
return head;
}
/*
* 销毁链表
*/
void destroy(Node *head)
{
if(head == NULL)
return ;
destroy(head->next);
free(head);
printf(“freed: %p\n”,head);
}
/*
* 向链表中插入元素
*/
void insert(Node *head,Element *e)
{
assert(head != NULL);
//创建新的节点
Node *pNew = (Node *)malloc(sizeof(Node));
assert(pNew != NULL);
memset(pNew,0,sizeof(Node));
pNew->e = e;
Node *pPre = head;
Node *pCur = head->next;
while(pCur != NULL)
{
if(pCur->e->id >= e->id)//找到元素合适的插入位置
break;
//指针后移
pPre = pPre->next;
pCur = pCur->next;
}
//查找一个和合适的插入位置
pNew->next = pCur;
pPre->next = pNew;
}
/*
* 删除链表中某个元素的节点
*/
void delete(Node *head,Element *e)
{
assert(head != NULL);
Node *pCur = head->next;
Node *pPre = head;
while(pCur != NULL)
{
if(pCur->e->id == e->id)//找到了合适的插入位置
break;
pPre = pPre->next;
pCur = pCur->next;
}
//空链表，或者未找到
if(pCur == NULL)
return ;
//删除
pPre->next = pCur->next;
free(pCur);
}
/*
* 查找包含某个元素的节点
*/
Node *find(Node *head,Element *e)
{
assert(head != NULL);
Node *pCur = head->next;
while(pCur != NULL)
{
if(pCur->e->id == e->id)
break;
pCur = pCur->next;
}
return pCur;
}
/*
* 返回链表的长度
*/
int size(Node *head)
{
assert(head != NULL);
int counter = 0;
Node *pCur = head->next;
while(pCur != NULL)
{
pCur = pCur->next;
counter++;
}
return counter;
}
/*
* 遍历链表
*/
void iterate(Node *head)
{
assert(head != NULL);
Node *pCur = head->next;
while(pCur != NULL)
{
out_element(pCur->e);
pCur = pCur->next;
}
//if(head == NULL)
//return;
//iteratr(head->next);
//if(head->e != NULL)
//out_element(head->e);
}
list_test.c
#include “list.h”
int main(void)
{
Node *list = create();
Element *e1 = (Element *)malloc(sizeof(Element));
Element *e2 = (Element *)malloc(sizeof(Element));
Element *e3 = (Element *)malloc(sizeof(Element));
make_element(e1,1,”Zhangsan”,22,10000.0);
make_element(e2,2,”Lisi”,33,999999.0);
make_element(e3,3,”wangwu”,44,8888.0);
insert(list,e1);
insert(list,e2);
insert(list,e3);
iterate(list);
printf(“%d\n”,size(list));
printf(“============================\n”);
out_element(find(list,e2)->e);
delete(list,e2);
delete(list,e3);
printf(“%d\n”,size(list));
destroy(list);
free(e1);
free(e2);
free(e3);
return 0;
}