第3章 线性表的链式存储
3.1链式存储
数据结构的存储方式必须体现它的逻辑关系 。在链式存储方式下，实现中除存放一个结点的信息外，还需附设指针，用指针体现结点之间的逻辑关系。如果一个结点有多个后继或多个前驱，那么可以附设相应个数的指针，一个结点附设的指针指向的是这个结点的某个前驱或后继。
3.2单链表
结点一般含有两个域，一个是存放数据信息的info域，另一个是指向该结点的后继结点的存放地址的指针域next。一个单链表必须有一个首指针指向单链表中的第一个结点。
|
ADT link_list{
|
|
数据集合K：K={k1, k2,…, kn},n≥0，K中的元素是datatype
|
|
类型数据关系R：R={r}
|
|
r={ <ki, ki+1>| i=1,2,…,n-1}
|
| 操作集合： |
|
(1) node *init_link_list() 建立一个空的单链表
|
|
(2) void print_link_list(node *head) 输出单链表中各个结点的值
|
|
(3) node *insert_in_front_link_list(node *head,datatype x) 插入一个值为x的结点作为单链表的第一个结点
|
|
(4) node *find_num_link_list(node *head,datatype x) 在单链表中查找一个值为x的结点
|
|
(5) node *find_pos_link_list(node *head,int i) 在单链表中查找第i个结点
|
|
(6) node *insert_x_after_y(node *head,datatype x,datatype y) 在单链表中值为y的结点后插入一个值为x的新结点
|
|
(7) node *insert_x_after_i(node *head,datatype x,int i) 在单链表中第i个结点后插入一个值为x的新结点
|
|
(8) node *delete_num_link_list(node *head,datatype x) 在单链表中删除一个值为x的结点
|
|
(9) node *delete_pos_link_list(node *head,int i) 在单链表中删除第i个结点
|
|
}ADT link_list;
|
|
// slnklist.h
|
| |
|
typedef int datatype;
|
|
typedef struct link_node{
|
|
datatype info;
|
|
struct link_node *next;
|
|
}node;
|
|
// 建立一个空的单链表
|
| |
|
node *init_link_list()
|
| { |
|
return NULL;
|
| } |
|
// slnkprin.c
|
| |
|
void print_link_list(node *head)
|
| { |
|
node *p;
|
| |
|
p=head;
|
|
if(!p)
|
|
printf("\nslinklist is empty!");
|
|
else
|
|
{
|
|
printf("\neach value of node is：\n");
|
|
while(p)
|
|
{
|
|
printf("%5d",p->info);
|
|
p=p->next;
|
|
}
|
|
}
|
| } |
|
// 查找一个值为x的结点
|
| |
|
node *find_num_link_list(node *head,datatype x)
|
| { |
|
node *p;
|
| |
|
p=head;
|
|
while(p&&p->info!=x)
|
|
p=p->next;
|
|
|
|
return p;
|
|
}
|
|
// 查找第i个结点
|
| |
|
node *find_pos_link_list(node *head,int i)
|
| { |
|
int j=1;
|
|
node *p=head;
|
| |
|
if(i<1)
|
|
{
|
|
printf("\nError!\n");
|
|
exit(1);
|
|
}
|
|
while(p&&i!=j)
|
|
{
|
|
p=p->next;
|
|
j++;
|
|
}
|
|
return p;
|
|
}
|
|
// 插入一个值为x的结点作为单链表的第一个结点
|
| |
|
node *insert_in_front_link_list(node *head,datatype x)
|
| { |
|
node *p;
|
|
p=(node*)malloc(sizeof(node)); /*分配空间*/
|
|
p->info=x; /*设置新结点的值*/
|
|
p->next=head; /*插入(1)*/
|
|
head=p; /*插入(2)*/
|
|
return head;
|
| } |
|
// 在单链表中第i个结点后插入一个值为x的新结点
|
| |
|
node *insert_x_after_i(node *head,datatype x,int i)
|
| { |
|
node *p,*q;
|
| |
|
q=find_pos_link_list(head,i);/*查找第i个结点*/
|
|
if(!q)
|
|
{
|
|
printf("\ncan't find node %d, can't insert!\n",i);
|
|
exit(1);
|
|
}
|
|
p=(node*)malloc(sizeof(node));/*分配空间*/
|
|
p->info=x; /*设置新结点*/
|
|
p->next=q->next; /*插入(1)*/
|
|
q->next=p; /*插入(2)*/
|
| |
|
return head;
|
| } |
|
// 删除一个值为x的新结点
|
| |
|
node *delete_num_link_list(node *head,datatype x)
|
| { |
|
node *pre=NULL,*p;
|
|
if(!head)
|
|
{
|
|
printf("\nthe slinklist is empty!\n");
|
|
return head;
|
|
}
|
|
p=head;
|
|
while(p&&p->info!=x)/*没有找到并且没有找完*/
|
|
{
|
|
pre=p;p=p->next;}/*pre指向p的前驱结点*/
|
|
if(!pre&&p->info==x)/*要删除的是第一个结点*/
|
|
head=head->next;/*删除(1)*/
|
|
else
|
|
pre->next=p->next;
|
|
free(p);
|
|
|
|
return head;
|
| } |
3.3带头结点单链表
一般的单链表中，第一个结点由head指示，而在带头结点单链表中，head指示的是所谓的头结点，它不是存储数据结构中的实际结点，第一个实际的结点是head->next指示的。在带头结点单链表的操作实现时要注意这一点。
|
ADT hlink_list
|
| { |
|
数据集合K：K={k1, k2,…, kn},n≥0，K中的元素是datatype类型
|
|
数据关系R：R={r}
|
|
r={ <ki, ki+1>| i=1,2,…,n-1}
|
| 操作集合： |
|
(1) node *init_hlink_list() 建立一个空的带头结点的单链表
|
|
(2) void print_hlink_list(node *head) 输出带头结点单链表中各个结点的值
|
|
(3) node *find_num_hlink_list(node *head,datatype x) 在带头结点单链表中查找一个值为x的结点
|
|
(4) node *find_pos_hlink_list(node *head,int i) 在带头结点单链表中查找第i个结点
|
|
(5) node *insert_in_front_hlink_list(node *head,datatype x) 插入一个值为x的结点作为带头结点单链表的第一个结点
|
|
(6) node *insert_x_after_y(node *head,datatype x,datatype y) 在带头结点单链表中值为y的结点后插入一个值为x的新结点
|
|
(7) node *insert_x_after_i(node *head,datatype x,int i) 在带头结点单链表中第i个结点后插入一个值为x的新结点
|
|
(8) node *delete_num_hlink_list(node *head,datatype x) 在带头结点单链表中删除一个值为x的结点
|
|
(9) node *delete_pos_hlink_list(node *head,int i) 在带头结点单链表中删除第i个结点
|
|
}ADT hlink_list;
|
|
// 建立一个空的带头结点单链表
|
| |
|
node *init_hlink_list()
|
| { |
|
node *head;
|
| |
|
head=(node*)malloc(sizeof(node));
|
|
head->next=NULL;
|
| |
|
return head;
|
| } |
|
// 输出带头结点单链表中各个结点的值
|
| |
|
void print_hlink_list(node *head)
|
| { |
|
node *p;
|
| |
|
p=head->next;/*从第一个（实际）结点开始*/
|
|
if(!p)
|
|
printf("\n带头结点单链表是空的!");
|
|
else
|
|
{
|
|
printf("\n带头结点的单链表各个结点的值为：\n");
|
|
while(p)
|
|
{
|
|
printf("%5d",p->info);
|
|
p=p->next;
|
|
}
|
|
}
|
| } |
|
// 在带头结点单链表中查找一个值为x的结点
|
| |
|
node *find_num_hlink_list(node *head,datatype x)
|
| { |
|
node *p;
|
| |
|
p=head->next;/*从第一个（实际）结点开始*/
|
|
while(p&&p->info!=x)
|
|
p=p->next;
|
|
|
|
return p;
|
| } |
|
// 在带头结点单链表中查找第i个结点
|
| |
|
node *find_pos_hlink_list(node *head,int i)
|
| { |
|
int j=0;
|
|
node *p=head;
|
| |
|
if(i<0)
|
|
{
|
|
printf("\n带头结点的单链表中不存在第%d个结点！",i);
|
|
return NULL;
|
|
}
|
|
while(p&&i!=j)/*没有查找完并且还没有找到*/
|
|
{
|
|
p=p->next;
|
|
j++;/*继续向后（左）查找，计数器加1*/
|
|
}
|
| |
|
return p;/*返回结果，i=0时，p指示的是头结点*/
|
| } |
|
// 在带头结点单链表中值为y的结点后插入一个值为x的新结点
|
| |
|
node *insert_x_after_y(node *head,datatype x,datatype y)
|
| { |
|
node *p,*q;
|
| |
|
q=find_num_hlink_list(head,y);/*查找值为y的结点*/
|
|
if(!q)/*没有找到*/
|
|
{
|
|
printf("\n没有找到值为%d的结点，不能插入%d!",y,x);
|
|
return head;
|
|
}
|
|
p=(node*)malloc(sizeof(node));/*为准备插入的新结点分配空间*/
|
|
p->info=x;/*为新结点设置值x*/
|
|
p->next=q->next;/*插入(1)*/
|
|
q->next=p;/*插入(2)*/
|
| |
|
return head;
|
| } |
|
// 在带头结点单链表中删除一个值为x的结点
|
| |
|
node *delete_num_hlink_list(node *head,datatype x)
|
| { |
|
node *pre=head,*q;/*首先pre指向头结点*/
|
|
q=head->next;/*q从带头结点的第一个实际结点开始找值为x的结点*/
|
|
while(q&&q->info!=x)/*没有查找完并且还没有找到*/
|
|
{
|
|
pre=q;
|
|
q=q->next;
|
|
}/*继续查找，pre指向q的前驱*/
|
|
pre->next=q->next;/*删除*/
|
|
free(q);/*释放空间*/
|
| |
|
return head;
|
| } |
3.4循环单链表
对于一个循环单链表，若首指针为head，表中的某个结点p是最后一个结点的特征应该是p->next==head。
循环单链表的头文件和单链表的相同。
|
// 建立一个空的循环单链表
|
| |
|
node *init_clink_list()
|
|
{
|
|
return NULL;
|
|
}
|
|
// 输出循环单链表中各个结点的值
|
| |
|
void print_clink_list(node *head)
|
| { |
|
node *p;
|
| |
|
if(!head)
|
|
printf("\n循环单链表是空的！\n");
|
|
else
|
|
{
|
|
printf("\n循环单链表各个结点的值分别为:\n");
|
|
printf("%5d",head->info);/*输出非空表中第一个结点的值*/
|
|
p=head->next;/*p指向第一个结点的下一个结点*/
|
|
while(p!=head)/*没有回到第一个结点*/
|
|
{
|
|
printf("%5d",p->info);
|
|
p=p->next;
|
|
}
|
|
}
|
| } |
|
// 在循环单链表中第i个结点后插入一个值为x的新结点
|
| |
|
node *insert_x_after_i(node *head,datatype x,int i)
|
| { |
|
node *p,*q;
|
| |
|
q=find_pos_clink_list(head,i);/*查找第i个结点，q指向第i个结点*/
|
|
if(!q)/*没有找到，则不进行插入*/
|
|
printf("\n表中不存在第%d个结点，无法进行插入!\n",i);
|
|
else
|
|
{ /*找到了第i个结点，准备插入x*/
|
|
p=(node*)malloc(sizeof(node));/*分配空间*/
|
|
p->info=x;/*设置新结点的值*/
|
|
p->next=q->next;/*插入，修改指针(1)*/
|
|
q->next=p;/*插入，修改指针(2)*/
|
|
}
|
| |
|
return head;
|
| } |
|
// 在循环单链表中删除一个值为x的结点
|
| |
|
node *delete_num_clink_list(node *head,datatype x)
|
| { |
|
node *pre=NULL,*q;/*q用于查找值为x的结点，pre指向q的前驱结点*/
|
| |
|
if(!head)/*表为空，则无法做删除操作*/
|
|
{
|
|
printf("\n循环单链表为空,无法做删除操作!");
|
|
return NULL;
|
|
}
|
|
q=head;/*从第1个结点开始准备查找*/
|
|
while(q->next!=head&&q->info!=x)/*没有找遍整个表并且没有找到*/
|
|
{
|
|
pre=q;
|
|
q=q->next;/*pre为q的前驱，继续查找*/
|
|
}/*循环结束后，pre为q的前驱*/
|
|
if(q->info!=x)/*没找到*/
|
|
{
|
|
printf("没有找到值为%d的结点!",x);
|
|
}
|
|
else /*找到了，下面要删除q*/
|
|
{
|
|
pre->next=q->next;/*删除q指向的结点*/
|
|
free(q);/*释放空间*/
|
|
}
|
| |
|
return head;
|
| } |
3.5双链表
|
// 双链表的头文件
|
| |
|
typedef int datatype;
|
|
typedef struct dlink_node{
|
|
datatype info;
|
|
struct dlink_node *llink,*rlink;
|
|
}dnode;
|
|
// 输出双链表中各个结点的值
|
| |
|
void print_dlink_list(dnode *head)
|
| { |
|
dnode *p;
|
| |
|
p=head;
|
|
if(!p)
|
|
printf("\n双链表是空的!\n");
|
|
else
|
|
{
|
|
printf("\n双链表中各个结点的值为：\n");
|
|
while(p)
|
|
{
|
|
printf("%5d",p->info);
|
|
p=p->rlink;
|
|
}
|
|
}
|
| } |
|
// 查找双链表中第i个结点
|
| |
|
dnode *find_pos_dlink_list(dnode *head,int i)
|
| { |
|
int j=1;
|
|
dnode *p=head;
|
| |
|
if(i<1)
|
|
{
|
|
printf("\n第%d个结点不存在!\n",i);
|
|
return NULL;
|
|
}
|
|
while(p&&i!=j)/*没有找完整个表并且没有找到*/
|
|
{
|
|
p=p->rlink;j++;/*继续沿着右指针向后查找，计数器加1*/
|
|
}
|
|
if(!p)
|
|
{
|
|
printf("\n第%d个结点不存在!\n",i);
|
|
return NULL;
|
|
}
|
|
|
|
return p;
|
| } |
|
// 在双链表中第i个结点后插入一个值为x的新结点
|
| |
|
dnode *insert_x_after_i(dnode *head,datatype x,int i)
|
| { |
|
dnode *p,*q;
|
| |
|
p=(dnode*)malloc(sizeof(dnode));/*分配空间*/
|
|
p->info=x;/*设置新结点的值*/
|
|
if(i==0)/*在最前面插入一个值为x的新结点*/
|
|
{
|
|
p->llink=NULL;/*新插入的结点没有前驱*/
|
|
p->rlink=head;/*新插入的结点的后继是原来双链表中的第一个结点*/
|
|
head=p;/*新结点成为双链表的第一个结点*/
|
|
return head;
|
|
}
|
|
q=find_pos_dlink_list(head,i);/*查找第i个结点*/
|
|
if(!q)/*第i个结点不存在*/
|
|
{
|
|
printf("第%d个结点不存在，无法进行插入",i);
|
|
return head;
|
|
}
|
|
if(q->rlink==NULL)/*在最后一个结点后插入*/
|
|
{
|
|
p->rlink=q->rlink;/*即为NULL，新插入的结点没有后继。插入操作(1)*/
|
|
p->llink=q;/*插入操作(2)*/
|
|
q->rlink=p;/*插入操作(4)*/
|
|
}/*注意不能和下面的一般情况一样处理，这里如执行下面的(3)将出错！*/
|
|
else/*一般情况下的插入*/
|
|
{
|
|
p->rlink=q->rlink;/*插入操作(1)*/
|
|
p->llink=q;/*插入操作(2)*/
|
|
q->rlink->llink=p;/*插入操作(3)*/
|
|
q->rlink=p;/*插入操作(4)*/
|
|
}
|
| |
|
return head;
|
| } |
|
// 在双链表中删除一个值为x的结点
|
| |
|
dnode *delete_num_dlink_list(dnode *head,datatype x)
|
| { |
|
dnode *q;
|
| |
|
if(!head)/*双链表为空，无法进行删除操作*/
|
|
{
|
|
printf("双链表为空，无法进行删除操作");
|
|
return head;
|
|
}
|
|
q=head;
|
|
while(q&&q->info!=x)
|
|
q=q->rlink;/*循环结束后q指向的是值为x的结点*/
|
|
if(!q)
|
|
{
|
|
printf("\n没有找到值为%d的结点！不做删除操作！",x);
|
|
}
|
|
if(q==head&&head->rlink)/*被删除的结点是第一个结点并且表中不只一个结点*/
|
|
{
|
|
head=head->rlink;
|
|
head->llink=NULL;
|
|
free(q);return head;
|
|
}
|
|
if(q==head&&!head->rlink)/*被删除的结点是第一个结点并且表中只有这一个结点*/
|
|
{
|
|
free(q);
|
|
return NULL;/*双链表置空*/
|
|
}
|
|
else
|
|
{
|
|
if(!q->rlink)/*被删除的结点是双链表中的最后一个结点*/
|
|
{
|
|
q->llink->rlink=NULL;
|
|
free(q);
|
|
return head;
|
|
}
|
|
else/*q是在一个有2个以上结点的双链表中的一个非开始、也非终端结点*/
|
|
{
|
|
q->llink->rlink=q->rlink;
|
|
q->rlink->llink=q->llink;
|
|
free(q);
|
|
return head;
|
|
}
|
|
}
|
| } |
3.6链式栈
栈的链式存储称为链式栈。链式栈就是一个特殊的单链表，对于这特殊的单链表，它的插入和删除规定在单链表的同一端进行。链式栈的栈顶指针一般用top表示。
链式栈类型的描述如下：
|
ADT link_stack{
|
|
数据集合K：K={k1, k2,…, kn},n≥0，K中的元素是datatype类型
|
|
数据关系R：R={r}
|
|
r={ <ki, ki+1>| i=1,2,…,n-1}
|
| 操作集合： |
|
(1) node *init_link_stack() 建立一个空链式栈
|
|
(2) int empty_link_stack(node *top) 判断链式栈是否为空
|
|
(3) datatype get_top(node *top) 取得链式栈的栈顶结点值
|
|
(4) void print_link_stack(node *top) 输出链式栈中各个结点的值
|
|
(5) node *push_link_stack(node *top,datatype x) 向链式栈中插入一个值为x的结点
|
|
(6) node *pop_link_stack(node *top) 删除链式栈的栈顶结点
|
|
}ADT link_stack;
|
|
// 取得链式栈的栈顶结点值
|
| |
|
datatype get_top(node *top)
|
|
{
|
|
if(!top)
|
|
{
|
|
printf("\n链式栈是空的!");
|
|
exit(1);
|
|
}
|
|
return(top->info);
|
| } |
|
// 判断链式栈是否为空
|
| |
|
int empty_link_stack(node *top)
|
| { |
|
return (top? 0:1);
|
| } |
|
// 输出链式栈中各个结点的值
|
| |
|
void print_link_stack(node *top)
|
| { |
|
node *p;
|
| |
|
p=top;
|
|
if(!p) printf("\n链式栈是空的!");
|
|
while(p)
|
|
{
|
|
printf("%5d",p->info);
|
|
p=p->next;
|
|
}
|
| } |
|
// 向链式栈中插入一个值为x的结点
|
| |
|
node *push_link_stack(node *top,datatype x)
|
| { |
|
node *p;
|
| |
|
p=(node*)malloc(sizeof(node)); /*分配空间*/
|
|
p->info=x; /*设置新结点的值*/
|
|
p->next=top; /*插入(1)*/
|
|
top=p; /*插入(2)*/
|
|
return top;
|
| } |
|
// 删除链式栈的栈顶结点
|
| |
|
node *pop_link_stack(node *top)
|
| { |
|
node *q;
|
| |
|
if(!top)
|
|
{
|
|
printf("\n链式栈是空的!");
|
|
return NULL;
|
|
}
|
|
q=top;/*指向被删除的结点(1)*/
|
|
top=top->next;/*删除栈顶结点(2)*/
|
|
free(q);
|
|
return top;
|
| } |
3.7链式队列
队列的链式存储称为链式队列。链式队列就是一个特殊的单链表，对于这种特殊的单链表，它的插入和删除规定在单链表的不同端进行。链式队列的队首和队尾指针分别用front和rear表示。
链式队列类型的描述如下：
|
ADT link_queue{
|
|
数据集合K：K={k1, k2,…, kn},n≥0，K中的元素是datatype类型
|
|
数据关系R：R={r}
|
|
r={ <ki, ki+1>| i=1,2,…,n-1}
|
| 操作集合： |
|
(1) queue *init_link_queue() 建立一个空的链式队列
|
|
(2) int empty_link_queue(queue qu) 判断链式队列是否为空
|
|
(3) void print_link_queue(queue *qu) 输出链式队列中各个结点的值
|
|
(4) datatype get_first(queue qu) 取得链式队列的队首结点值
|
|
(5) queue *insert_link_queue(queue *qu,datatype x) 向链式队列中插入一个值为x的结点
|
|
(6) queue *delete_link_queue(queue *qu) 删除链式队列中队首结点
|
|
}ADT link_queue;
|
链式队列的结点定义必须有队首和队尾指针，因此增加定义一个结构类型，其中的两个域分别为队首和队尾指针。其定义如下：
|
typedef struct{
|
|
node *front,*rear; /*定义队首与队尾指针*/
|
|
}queue;
|
|
// 建立一个空的链式队列
|
| |
|
queue *init_link_queue()
|
| { |
|
queue *qu;
|
| |
|
qu=(queue*)malloc(sizeof(queue)); /*分配空间*/
|
|
qu->front=NULL; /*队首指针设置为空*/
|
|
qu->rear=NULL; /*队尾指针设置为空*/
|
|
return qu;
|
| } |
|
// 取得链式队列的队首结点值
|
| |
|
datatype get_first(queue qu)
|
| { |
|
if(!qu.front)
|
|
{
|
|
printf("\n链式队列是空的!");
|
|
exit(1);
|
|
}
|
|
return(qu.front->info);
|
| } |
|
// 向链式队列中插入一个值为x的结点
|
| |
|
queue *insert_link_queue(queue *qu,datatype x)
|
| { |
|
node *p;
|
| |
|
p=(node*)malloc(sizeof(node)); /*分配空间*/
|
|
p->info=x; /*设置新结点的值*/
|
|
p->next=NULL;
|
|
if(qu->front==NULL)
|
|
qu->front=qu->rear=p;
|
|
else
|
|
{
|
|
qu->rear->next=p; /*队尾插入*/
|
|
qu->rear=p;
|
|
}
|
|
return qu;
|
| } |
|
// 删除队首结点
|
| |
|
queue *delete_link_queue(queue *qu)
|
| { |
|
node *q;
|
|
if(!qu->front)
|
|
{
|
|
printf("队列为空，无法删除！");
|
|
return qu;
|
|
}
|
|
q=qu->front; /*q指向队首结点(1)*/
|
|
qu->front=q->next; /*队首指针指向下一个结点(2)*/
|
|
free(q); /*释放原队首结点空间*/
|
|
if(qu->front==NULL)
|
|
qu->rear=NULL; /*队列中的唯一结点被删除后，队列变空(3)*/
|
|
return qu;
|
| } |