devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

数据结构与算法系列-线性表-线式存储结构、链式存储结构_26个英文字母表的链式存储结构

作者：凡人多烦事01 | 2024-06-10 22:58:39

赞

踩

26个英文字母表的链式存储结构

线性表的定义：

线性表是由N个数据元素组成的有限序列,N为数据元素的个数。

线性表是一种非常典型的线性结构


举例:

26个英文字母(A,B,C……Z)就是一个线性表

线性表的顺序存储结构称为顺序表，顺序表是将线性表中的数据元素按其逻辑顺序依次存放在内存中一组地址连续的存储单元中，即把线性表的相邻元素存在相邻的内存单元中。

 

顺序表的特点是逻辑上相邻的两个元素在物理位置也相邻,可以用一个简单的公式计算出某一元素的存放位置。因此为线性表的存取是很容易的。

 

线性表的缺点：

对线性表进行插入或者删除的时候，需要移动大量元素,消耗时间较多，另外顺序表是用数组来存放线性表中各个元素的，线性表中的最大长度难确，必须按照线性表的最大可能长度来分配空间,若是线性表长度变化较大时,则使存储空间不能得到充分利用,如果分配较小,有可能导致溢出。

线性表的描述 

  1. # define MAXLEN 100  //maxlen 要大于实际线性表的长度
  2. typedef int elementtype;
  3. typedef struct{
  4. 	elementtype s[MAXLEN]; //定义线性表中的元素,MAXLEN为线性表的最大容量
  5. 	int len;			//定义线性表的表长
  6. }SqList;

线性表的插入运算。(图片来自网络)


在具有n个线性表的第i(1<=i<=n)个元素之前插入一个新元素

由于顺序表中的元素在机器内是连续存放的,要在第i个元素之前插入一个新元素,就必须把第n个到第i个元素依次向后以后一个位置。

  1. #include <stdio.h>
  2. # define MAXLEN 100  //maxlen 要大于实际线性表的长度
  3. typedef int elementtype;
  4. typedef struct{
  5. 	elementtype s[MAXLEN]; //定义线性表中的元素,MAXLEN为线性表的最大容量
  6. 	int len;			//定义线性表的表长
  7. }SqList;
  8.  
  9. /*在顺序表 *sql 的第i个元素之前插入一个新的元素x */
  10. int insertsqlist(int i,elementtype x,SqList *sql){
  11. 	int j;
  12. 	if((i<1)||(i>sql->len)){
  13. 		return 0;
  14. 	}else{
  15. 		for(j = sql->len;j>=i;j--){
  16. 			sql->s[j+1] = sql ->s[j]; //向后移动数据 腾出要插入的空位
  17. 		}
  18. 		sql ->s[j+1] = x;		//修正插入位置为 j+1,将新元素插入到s[j+1]位置
  19. 		(sql -> len)++;			//表长加1
  20. 		return 1;
  21. 	}
  22. }
  23. main(){
  24. 	int b =3,c,k;
  25. 	elementtype d = 9;
  26. 	SqList a = {0,1,2,3,4,5,6,7,8};
  27. 	a.len = 8;
  28. 	for(k=1;k<a.len;k++){
  29. 		printf("% 3d",a.s[k]);
  30. 	}
  31. 	printf("\n");
  32. 	c = insertsqlist(b,d,&a);
  33. 	if(c==0){
  34. 		printf("error");
  35. 	}else{
  36. 		for(k=1;k<a.len;k++){
  37. 		printf("% 3d",a.s[k]);
  38. 		}
  39. 	}
  40. 	printf("\n");
  41. }


插入一个新元素需要移动的平均次数为 n/2


