Day7-数据结构整理
二叉树的创建与遍历
#include
#include
#include
typedef struct Node
{
char data;
struct Node *left;
struct Node *right;
}*Btree;
//创建二叉树 返回二叉树根节点地址
Btree create_tree()
{
char e;
printf("请输入tree->data:");
scanf(" %c",&e);
if(e=='0')
return NULL;
Btree tree=(Btree)malloc(sizeof(struct Node));
if(tree==NULL)
return NULL;
tree->data=e;
//递归创建左
printf("左:");
tree->left=create_tree();
//递归创建右
printf("右:");
tree->right=create_tree();
return tree;
}
//先序遍历
void first_output(Btree tree)
{
if(tree==NULL)
return;
printf("%c ",tree->data);
first_output(tree->left);
first_output(tree->right);
}
//中序遍历
void mid_output(Btree tree)
{
if(tree==NULL)
return;
mid_output(tree->left);
printf("%c ",tree->data);
mid_output(tree->right);
}
//后序遍历
void last_output(Btree tree)
{
if(tree==NULL)
return;
last_output(tree->left);
last_output(tree->right);
printf("%c ",tree->data);
}
//计算各个节点个数
void count_tree(Btree tree,int *n0,int *n1,int *n2)
{
if(tree==NULL)
return;
if(tree->left==NULL && tree->right==NULL)
(*n0)++;//++*n0
else if(tree->left!=NULL && tree->right!=NULL)
(*n2)++;
else
(*n1)++;
count_tree(tree->left,n0,n1,n2);
count_tree(tree->right,n0,n1,n2);
}
int main(int argc, const char *argv[])
{
//创建加输入，用递归
Btree tree=create_tree();
puts("先序遍历:");
first_output(tree);
puts("");
puts("中序遍历:");
mid_output(tree);
puts("");
puts("后序遍历:");
last_output(tree);
puts("");
int n0=0,n1=0,n2=0;
count_tree(tree,&n0,&n1,&n2);
printf("n0=%d n1=%d n2=%d\n",n0,n1,n2);
return 0;
} 查找
二分查找
#include
#include
#include
//升序
int half(int key,int *arr,int low,int high)
{
int mid;
while(low<=high)
{
mid=(low+high)/2;
if(key==*(arr+mid))
return mid;
else if(key>*(arr+mid))
low=mid+1;
else
high=mid-1;
}
return -1;
}
//降序
int half_2(int key,int *arr,int low,int high)
{
int mid;
while(low<=high)
{
mid=(low+high)/2;
if(key==*(arr+mid))
return mid;
else if(key<*(arr+mid))
low=mid+1;
else
high=mid-1;
}
return -1;
}
int main(int argc, const char *argv[])
{
//int arr[]={1,10,30,50,90,110,123,126,127};
int arr[]={127,126,123,110,90,50,30,10,1};
int n=sizeof(arr)/sizeof(int);
int key;
printf("please enter key:");
scanf("%d",&key);
int low=0,high=n-1;
int sub=half_2(key,arr,low,high);
if(sub==-1)
puts("没找到");
else
printf("在数组的第%d个位置\n",sub+1);
return 0;
} 排序
直接插入排序
#include
#include
#include
int main(int argc, const char *argv[])
{
int arr[10]={-5,9,6,3,1,0,10,-9,6,-7};
int i,j,t;
int *p=arr;
for(i=1;i<10;i++)
{
t=*(p+i);
for(j=i-1;j>=0;j--)
{
if(t<*(p+j))
*(p+j+1)=*(p+j);
else
break;
}
*(p+j+1)=t;
}
for(i=0;i<10;i++)
{
printf("%d ",*(p+i));
}
printf("\n");
return 0;
} 快速排序
#include
#include
#include
/*
* function: 一轮排序
* @param [ in]
* @param [out]
* @return 返回基准值的下表
*/
int one_sort(int arr[],int low,int high)
{
int key=arr[low];//确定数组的第一个元素为基准值
//low==high 循环结束
// 1 34 45 23 56
// l
//h
while(low=arr[low])
{
low++;
}
arr[high]=arr[low];
}
arr[low]=key;//把基准值插入到数组中 low/high就是基准值的下表
return low;//high
}
void quick_sort(int arr[],int low,int high)
{
//没有元素low>high
//只有一个元素：low==high
if(low>=high)
return;
//一轮排序
int mid=one_sort(arr,low,high);
//递归左边：递归左子树
quick_sort(arr,low,mid-1);
//递归右边：递归右子树
quick_sort(arr,mid+1,high);
}
int main(int argc, const char *argv[])
{
int arr[]={12,3,34,23,14,45,76,23,12};
int len=sizeof(arr)/sizeof(arr[0]);
quick_sort(arr,0,len-1);
for(int i=0;i 链表
单链表
头插、头删、尾插、尾删、按位置插入和删除、排序、逆置、查找倒数第n个节点
#include
#include
#include
typedef int datatype;
typedef struct Node
{
datatype data;
struct Node *next;
}*Linklist;
Linklist change_data(int data,Linklist l,int e); //按元素修改
Linklist insert_data_keke(int data,Linklist l,int e); //按元素插入(往前插)
void selection_sort(Linklist l); //简单选择排序
void Bubble(Linklist l); //冒泡排序
Linklist free_sqace(Linklist l); //释放
Linklist rev_linklist(Linklist l); //逆置
Linklist delete_by_data(int e,Linklist l); //按元素删除
int search_by_data(int e,Linklist l); //按元素查找
Linklist delete_by_pos(int n,Linklist l);//任意位置删除
Linklist bull(Linklist l); //排序
int find_data(int n,Linklist l); //任意位置查找
Linklist amend_data(int n,Linklist l); //任意位置修改
Linklist insert_data(int n,Linklist l,int e); //按位置插入
int Linklist_len(Linklist l); //计算链表元素个数
Linklist delete_real(Linklist l); //尾删
Linklist insert_end(int e,Linklist l); //尾插1.0
Linklist delete_head(Linklist l); //头删
Linklist creat_node(); //申请节点空间
Linklist insert_head(datatype e,Linklist l); //头插
int ouputs(Linklist l); //输出
Linklist insert_tail(datatype e,Linklist rear); //尾插
Linklist creat_node() //申请节点空间
{
Linklist node=(Linklist)malloc(sizeof(struct Node));
if(NULL==node)
return NULL;
node->data=0;
node->next=NULL;
return node;
}
Linklist insert_head(datatype e,Linklist l) //头插
{
Linklist node=creat_node();
if(NULL==node)
return NULL;
node->data=e;
node->next=l;
l=node;
return l;
}
int ouputs(Linklist l) //输出
{
if(NULL==l)
{
return -1;
}
while(l!=NULL)
{
printf("%d ",l->data);
l=l->next;
}
printf("\n");
}
Linklist insert_tail(datatype e,Linklist rear) //尾插
{
Linklist s=creat_node();
if(NULL==s)
return NULL;
s->data=e;
if(rear!=NULL)
rear->next=s;
rear=s;
return rear;
}
Linklist insert_end(int e,Linklist l) //尾插1.0
{
Linklist s=creat_node();
s->data=e;
if(l==NULL)
{
l=s;
}
else
{
Linklist end=l;
while(end->next!=NULL)
{
end=end->next;
}
end->next=s;
}
return l;
}
Linklist delete_head(Linklist l) //头删
{
if(NULL==l)
return l;
if(l->next==NULL)
{
free(l);
l=NULL;
}
else
{
Linklist q=l->next;
l->data=q->data;
l->next=q->next;
free(q);
q=NULL;
}
return l;
}
Linklist delete_real(Linklist l) //尾删
{
if(NULL==l)
return NULL;
else if(l->next==NULL)
{
free(l);
l=NULL;
}
else
{
Linklist p=l;
while(p->next->next!=NULL)
{
p=p->next;
}
free(p->next);
p->next=NULL;
}
return l;
}
int Linklist_len(Linklist l) //计算链表元素个数
{
int count=0;
while(l!=NULL)
{
l=l->next;
count++;
}
return count;
}
Linklist insert_data(int n,Linklist l,int e) //按位置插入
{
//１.判断链表是否为空
//２.判断位置是否合法
int len=Linklist_len(l);
if(NULL==l||n<1||n>len+1)
{
puts("insert error\n");
exit(-1);
}
Linklist p=l;
if(n==len+1)
{
insert_end(e,l);
return l;
}
else
{
for(int i=1;inext;
}
Linklist s=creat_node();
s->next=p->next;
p->next=s;
s->data=p->data;
p->data=e;
return l;
}
}
Linklist amend_data(int n,Linklist l) //任意位置修改
{
int len=Linklist_len(l);
if(NULL==l||n<1||n>len)
{
printf("insert error\n");
exit(-1);
}
int i;
Linklist p=l;
for(i=1;inext;
}
printf("please enter the modified data:");
int e;
scanf("%d",&e);
p->data=e;
return l;
}
int find_data(int n,Linklist l) //任意位置查找
{
int len=Linklist_len(l);
if(NULL==l||n<1||n>len)
{
printf("insert error\n");
exit(-1);
}
int i;
Linklist p=l;
for(i=1;inext;
}
return p->data;
}
Linklist bull(Linklist l) //排序
{
int len=Linklist_len(l);
int arr[len];
int i,j,t;
Linklist p=l;
Linklist q=l;
for(i=0;idata;
p=p->next;
}
for(i=1;iarr[j+1])
{
t=arr[j];arr[j]=arr[j+1];arr[j+1]=t;
}
}
}
for(i=0;idata=arr[i];
q=q->next;
}
return l;
}
Linklist delete_by_pos(int n,Linklist l) //按任意位置删除
{
if(NULL==l||n<1||n>Linklist_len(l))
{
exit(-1);
}
if(n==1)
{
delete_head(l);
}
else
{
Linklist p=l;
for(int i=1;inext;
}
Linklist q=p->next;
p->next=q->next;
free(q);
q=NULL;
}
return l;
}
int search_by_data(int e,Linklist l) //按元素查找
{
if(NULL==l)
{
exit(-1);
}
int n=0;
while(l!=NULL)
{
n++;
if(l->data==e)
{
return n;
}
l=l->next;
}
return -1;
}
/*Linklist delete_by_data(int e,Linklist l) //按元素删除
{
if(search_by_data(e,l)==-1)
return l;
else
{
//int n=Linklist_len(l);
Linklist p=l;
while(p!=NULL)
{
for(int i=1;idata==e)
l=delete_by_pos(i,p);
p=l;
}
p=p->next;
}
}
return l;
}*/
Linklist rev_linklist(Linklist l) //逆置
{
if(NULL==l || l->next==NULL)
{
return l;
}
Linklist p=l->next;
int len=Linklist_len(l)-1;
l->next=NULL;
for(int i=0;inext;
t->next=l;
l=t;
}
return l;
}
Linklist free_sqace(Linklist l) //释放
{
if(NULL==l)
{
return l;
}
int len=Linklist_len(l);
for(int i=0;inext==NULL)
{
return ;
}
int len=Linklist_len(l);
Linklist p;
for(int i=1;idata > p->next->data)
{
int t = p->data;
p->data = p->next->data;
p->next->data = t;
}
p=p->next;
}
}
}
void selection_sort(Linklist l) //简单选择排序
{
if(NULL==l || l->next==NULL)
{
return ;
}
int len=Linklist_len(l);
Linklist min=NULL;
Linklist p=l;
for(int i=0;idata > min->next->data)
{
min=min->next;
}
}
if(min!=l)
{
int t=p->data;
p->data=min->data;
min->data=t;
}
p=p->next;
}
}
Linklist insert_data_keke(int data,Linklist l,int e) //按元素插入(往前插)
{
if(NULL==l)
return l;
Linklist p=l;
int count=0;
while(p!=NULL)
{
if(p->data==data)
count++;
p=p->next;
}
if(count==0)
{
puts("没有这个元素");
return l;
}
else
{
p=l;
/* Linklist s=creat_node();
while(p->data!=data)
{
p=p->next;
}
s->next=p->next;
p->next=s;
s->data=p->data;
p->data=e;
*/
Linklist q=NULL;
int count=0;
while(p!=NULL)
{
if(p->data==data)
{
count++;
}
p=p->next;
}
p=l;
for(int i=0;idata==data)
{
Linklist s=creat_node();
s->next=p->next;
p->next=s;
s->data=p->data;
p->data=e;
q=s->next;
break;
}
p=p->next;
}
p=q;
}
return l;
}
}
Linklist change_data(int data,Linklist l,int e) //按元素修改
{
if(NULL==l)
return l;
Linklist p=l;
int count=0;
while(p!=NULL)
{
if(p->data==data)
count++;
p=p->next;
}
if(count==0)
{
puts("没有这个元素");
return l;
}
else
{
p=l;
while(p!=NULL)
{
if(p->data==data)
{
p->data=e;
}
p=p->next;
}
return l;
}
}
int main(int argc, const char *argv[])
{
Linklist l=NULL;
int n;
datatype e;
printf("please enter n:");
scanf("%d",&n);
/*for(int i=0;i 单向循环链表
#include
#include
#include
typedef int datatype;
typedef struct Node
{
datatype data;
struct Node *next;
}*Linklist;
void Yuesefu(int n,int m,Linklist l); //约瑟夫环
Linklist delete_real(Linklist l); //尾删
Linklist delete_head(Linklist l); //头删
Linklist insert_end(datatype e,Linklist rear); //尾插
int ouputs(Linklist l); //输出
Linklist creat_node(); //申请节点空间
Linklist insert_head(datatype e,Linklist l); //头插
{
Linklist node=(Linklist)malloc(sizeof(struct Node));
if(NULL==node)
return NULL;
node->data=0;
node->next=node;
return node;
}
Linklist insert_head(datatype e,Linklist l) //头插
{
Linklist node=creat_node();
if(NULL==l)
{
l=node;
node->data = e;
}
else
{
node->next = l->next;
l->next = node;
node->data = l->data;
l->data = e;
}
return l;
}
int ouputs(Linklist l) //输出
{
if(NULL==l)
{
return -1;
}
Linklist p=l;
do
{
printf("%d ",p->data);
p=p->next;
}while(p!=l);
printf("\n");
}
Linklist insert_end(int e,Linklist l) //尾插1.0
{
Linklist s=creat_node();
s->data=e;
if(l==NULL)
{
l=s;
}
else
{
Linklist end=l;
while(end->next!=l)
{
end=end->next;
}
end->next=s;
s->next=l;
}
return l;
}
Linklist delete_head(Linklist l) //头删
{
if(NULL==l)
return l;
if(l->next==l)
{
free(l);
l=NULL;
}
else
{
Linklist end=l;
while(end->next!=l)
{
end=end->next;
}
Linklist q=l->next;
l->data=q->data;
l->next=q->next;
end->next=l;
free(q);
q=NULL;
}
return l;
}
Linklist delete_real(Linklist l) //尾删
{
if(NULL==l)
return NULL;
else if(l->next==l)
{
free(l);
l=NULL;
}
else
{
Linklist p=l;
while(p->next->next!=l)
{
p=p->next;
}
free(p->next);
p->next=l;
}
return l;
}
void Yuesefu(int n,int m,Linklist l) //约瑟夫环
{
Linklist p=l;
for(int i=0;inext;
}
Linklist q=p->next;
printf("%d ",q->data);
p->next=q->next;
free(q);
q=NULL;
p=p->next;
}
printf("\n");
}
int main(int argc, const char *argv[])
{
/* Linklist l=NULL;
int n;
datatype e;
printf("please enter n:");
scanf("%d",&n);
for(int i=0;i 双向链表
头插、尾插、头删、尾删、逆置
#ifndef __HEAD_H__
#define __HEAD_H__
#include
#include
#include
typedef char datatype[20];
typedef struct Node
{
datatype data;
struct Node *next;
struct Node *prev;
}*DoubleLink;
//逆置2.0
DoubleLink inversion2_0(DoubleLink l);
DoubleLink create_node(); //创建节点
// 头插
DoubleLink insert_head(datatype e,DoubleLink l);
// 输出
void outpus(DoubleLink l);
// 尾插
DoubleLink insert_real(datatype e,DoubleLink l);
// 头删
DoubleLink del_head(DoubleLink l);
// 尾删
DoubleLink del_real(DoubleLink l);
//逆置
DoubleLink inversion(DoubleLink l);
#endif
DoubleLink create_node() //创建节点
{
DoubleLink node=(DoubleLink)malloc(sizeof(struct Node));
if(NULL==node)
{
return NULL;
}
//对新节点的数据域赋值
strcpy(node->data,"");
//对指针域赋值
node->next=node->prev=NULL;
return node;
}
// 输出
void outpus(DoubleLink l)
{
//判断链表是否为空
if(l==NULL)
return;
//正向遍历
puts("正向遍历");
while(l->next!=NULL)
{
printf("%s ",l->data);
l=l->next;
}
printf("%s\n",l->data);
//逆向遍历
/* puts("逆向遍历");
while(l!=NULL)
{
printf("%s ",l->data);
l=l->prev;
}
printf("\n");*/
}
// 头插
DoubleLink insert_head(datatype e,DoubleLink l)
{
DoubleLink s=create_node();
if(NULL==s)
return l;
strcpy(s->data,e);
if(NULL!=l)
{
s->next=l;
l->prev=s;
}
l=s;
return l;
}
// 尾插
DoubleLink insert_real(datatype e,DoubleLink l)
{
DoubleLink s=create_node();
if(NULL==s)
{
return l;
}
strcpy(s->data,e);
if(NULL==l)
{
l=s;
return l;
}
DoubleLink real=l;
while(real->next!=NULL)
real=real->next;
real->next=s;
s->prev=real;
return l;
}
// 头删
DoubleLink del_head(DoubleLink l)
{
if(l==NULL)
return l;
if(l->next==NULL)
{
free(l);
l=NULL;
return l;
}
else if(l->next->next==NULL)
{
DoubleLink q=l->next;
strcpy(l->data,q->data);
l->next=l->prev;
free(q);
q=NULL;
return l;
}
else
{
DoubleLink q=l->next;
strcpy(l->data,q->data);
l->next=q->next;
q->next->prev=l;
free(q);
q=NULL;
return l;
}
}
// 尾删
DoubleLink del_real(DoubleLink l)
{
if(NULL==l)
return l;
if(NULL==l->next)
{
free(l);
l=NULL;
return l;
}
else
{
DoubleLink real=l;
while(real->next!=NULL)
real=real->next;
real->prev->next=NULL;
free(real);
real=NULL;
return l;
}
}
//逆置
DoubleLink inversion(DoubleLink l)
{
if(NULL==l||l->next==NULL)
return l;
datatype t;
DoubleLink p=l;
while(l->next!=NULL)
l=l->next;
DoubleLink q=l;
l=p;
while(p!=q&&p->prev!=q)
{
strcpy(t,q->data);
strcpy(q->data,p->data);
strcpy(p->data,t);
p=p->next;
q=q->prev;
}
return l;
}
//逆置2.0
DoubleLink inversion2_0(DoubleLink l)
{
if(NULL==l||l->next==NULL)
return l;
DoubleLink p=l->next;
l->next=NULL;
int i;
for(i=0;i<4;i++)
{
DoubleLink t=p;
t->prev=NULL;
p=p->next;
t->next=l;
l->prev=t;
l=t;
}
return l;
}
int main(int argc, const char *argv[])
{
DoubleLink l=NULL;
int n;
printf("please enter n:");
scanf("%d",&n);
datatype e;
for(int i=0;i 双向循环链表
#ifndef __HEAD_H__
#define __HEAD_H__
#include
#include
#include
typedef char datatype[20];
typedef struct Node
{
datatype data;
struct Node *next;
struct Node *prev;
}*DoubleLink;
DoubleLink create_node(); //创建节点
// 头插
DoubleLink insert_head(datatype e,DoubleLink l);
// 输出
void outpus(DoubleLink l);
// 尾插
DoubleLink insert_real(datatype e,DoubleLink l);
// 头删
DoubleLink del_head(DoubleLink l);
// 尾删
DoubleLink del_real(DoubleLink l);
#endif
int main(int argc, const char *argv[])
{
DoubleLink l=NULL;
int n;
printf("please enter n:");
scanf("%d",&n);
datatype e;
for(int i=0;idata,"");
//对指针域赋值
node->next=node->prev=node;
return node;
}
// 输出
void outpus(DoubleLink l)
{
//判断链表是否为空
if(l==NULL)
return;
//正向遍历
puts("正向遍历");
DoubleLink p=l;
while(l->next!=p)
{
printf("%s ",l->data);
l=l->next;
}
printf("%s\n",l->data);
//逆向遍历
puts("逆向遍历");
while(l!=p)
{
printf("%s ",l->data);
l=l->prev;
}
printf("%s\n",l->data);
}
// 头插
DoubleLink insert_head(datatype e,DoubleLink l)
{
DoubleLink s=create_node();
if(NULL==s)
return l;
strcpy(s->data,e);
DoubleLink real;
if(NULL!=l)
{
real=l->prev;
s->next=l;
l->prev=s;
real->next=s;
s->prev=real;
}
l=s;
return l;
}
// 尾插
DoubleLink insert_real(datatype e,DoubleLink l)
{
DoubleLink s=create_node();
if(NULL==s)
{
return l;
}
strcpy(s->data,e);
if(NULL==l)
{
l=s;
return l;
}
DoubleLink real=l->prev;
real->next=s;
s->prev=real;
s->next=l;
l->prev=s;
return l;
}
// 头删
DoubleLink del_head(DoubleLink l)
{
if(l==NULL)
return l;
DoubleLink p=l;
if(l->next==p)
{
free(l);
l=NULL;
return l;
}
else
{
DoubleLink q=l->next;
strcpy(l->data,q->data);
l->next=q->next;
q->next->prev=l;
free(q);
q=NULL;
return l;
}
}
// 尾删
DoubleLink del_real(DoubleLink l)
{
if(NULL==l)
return l;
if(l==l->next)
{
free(l);
l=NULL;
return l;
}
else
{
DoubleLink real=l->prev;
real->prev->next=l;
l->prev=real->prev;
free(real);
real=NULL;
return l;
}
} 队列
循环队列
因为顺序队列的使用是一次性的，会出现假溢出问题，所以引出循环队列，解决假溢出问题。
循环队列创建
#include
#include
typedef int datatyp;
#define MAXSIZE 5
typedef struct
{
//队头
int front;
//队尾
int rear;
//数据元素
datatyp data[MAXSIZE];
}QueueList;
//在堆区申请空间
QueueList *create_queue()
{
QueueList *queue=(QueueList *)malloc(sizeof(QueueList));
if(NULL==queue)
return NULL;
queue->front=queue->rear=0;
memset(queue->data,0,sizeof(queue->data));
return queue;
} 循环队列入队
/*
* function: 循环队列入队
* @param [ in]
* @param [out]
* @return 成功返回0 失败返回-1
*/
int enqueue(datatype e,QueueList *queue)
{
//1,判断是否创建
//2，判断是否满
if(NULL==queue ||queue->front==(queue->rear+1)%MAXSIZE)
{
puts("enqueue error");
return -1;
}
//3,入队：在队尾插入
queue->data[queue->rear]=e;
queue->rear=(queue->rear+1)%MAXSIZE;
return 0;
}循环队列出队
/*
* function: 出队
* @param [ in]
* @param [out]
* @return 成功返回0 失败返回-1
*/
int delqueue(QueueList *queue)
{
//1,判断是否创建
//2，判断是否为空
if(NULL==queue || queue->front==queue->rear)
{
puts("delqueue error");
return -1;
}
//3,出队：出队在队头
printf("delqueue data is:%d\n",queue->data[queue->front]);
queue->front=(queue->front+1)%MAXSIZE;
return 0;
}循环队列的遍历
/*
* function: 循环输出队列
* @param [ in]
* @param [out]
* @return 无
*/
void output(QueueList *queue)
{
//1,判断是否创建
//2，判断是否为空
if(NULL==queue || queue->front==queue->rear)
{
puts("output error");
return;
}
//3,从队头到队尾输出
for(int i=queue->front;i!=queue->rear;i=(i+1)%MAXSIZE)
{
printf("%d\t",queue->data[i]);
}
puts("");
}循环队列个数计算
/*
* function: 计算循环队列个数
* @param [ in]
* @param [out]
* @return
*/
int loop_queue_count(QueueList *queue)
{
return (MAXSIZE-queue->front+queue->rear)%MAXSIZE;
}链式队列
因为循环队列存在队满的情况，切适用于数据量较小的时候，所以引出链式队列，存储类型不同，不存在队满，可以存储数据量较多的时候。
链式队列节点创建【单链表节点创建】
/*
* function: 创建一个节点
* @param [ in]
* @param [out]
* @return
*/
Linklist create_node()
{
Linklist node=(Linklist)malloc(sizeof(struct Node));
if(NULL==node)
return NULL;
node->data=0;
node->next=NULL;
return node;//0x10
}链式队列入队【单链表尾插】
/*
* function: 尾插
* @param [ in]
* @param [out]
* @return
*/
Linklist insert_rear(datatype e,Linklist L)
{
//创建一个新节点
Linklist s=create_node();
s->data=e;
if(L==NULL)
{
L=s;
}
else
{
//rear指向最后一个节点的地址
Linklist rear=L;
while(rear->next!=NULL)
{
rear=rear->next;
}
rear->next=s;
}
return L;
}链式队列出队【单链表头删】
/*
* function: 头删除
* @param [ in]
* @param [out]
* @return
*/
Linklist delete_head(Linklist L)
{
//判断链表是否为空
if(NULL==L)
{
return L;
}
printf("delete data is:%d\n",L->data);
if(L->next==NULL)
{
free(L);
L=NULL;
}
else
{
Linklist q=L->next;
L->data=q->data;
L->next=q->next;
free(q);
q=NULL;
}
return L;
}链式队列遍历【单链表的输出】
/*
* function: 循环遍历
* @param [ in]
* @param [out]
* @return 成功返回0 失败返回-1
*/
int link_output(Linklist L)
{
//判断是否创建
//判断是否为空
if(NULL==L )
{
return -1;
}
while(L!=NULL)
{
printf("%d\t",L->data);
L=L->next;
}
puts("");
}