c++单向链表-数据结构

#ifndef LIST_H_H_
#define LIST_H_H_
#include<cstdio>
#include<cstdlib>
#include<cassert>

/** 节点中的具体的数据类型 */
typedef int DataType;

/** 链表中的节点 */
struct Node
{
DataType data_;
Node* next;
};

/** 表头 */
struct List
{
Node* head; ///<指向链表的第一个节点
};

/** 初始化链表 */
void list_init(List* list);;

/** 插入数据（在链表头部） */
int list_insert(List* list, DataType data);

/** 在指定的元素后面插入数据 */
int list_insert(List* list, DataType element, DataType data);

/** 删除节点 */
int list_remove(List* list, DataType data);

/** 寻找节点，返回找到的节点或NULL */
Node* list_find(List* list, DataType data);

/** 链表大小 */
int list_size(List* list);

/** 删除链表（不含表头） */
void list_destroy(List* list);;

#endif // !LIST_H_H_

#include "list.h"

/** 初始化链表 */
void list_init(List * list)
{
list->head = NULL;
}

/** 插入数据（在链表头部） */
int list_insert(List * list, DataType data)
{
Node* newNode = (Node*)malloc(sizeof(Node));

if (newNode == NULL)
{
fprintf(stderr, "out of memory");
return -1;
}

newNode->data_ = data;
newNode->next = list->head;
list->head = newNode;

return 0;
}

/** 在指定的元素后面插入数据 */
int list_insert(List * list, DataType element, DataType data)
{
Node* p = list_find(list, element);
if (p == NULL)
{
fprintf(stderr, "can't find the element");
return -1;
}

Node* newNode = (Node*)malloc(sizeof(Node));
if (newNode == NULL)
{
fprintf(stderr, "out of memory");
return -1;
}

newNode->data_ = data;
newNode->next = p->next;
p->next = newNode;

return 0;
}

/** 删除节点 */
int list_remove(List * list, DataType data)
{
Node* tempNode;
Node* p = list->head;

//是否是空链表
if (p == NULL)
{
return -1;
}

//如果是第一个节点
if (p->data_ == data)
{
tempNode = p->next;

#ifdef _DEBUG
//test code
printf("node remove:%d\n", p->data_);
#endif // _DEBUG

free(p);
list->head = tempNode;

return 0;
}
else
{   //遍历下一个节点
while ((p->next != NULL) && (p->next->data_ != data))
{
p = p->next;
}

if (p->next==NULL)
{
fprintf(stderr, "not found element at %s\n",__FUNCTION__);
return -1;
}
else
{
tempNode = p->next->next;

#ifdef _DEBUG
//test code
printf("node remove:%d\n", p->next->data_);
#endif // _DEBUG

free(p->next);
p->next = tempNode;
return 0;
}
}
}

/** 寻找节点，返回找到的节点或NULL */
Node * list_find(List * list, DataType data)
{
Node* p = list->head;
while ((p != NULL) && (p->data_ != data))
{
p = p->next;
}

return p;
}

/** 链表大小 */
int list_size(List * list)
{
Node* p = list->head;
int count = 0;

while (p != NULL)
{
count++;
p = p->next;
}

return count;
}

/** 删除链表（不含表头） */
void list_destroy(List * list)
{
Node* tempNode;
Node* p = list->head;
while (p != NULL)
{
tempNode = p->next;

#ifdef _DEBUG
//test code
printf("node destroy:%d\n", p->data_);
#endif // _DEBUG

free(p);
p = tempNode;

}
list->head = NULL;
}

#include<iostream>
#include"list.h"

int main()
{
List list;
list_init(&list);

list_insert(&list, 3);
list_insert(&list, 2);
list_insert(&list, 1);
list_insert(&list, 5);
list_insert(&list, 1, 7);

list_remove(&list, 1);

Node* first = list.head;
while (first!=NULL)
{
std::cout << first->data_ << std::endl;
first = first->next;
}

list_remove(&list, 9);

Node* f1=list_find(&list,2);
if (f1)
{
std::cout << "find:" << f1->data_ << std::endl;
}
else
{
std::cout << "not find" << std::endl;
}

Node* f2 = list_find(&list, 22);
if (f2)
{
std::cout << "find:" << f2->data_ << std::endl;
}
else
{
std::cout <<"not find"<< std::endl;
}

std::cout << "list size--------------:" << list_size(&list) << std::endl;
list_destroy(&list);
std::cout << "list size after destroy:" << list_size(&list) << std::endl;

return 0;
}