线性表的删除运算 

  1. #include<stdio.h>
  2. #define MAXLEN 100   /*MAXLEN 要大于实际线性表的长度*/
  3. typedef int elementtype;
  4. typedef struct{				
  5. 	elementtype s[MAXLEN];
  6. 	int len;
  7. }SqList;
  8.  
  9. int delsqllist(int i,SqList *sql){
  10. 	int j;
  11. 	if((i<1)||(i>sql->len)){
  12. 		return(0);
  13. 	}else{
  14. 		for(j=i+1;j<=sql->len;j++){
  15. 			sql ->s[j-1] = sql ->s[j]; /*向前移动数据,覆盖前一数据*/
  16. 		}
  17. 		(sql->len)--;
  18. 		return 1;
  19. 	}
  20. }
  21.  
  22. main(){
  23. 	int b=4,c,k;
  24. 	SqList a = {0,1,2,3,4,5,6,7,8};
  25. 	/*赋线性表各元素初值,为之前概念描述一致,a.s[0]闲置不用*/
  26. 	a.len = 8 ;
  27. 	for(k=1;k<a.len;k++){
  28. 		printf("%3d",a.s[k]);  /*删除之前*/
  29. 	}
  30. 	printf("\n");
  31. 	c= delsqllist(b,&a);
  32. 	if(c==0){
  33. 		printf("error \n");
  34. 	}	
  35. 	else{
  36. 		for(k=1;k<a.len;k++){
  37. 			printf("%3d",a.s[k]); /*删除之后*/ 
  38. 		}
  39.  
  40. 	}
  41. 	printf("\n");
  42. }

删除一个元素需要移动的平均次数为 (n-1)/2

当线性表中的元素很多时,算法的效率很低。若表长n，则插入和删除的时间复杂度为O(n)


因为线性表的缺点  我们可以采用另外一种存储方式 链式存储结构。

线性表的链式存储结构是用一组 任意存储单元 来存放表中的数据元素,这组存储单元可以是连续的可以是不连续的。为了表示出每个元素与其后继元素之间的关系,除了存储本身的信息外,还需要存储一个指示其后继的存储位置信息

单向链表



顺序表是一种静态存储结构,而链表是一种动态存储结构。

若线性链表的每个节点只含有一个指针域， 则这样的链表称为单链表。

单链表的插入运算

  1. /*
  2. 建立链表时,首先要建立表头节点,此时为空链表。然后将新的节点逐一插入到链表中
  3. Step1: 申请存储单元 malloc (sizeof(Node))
  4. Step2: 读入该节点的数据 新节点的指针域为空
  5. Step3: 把新节点链接到链表上去（前插 后插）
  6. */
  7.  
  8. #include<malloc.h>
  9. #include<stdio.h>
  10. typedef struct node{
  11. 	int data;
  12. 	struct node * next;
  13. }NODE;
  14.  
  15. NODE * create(){/*此函数采用后插入方式建立单链表,并返回一个指向链表表头的指针*/
  16. 	NODE *head,*q,*p;/*定义指针变量*/
  17. 	char ch;
  18. 	int a;
  19. 	head = (NODE *)malloc(sizeof(NODE));/*申请新的存储空间,建立表头节点*/
  20. 	q = head;
  21. 	ch = '*';
  22. 	printf("\n Input the list:");
  23. 	while(ch!='?'){
  24. 		scanf("%d",&a); /*输入新元素*/
  25. 		p = (NODE *)malloc(sizeof(NODE));
  26.  
  27. 		p->data = a; /*将新节点数据赋值给p*/
  28. 		q->next =p;  /*将 指针p 赋值给他的前一个指针*/
  29. 		q = p;	/* 指针p赋值给指针q */
  30.  
  31. 		ch = getchar();
  32. 	}
  33. 	q -> next =NULL;/*新节点的指针域为空*/
  34. 	return (head); /*返回表头指针head*/
  35. }
  36.  
  37. main(){
  38. 	NODE *a;
  39. 	a= create();
  40. 	printf("out put the list");
  41. 	a = a->next;
  42. 	while(a!=NULL){
  43. 		printf("% d",a->data);
  44. 		a = a->next;
  45. 	}
  46. }

单链表中的查找


