数据结构学习 线性表 链表

一、线性表

定义;有同类型数据元素构成有序序列的线性结构

基本操作

1. typedef int Position;
2. typedef struct LNode *List;
3. struct LNode {
4.     ElementType Data[MAXSIZE];
5.     Position Last;
6. };
7.  
8. /* 初始化 */
9. List MakeEmpty()
10. {
11.     List L;
12.  
13.     L = (List)malloc(sizeof(struct LNode));
14.     L->Last = -1;
15.  
16.     return L;
17. }
18.  
19. /* 查找 */
20. #define ERROR -1
21.  
22. Position Find( List L, ElementType X )
23. {
24.     Position i = 0;
25.  
26.     while( i <= L->Last && L->Data[i]!= X )
27.         i++;
28.     if ( i > L->Last )  return ERROR; /* 如果没找到，返回错误信息 */
29.     else  return i;  /* 找到后返回的是存储位置 */
30. }
31.  
32. /* 插入 */
33. /*注意:在插入位置参数P上与课程视频有所不同，课程视频中i是序列位序（从1开始），这里P是存储下标位置（从0开始），两者差1*/
34. bool Insert( List L, ElementType X, Position P ) 
35. { /* 在L的指定位置P前插入一个新元素X */
36.     Position i;
37.  
38.     if ( L->Last == MAXSIZE-1) {
39.         /* 表空间已满，不能插入 */
40.         printf("表满"); 
41.         return false; 
42.     }  
43.     if ( P<0 || P>L->Last+1 ) { /* 检查插入位置的合法性 */
44.         printf("位置不合法");
45.         return false; 
46.     } 
47.     for( i=L->Last; i>=P; i-- )
48.         L->Data[i+1] = L->Data[i]; /* 将位置P及以后的元素顺序向后移动 */
49.     L->Data[P] = X;  /* 新元素插入 */
50.     L->Last++;       /* Last仍指向最后元素 */
51.     return true; 
52. } 
53.  
54. /* 删除 */
55. /*注意:在删除位置参数P上与课程视频有所不同，课程视频中i是序列位序（从1开始），这里P是存储下标位置（从0开始），两者差1*/
56. bool Delete( List L, Position P )
57. { /* 从L中删除指定位置P的元素 */
58.     Position i;
59.  
60.     if( P<0 || P>L->Last ) { /* 检查空表及删除位置的合法性 */
61.         printf("位置%d不存在元素", P ); 
62.         return false; 
63.     }
64.     for( i=P+1; i<=L->Last; i++ )
65.         L->Data[i-1] = L->Data[i]; /* 将位置P+1及以后的元素顺序向前移动 */
66.     L->Last--; /* Last仍指向最后元素 */
67.     return true;   
68. }

二、链表

链表的一些基本操作

1. typedef struct LNode *PtrToLNode;
2. struct LNode {
3.     ElementType Data;
4.     PtrToLNode Next;
5. };
6. typedef PtrToLNode Position;
7. typedef PtrToLNode List;
8.  
9. /* 查找 */
10. #define ERROR NULL
11.  
12. Position Find( List L, ElementType X )
13. {
14.     Position p = L; /* p指向L的第1个结点 */
15.  
16.     while ( p && p->Data!=X )
17.         p = p->Next;
18.  
19.     /* 下列语句可以用 return p; 替换 */
20.     if ( p )
21.         return p;
22.     else
23.         return ERROR;
24. }
25.  
26. /* 带头结点的插入 */
27. /*注意:在插入位置参数P上与课程视频有所不同，课程视频中i是序列位序（从1开始），这里P是链表结点指针，在P之前插入新结点 */
28. bool Insert( List L, ElementType X, Position P )
29. { /* 这里默认L有头结点 */
30.     Position tmp, pre;
31.  
32.     /* 查找P的前一个结点 */        
33.     for ( pre=L; pre&&pre->Next!=P; pre=pre->Next ) ;            
34.     if ( pre==NULL ) { /* P所指的结点不在L中 */
35.         printf("插入位置参数错误\n");
36.         return false;
37.     }
38.     else { /* 找到了P的前一个结点pre */
39.         /* 在P前插入新结点 */
40.         tmp = (Position)malloc(sizeof(struct LNode)); /* 申请、填装结点 */
41.         tmp->Data = X; 
42.         tmp->Next = P;
43.         pre->Next = tmp;
44.         return true;
45.     }
46. }
47.  
48. /* 带头结点的删除 */
49. /*注意:在删除位置参数P上与课程视频有所不同，课程视频中i是序列位序（从1开始），这里P是拟删除结点指针 */
50. bool Delete( List L, Position P )
51. { /* 这里默认L有头结点 */
52.     Position tmp, pre;
53.  
54.     /* 查找P的前一个结点 */        
55.     for ( pre=L; pre&&pre->Next!=P; pre=pre->Next ) ;            
56.     if ( pre==NULL || P==NULL) { /* P所指的结点不在L中 */
57.         printf("删除位置参数错误\n");
58.         return false;
59.     }
60.     else { /* 找到了P的前一个结点pre */
61.         /* 将P位置的结点删除 */
62.         pre->Next = P->Next;
63.         free(P);
64.         return true;
65.     }
66. }