链表

#include <stdio.h>
//#include <stdlib.h>
#include <malloc.h>


//链表节点数据类型声明，链表中的每个节点都是一个Node类型变量
struct Node
{
int data;
struct Node *next;
};


//头指针为NULL表示链表为空，即链表中没有任何节点
//头指针就是链表头结点（第一个节点）的指针，它可以代表整个链表，就像数组名代表整个数组一样
//链表尾节点没有下一个节点（后继），故他的next指针成员是NULL
struct Node *head=NULL;


//链表的CRUD操作
//C：Create，即增加节点
//R：Retrieve，即查找节点
//U：Update，即修改节点数据
//D：Delete，即删除指定节点
void add(int);
void insert(int,int);//指定位置存入数据
void insert1(int,int);//指定数据存入数据//////////////////////
int  del(int);
int  upd(int,int);
int* find(int);
void show();
int  size();
void clear();
void reverse();//逆序
void sort(int);


int main()
{
add(2001);
add(1999);
add(3000);
show();

///////////////////////指定位置插入数据
insert(2,888);
show();

/* ////////////////////////////////删除节点
if(del(1000)==2 || del(1000)==1)
{
printf("未发现此节点\n");
return 0;
}

if(del(1000))
{
printf("删除1000失败！\n");
}
else
{
printf("删除成功！\n");
show();
}

//////////////////////////修改数据
if(upd(1999,2000))
{
printf("修改1999失败！\n");
}
else
{
printf("修改成功！\n");
show();
}

/////////////////////////////寻找节点
if(find(6000)==NULL)
{
printf("找不到节点！\n");
}
show();

/////////////////////////////////////求链表长度
printf("链表长度是%d\n",size());

/////////////////////////////清空链表
clear();
show();

/////////////////////////////////链表逆序
reverse();
show();

///////////////////////////冒泡排序
sort(0);
show();*/

return 0;
}


//向head所代表的链表的插入一个新节点
void add(int data)
{
/* //头插法：在链表头部插入节点
struct Node *node=(struct Node *)malloc(sizeof(struct Node));
node->data=data;
node->next=head;

head=node;*/

//尾插法：在链表尾部插入节点
struct Node *new_node=(struct Node *)malloc(sizeof(struct Node));
new_node->data=data;
new_node->next=NULL;

if(head==NULL)
{
head=new_node;
return;
}

struct Node* node=head;
while(node->next!=NULL)
{
node=node->next;
}
node->next=new_node;
}


//在指定位置插入数据，第一个节点位置为0
void insert(int pos,int data)
{
if(pos<0)
{
pos=0;
}
else if(pos>size())
{
pos=size();
}


struct Node *new_node=(struct Node *)malloc(sizeof(struct Node));
new_node->data=data;
new_node->next=NULL;

if(0==pos)
{
new_node->next=head;
head=new_node;
return;
}

struct Node *node=head;
int i;
for(i=0;i<pos-1;i++)
{
node=node->next;
}


new_node->next=node->next;
node->next=new_node;
}


//从链表中删除指定节点，删除成功返回0，否则返回非0值（不同非0值可以用来代表不同的错误原因）
int del(int data)
{
if(NULL==head)
{
return 1;
}

if(head->data==data)
{
struct Node *new_head=head->next;
free(head);
head=new_head;
return 0;
}


struct Node *prev=head;
while(prev->next!=NULL && prev->next->data!=data)
{
prev=prev->next;
}
if(prev->next==NULL)
{
return 2;
}

struct Node *del=prev->next;
prev->next=prev->next->next;
free(del);

/* struct Node *del=prev->next->next;//声明一个新的指针来记录将要删除的数据
free(prev->next);
prev->next=del;*/
return 0;
}


//修改链表中的指定节点
int upd(int data1,int data2)
{
/* struct Node *tmp=head;

while(tmp!=NULL && tmp->data!=data1)
{
tmp=tmp->next;
}
if(tmp->next==NULL)
{
return 1;
}

tmp->data=data2;*/

int *p=find(data1);

if(p==NULL)
{
return 1;
}
*p=data2;

return 0;
}


int* find(int data)
{
struct Node *tmp=head;

while(tmp!=NULL && tmp->data!=data)
{
tmp=tmp->next;
}

return tmp?(&(tmp->data)):NULL;
}


//将head所代表的链表中的所有节点的数据输出显示
void show()
{
struct Node *tmp=head;

while(NULL!=tmp)
{
printf("%d ",tmp->data);
tmp=tmp->next;
}
printf("\n");
}


int size()
{
struct Node *node=head;

int cnt=0;
while(node!=NULL)
{
cnt++;
node=node->next;
}

return cnt;
}


void clear()
{
struct Node *node=head;
struct Node *tmp=NULL;

while(node!=NULL)
{
tmp=node->next;
free(node);
node=tmp;
}
head=NULL;
}


//采用冒泡法对链表进行排序，flag为0表示从小到大排序，否则从大到小排序
void sort(int flag)
{
int i,j;
int n=size();

for(i=0;i<n-1;i++)
{
struct Node* node=head;

for(j=0;j<n-i-1;j++)
{
if(flag?(node->data<node->next->data):(node->data>node->next->data))
{
int tmp=node->data;
node->data=node->next->data;
node->next->data=tmp;
}
node=node->next;
}
}
}






void reverse()//逆序
{
if(head==NULL)
{
return;
}
struct Node* p=head->next;
struct Node* q=NULL;


head->next=NULL;


while(p!=NULL)
{
q=p->next;
p->next=head;
head=p;
p=q;
}
}