locate()  按值查找 find 按序号查找

  1. /*
  2. 建立链表时,首先要建立表头节点,此时为空链表。然后将新的节点逐一插入到链表中
  3. Step1: 申请存储单元 malloc (sizeof(Node))
  4. Step2: 读入该节点的数据 新节点的指针域为空
  5. Step3: 把新节点链接到链表上去（前插 后插）
  6. */
  7.  
  8. #include<malloc.h>
  9. #include<stdio.h>
  10. typedef struct node{
  11. 	int data;
  12. 	struct node * next;
  13. }NODE;
  14.  
  15. NODE * create(){/*此函数采用后插入方式建立单链表,并返回一个指向链表表头的指针*/
  16. 	NODE *head,*q,*p;/*定义指针变量*/
  17. 	char ch;
  18. 	int a;
  19. 	head = (NODE *)malloc(sizeof(NODE));/*申请新的存储空间,建立表头节点*/
  20. 	q = head;
  21. 	ch = '*';
  22. 	printf("\n Input the list:");
  23. 	while(ch!='?'){
  24. 		scanf("%d",&a); /*输入新元素*/
  25. 		p = (NODE *)malloc(sizeof(NODE));
  26.  
  27. 		p->data = a; /*将新节点数据赋值给p*/
  28. 		q->next =p;  /*将 指针p 赋值给他的前一个指针*/
  29. 		q = p;	/* 指针p赋值给指针q */
  30.  
  31. 		ch = getchar();
  32. 	}
  33. 	q -> next =NULL;/*新节点的指针域为空*/
  34. 	return (head); /*返回表头指针head*/
  35. }
  36.  
  37. NODE * locate(NODE *head,int x){//在已知链表中查找给定的值x
  38. 	NODE *p;
  39. 	p = head->next;
  40. 	while((p!=NULL)&&(p->data!=x))//未到表尾且未找到数据
  41. 		p = p->next;
  42. 	return p;
  43. }
  44.  
  45. NODE * find(NODE *head,int i){ /*在已知链表中查找序号为i的节点*/
  46. 	int j =1;
  47. 	NODE *p;
  48. 	p = head ->next;
  49. 	while((p!=NULL)&& (j<i)){
  50. 		p = p->next;
  51. 		j++;
  52. 	}
  53. 	return p;
  54. }
  55.  
  56. main(){
  57. 	int y;
  58. 	NODE *a,*b;
  59. 	a = create();
  60. 	printf("Input x:");
  61. 	scanf("%d",&y);
  62. 	//b= locate(a,y);
  63. 	b = find(a,y);
  64. 	if(b!=NULL){
  65. 		printf("find:");
  66. 		printf("% 5d",b->data);
  67. 	}else
  68. 		printf("error");	
  69. }


