链表的基本操作函数算法(C/C++实现)

#include <cstdlib>
#include <iostream>
#include <cstdio>
using namespace std;
typedef struct NODE{
struct NODE *link;
int value;
}Node;

#define TRUE 1
#define FALSE 0
bool search_val(Node *head,int val);
Node *get_node(Node *head,int val);
int count_list(Node *head);
bool is_empty(Node *head);
Node *get_last_node(Node *head);
void destroy_list(Node **rootp);
//有些函数的声明没写在前面,请注意!
int node_insert(Node **rootp,int new_value){
if(search_val(*rootp,new_value)) return TRUE;//如果有重复元素就不用插入了
Node *previous;
Node *current;
Node *new_node;

current=*rootp;//rootp指向链表首指针,是个二阶指针
while(current!=NULL && current->value < new_value){//寻找待插入的位置
previous=current;
current=current->link;
}
//if(current->value==new_value) return TRUE;//???奇怪的bug

new_node=(Node *)malloc(sizeof(Node));
if(new_node==NULL){//如果new失败了
return FALSE;
}

new_node->value=new_value;
new_node->link=current;
if(previous==NULL){//如果待插入的元素最小,即要把new出来的结点放到链表首部
*rootp=new_node;
}else{//否则正常连接
previous->link=new_node;
}
return TRUE;
}

int node_insert(Node *head,int val){
Node *t=(Node *)malloc(sizeof(Node));
if(t==NULL) return FALSE;
t->value=val;
t->link=NULL;
if(head==NULL){
head=t;
return TRUE;
}
Node *p=get_last_node(head);
if(p==NULL){
return FALSE;
}else{
p->link=t;
}
return TRUE;
}

int node_delete(Node **rootp,int val){
if(!search_val(*rootp,val)) return FALSE;//如果没有待删除元素就直接返回
Node *previous=NULL;//previous的初始值是必要的,但要删除的是头结点时,用于判断
Node *current;
current=*rootp;//rootp指向链表首指针,是个二阶指针
while(current!=NULL && current->value!=val){//寻找待删除的位置,前面已经保证了一定有待删除元素
previous=current;
current=current->link;
}
//循环结束后就找到了待删除结点的位置current
if(previous==NULL){//如果要删除的是头节点
*rootp=current->link;
free(current);
current=NULL;
}else{
previous->link=current->link;//如果要删除的是尾结点,current->link就是NULL,就相当于设置了终止标志
free(current);
current=NULL;
}
return TRUE;

}

void show_linklist(Node *head){
Node *p=head;
while(p!=NULL){
cout<<p->value<<"->";
p=p->link;
}
cout<<"NULL"<<endl;
}

bool search_val(Node *head,int val){
Node *p=head;
while(p!=NULL){
if(p->value==val){
return true;
}
p=p->link;
}
return false;//没找到
}

Node *get_last_node(Node *head){
Node *p=head;
Node *previous=NULL;
while(p!=NULL){
previous=p;
p=p->link;
}
return previous;
}

Node *reverse_list(Node **rootp){
if(*rootp==NULL) return NULL;
int len=count_list(*rootp)-1;
int vals[len];
Node *p=*rootp;

Node *t=(Node *)malloc(sizeof(Node));
t->value=get_last_node(*rootp)->value;
t->link=NULL;

Node *root=t;
int i=0;
while(p!=NULL){
vals[i++]=p->value;
p=p->link;
}
for(i=0;i<len;++i){
node_insert(root,vals[len-1-i]);
}
destroy_list(rootp);
return root;
}

Node *get_node(Node *head,int val){
Node *p=head;
while(p!=NULL){
if(p->value==val){
return p;
}
p=p->link;
}
return NULL;//没找到
}

bool is_empty(Node *head){
if(head==NULL){
return true;
}else{
return false;
}
}

int count_list(Node *head){
Node *p=head;
int cnt=0;
while(p!=NULL){
++cnt;
p=p->link;
}
return cnt;
}

void destroy_list(Node **rootp){//删除整个链表
if(*rootp==NULL) return;
Node *p=get_last_node(*rootp);
while(p!=NULL){
node_delete(rootp,p->value);
p=get_last_node(*rootp);
}
}

void test(){//测试函数
Node t;
t.value=20;
t.link=NULL;
Node *root=&t;
for(int i=15;i<=25;++i){
node_insert(&root,i);
}
cout<<root->value<<endl;
show_linklist(root);
cout<<search_val(root,20)<<endl;
cout<<node_delete(&root,12)<<endl;
show_linklist(root);
cout<<node_delete(&root,20)<<endl;
cout<<node_delete(&root,25)<<endl;
cout<<node_delete(&root,15)<<endl;
show_linklist(root);
cout<<count_list(root)<<endl;
cout<<get_last_node(root)->value<<endl;

root=reverse_list(&root);
cout<<root->value<<endl;
show_linklist(root);
destroy_list(&root);
show_linklist(root);
cout<<(root==NULL)<<endl;
}

int main(){
test();
return 0;
}