单链表的插入和删除

  1. #include<malloc.h>
  2. #include<stdio.h>
  3. typedef struct node{
  4. 	int data;
  5. 	struct node *next;
  6. }NODE;
  7.  
  8. NODE *create(){ /*此函数采用后插入的方式建立单链表,并返回一个指向链表表头的指针*/
  9. 	NODE * head,*q,*p;
  10. 	int a,n;
  11. 	head = (NODE *)malloc(sizeof(NODE)); /*申请新的存储空间,建立表头节点*/
  12. 	q = head;
  13. 	printf("\n Input number of the list");
  14. 	scanf("%d",&n);/*输入单向链表的个数*/
  15.  
  16. 	if(n>0){
  17. 		printf("Input the list:");
  18. 		while(n>0){
  19. 			scanf("%d",&a);/*输入新元素*/
  20. 			p = (NODE*)malloc(sizeof(NODE));
  21. 			p ->data = a;
  22. 			q ->next = p;
  23. 			q= p;
  24. 			n--;
  25. 		}
  26. 	}
  27. 	q->next = NULL;
  28. 	return (head);
  29. }
  30. void insert(NODE *p,int x){/*在链表的p结点置后出插入给定的元素*/
  31. 	NODE *q;
  32. 	q = (NODE*)malloc(sizeof(NODE)); /*申请新的存储空间*/
  33. 	q ->data = x; /*将x赋值给开辟空间的q*/
  34. 	q ->next = p->next; /*p的下一个结点指针赋值给新增元素的下一个结点指针*/
  35. 	p->next = q;/*新增元素添加到链表中*/
  36. }
  37.  
  38. void deleteList(NODE *head,int x){
  39. 	NODE *p,*q;
  40. 	q = head;
  41. 	p = q->next;
  42. 	while((p!=NULL)&&(p->data !=x)){ /*查找要删除的元素*/
  43. 		q = p;
  44. 		p = p->next;
  45. 	}
  46. 	if(p==NULL)
  47. 		printf("%d not found.\n",x);
  48. 	else{
  49. 		q->next = p->next;/*链接x直接后继结点*/
  50. 		free(p);/*删除x结点,释放x结点空间*/
  51. 	}
  52. 	
  53.  
  54. }
  55. /* 
  56. insertMain
  57. main(){
  58. 	int x,position;
  59. 	int i=0,j = 0;
  60. 	NODE *c,*d;
  61. 	c = create();
  62. 	d = c->next;
  63. 	while(d!=NULL){
  64. 		d = d->next;
  65. 		j++;
  66. 	}
  67. 	d = c;
  68. 	do{
  69. 		printf("Input position (again:)");
  70. 		scanf("%d",&position); //position 可以为0表示表头结点
  71. 	}while(position>j || position<0);//position 值超过单向链表结点数，重新输入
  72. 	printf("Input x:");
  73. 	scanf("%d",&x);
  74. 	while(i!=position){//由postion确定其在单向链表中的位置d
  75. 		d = d->next;
  76. 		i++;
  77. 	}
  78. 	insert(d,x);
  79. 	printf("Output the list");
  80. 	while(c->next!=NULL){
  81. 		c = c->next;
  82. 		printf("%5d",c->data);
  83. 	}
  84. 	printf("ok");
  85. }*/
  86.  
  87. main(){
  88. 	int x;
  89. 	NODE *a,*b;
  90. 	a = create();
  91. 	printf("Input x:");
  92. 	scanf("%5d",&x);
  93. 	deleteList(a,x);
  94. 	b = a ;
  95. 	b = b->next;
  96. 	printf("Output the list:");
  97. 	while(b!=NULL){
  98. 		printf("%5d",b->data); //输出删除x后的单向链表
  99. 		b = b->next;
  100. 	}
  101. }

循环链表

单链表各结点之间由一个指针域链接，最后一个指针域的值用NULL表示,作为链表结束的标志。如果将单链表最后一个结点的指针指向头结点,使链表形成一个环形,此链表称为循环链表。



循环链表的插入和查找。

  1. #include<malloc.h>
  2. #include<stdio.h>
  3. typedef struct node{//定义结点的存储结构
  4. 	int data;
  5. 	struct node *next;
  6. }NODE;
  7.  
  8. NODE* create_circular(){//此函数采用后插入方式建立单向循环列表,并返回一个指向链表表头的指针
  9. 	NODE * head,*q,*p;
  10. 	int a,n;
  11. 	head = (NODE*)malloc(sizeof(NODE)); /*申请新的存储空间,建立表头节点*/
  12. 	q = head;
  13. 	printf("\n Input number of the list");
  14. 	scanf("%d",&n);/*输入单向链表的个数*/
  15. 	head ->data=n; //表头结点赋值n 即表中结点个数
  16. 	if(n>0){
  17. 		printf("Input the list:");
  18. 		while(n>0){
  19. 			scanf("%d",&a);/*输入新元素*/
  20. 			p = (NODE*)malloc(sizeof(NODE));
  21. 			p ->data = a;
  22. 			q ->next = p;
  23. 			q= p;
  24. 			n--;
  25. 		}
  26. 	}
  27. 	q->next = head; //将最后一个结点指向表头
  28. 	return (head);
  29. }
  30.  
  31. NODE* prior(NODE*p){//返回结点p的直接前驱结点q，这里pq为结点指针
  32. 	NODE *q;
  33. 	q = p->next;
  34. 	while(q->next!=p)
  35. 		q = q->next;
  36. 	return (q);
  37. }
  38.  
  39. main(){
  40. 	NODE* a,*c,*p;
  41. 	int i,j;
  42. 	a = create_circular();//建立单向循环链表
  43. 	printf("Input j:"); //给出单向循环链表中的结点序号,表头序号为0
  44. 	scanf("%d",&j);
  45. 	p = a;
  46. 	for(i=0;i<j;i++)
  47. 		p = p->next;//按序号确定一个p结点
  48. 	c = prior(p);
  49. 	printf("prior of %d is: %d",p->data,c->data);
  50. }


双向链表

一种更复杂的链表是“双向链表”或“双面链表”。每个节点有两个连接：一个指向前一个节点，（当此“连接”为第一个“连接”时，指向空值或者空列表）；而另一个指向下一个节点，（当此“连接”为最后一个“连接”时，指向空值或者空列表）


在单向循环链表中,虽然从任一已知结点都可以找到其前驱结点,但其时间复杂度为O(n),原因在于其每个结点只含有一个指向其后继结点的指针。若希望能快速找到一个结点的直接前驱,则可以在循环表中的结点中再增加一个指针域.这个指针直接指向该结点的直接前驱,这样 链表中的每一个结点就有了两个指针域.这称为双向链表。时间复杂度O(1)

双向链表的定义与操作运算 

  1. /* 线性表的双向链表存储结构 */
  2. typedef struct DuLNode
  3. {
  4.   ElemType data;
  5.   struct DuLNode *prior,*next;
  6. }DuLNode,*DuLinkList;

  1. /*带头结点的双向循环链表的基本操作(14个) */
  2. void InitList(DuLinkList *L)
  3. { /* 产生空的双向循环链表L */
  4.   *L=(DuLinkList)malloc(sizeof(DuLNode));
  5.   if(*L)
  6.     (*L)->next=(*L)->prior=*L;
  7.   else
  8.     exit(OVERFLOW);
  9. }

  1. void DestroyList(DuLinkList *L)
  2. { /* 操作结果：销毁双向循环链表L */
  3.   DuLinkList q,p=(*L)->next; /* p指向第一个结点 */
  4.   while(p!=*L) /* p没到表头 */
  5.   {
  6.     q=p->next;
  7.     free(p);
  8.     p=q;
  9.   }
  10.   free(*L);
  11.   *L=NULL;
  12. }

  1. void ClearList(DuLinkList L) /* 不改变L */
  2. { /* 初始条件：L已存在。操作结果：将L重置为空表 */
  3.   DuLinkList q,p=L->next; /* p指向第一个结点 */
  4.   while(p!=L) /* p没到表头 */
  5.   {
  6.     q=p->next;
  7.     free(p);
  8.     p=q;
  9.   }
  10.   L->next=L->prior=L; /* 头结点的两个指针域均指向自身 */
  11. }

  1. Status ListEmpty(DuLinkList L)
  2. { /* 初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
  3.   if(L->next==L&&L->prior==L)
  4.     return TRUE;
  5.   else
  6.     return FALSE;
  7. }

  1. int ListLength(DuLinkList L)
  2. { /* 初始条件：L已存在。操作结果：返回L中数据元素个数 */
  3.   int i=0;
  4.   DuLinkList p=L->next; /* p指向第一个结点 */
  5.   while(p!=L) /* p没到表头 */
  6.   {
  7.     i++;
  8.     p=p->next;
  9.   }
  10.   return i;
  11. }

  1. Status GetElem(DuLinkList L,int i,ElemType *e)
  2. { /* 当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR */
  3.   int j=1; /* j为计数器 */
  4.   DuLinkList p=L->next; /* p指向第一个结点 */
  5.   while(p!=L&&jnext;
  6.     j++;
  7.   }
  8.   if(p==L||j>i) /* 第i个元素不存在 */
  9.     return ERROR;
  10.   *e=p->data; /* 取第i个元素 */
  11.   return OK;
  12. }

  1. int LocateElem(DuLinkList L,ElemType e,Status(*compare)(ElemType,ElemType))
  2. { /* 初始条件：L已存在，compare()是数据元素判定函数 */
  3.   /* 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。 */
  4.   /*           若这样的数据元素不存在，则返回值为0 */
  5.   int i=0;
  6.   DuLinkList p=L->next; /* p指向第1个元素 */
  7.   while(p!=L)
  8.   {
  9.     i++;
  10.     if(compare(p->data,e)) /* 找到这样的数据元素 */
  11.       return i;
  12.     p=p->next;
  13.   }
  14.   return 0;
  15. }

  1. Status PriorElem(DuLinkList L,ElemType cur_e,ElemType *pre_e)
  2. { /* 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱， */
  3.   /*           否则操作失败，pre_e无定义 */
  4.   DuLinkList p=L->next->next; /* p指向第2个元素 */
  5.   while(p!=L) /* p没到表头 */
  6.   {
  7.     if(p->data==cur_e)
  8.     {
  9.       *pre_e=p->prior->data;
  10.       return TRUE;
  11.     }
  12.     p=p->next;
  13.   }
  14.   return FALSE;
  15. }

  1. Status NextElem(DuLinkList L,ElemType cur_e,ElemType *next_e)
  2. { /* 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继， */
  3.   /*           否则操作失败，next_e无定义 */
  4.   DuLinkList p=L->next->next; /* p指向第2个元素 */
  5.   while(p!=L) /* p没到表头 */
  6.   {
  7.     if(p->prior->data==cur_e)
  8.     {
  9.       *next_e=p->data;
  10.       return TRUE;
  11.     }
  12.     p=p->next;
  13.   }
  14.   return FALSE;
  15. }

  1. DuLinkList GetElemP(DuLinkList L,int i) /* 另加 */
  2. { /* 在双向链表L中返回第i个元素的地址。i为0，返回头结点的地址。若第i个元素不存在，*/
  3.   /* 返回NULL */
  4.   int j;
  5.   DuLinkList p=L; /* p指向头结点 */
  6.   if(i<0||i>ListLength(L)) /* i值不合法 */
  7.     return NULL;
  8.   for(j=1;j<=i;j++)
  9.     p=p->next;
  10.   return p;
  11. }

  1. Status ListInsert(DuLinkList L,int i,ElemType e)
  2. { /* 在带头结点的双链循环线性表L中第i个位置之前插入元素e，i的合法值为1≤i≤表长+1 */
  3.   /* 改进算法2.18，否则无法在第表长+1个结点之前插入元素 */
  4.   DuLinkList p,s;
  5.   if(i<1||i>ListLength(L)+1) /* i值不合法 */
  6.     return ERROR;
  7.   p=GetElemP(L,i-1); /* 在L中确定第i个元素前驱的位置指针p */
  8.   if(!p) /* p=NULL,即第i个元素的前驱不存在(设头结点为第1个元素的前驱) */
  9.     return ERROR;
  10.   s=(DuLinkList)malloc(sizeof(DuLNode));
  11.   if(!s)
  12.     return OVERFLOW;
  13.   s->data=e;
  14.   s->prior=p; /* 在第i-1个元素之后插入 */
  15.   s->next=p->next;
  16.   p->next->prior=s;
  17.   p->next=s;
  18.   return OK;
  19. }

  1. Status ListDelete(DuLinkList L,int i,ElemType *e)
  2. { /* 删除带头结点的双链循环线性表L的第i个元素，i的合法值为1≤i≤表长 */
  3.   DuLinkList p;
  4.   if(i<1) /* i值不合法 */
  5.     return ERROR;
  6.   p=GetElemP(L,i);  /* 在L中确定第i个元素的位置指针p */
  7.   if(!p) /* p=NULL,即第i个元素不存在 */
  8.     return ERROR;
  9.   *e=p->data;
  10.   p->prior->next=p->next;//？？？没有考虑链表头？链表尾？
  11.   p->next->prior=p->prior;
  12.   free(p);
  13.   return OK;
  14. }

  1. void ListTraverse(DuLinkList L,void(*visit)(ElemType))
  2. { /* 由双链循环线性表L的头结点出发，正序对每个数据元素调用函数visit() */
  3.   DuLinkList p=L->next; /* p指向头结点 */
  4.   while(p!=L)
  5.   {
  6.     visit(p->data);
  7.     p=p->next;
  8.   }
  9.   printf("\n");
  10. }

  1. void ListTraverseBack(DuLinkList L,void(*visit)(ElemType))
  2. { /* 由双链循环线性表L的头结点出发，逆序对每个数据元素调用函数visit()。另加 */
  3.   DuLinkList p=L->prior; /* p指向尾结点 */
  4.   while(p!=L)
  5.   {
  6.     visit(p->data);
  7.     p=p->prior;
  8.   }
  9.   printf("\n");
  10. }



声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号