线性表的链式存储实现(带头结点)

简介: 线性表的链式存储实现(带头结点)

LinkedList.h

 1 #ifndef LINKLIST_H_INCLUDE
 2 #define LINKLIST_H_INCLUDE
 3 
 4 #include <stdio.h>
 5 #include <stdlib.h>
 6 #include <stdbool.h>
 7 
 8 #define ERROR -1
 9 
10 typedef int ElementType;
11 
12 typedef struct LNode* PtrToNode;
13 struct LNode{
14     ElementType Data;
15     PtrToNode Next;
16 };
17 
18 typedef PtrToNode Position;        //这里的位置某个结点的结点指针
19 typedef PtrToNode List;
20 
21 
22 List MakeEmpty();
23 
24 
25 //链表长度
26 int Length(List L);
27 
28 //根据位序查找元素
29 ElementType FindKth(List L, int K);
30 
31 //根据元素查找相应的结点
32 Position Find(List L, ElementType X);
33 
34 //在指定位置之后插入元素
35 List Insert(List L, ElementType X, int i);
36 
37 bool Delete(List L, int i);
38 
39 void printList(List L);
40 
41 
42 
43 
44 #endif

LinkedList.c

  1 #include "LinkedList.h"
  2 
  3 List MakeEmpty()
  4 {
  5     List L = (List)malloc(sizeof(struct LNode));
  6     L->Next = NULL;
  7     L->Data = 0;
  8     return L;
  9 }
 10 
 11 int Length(List L)
 12 {
 13     int cnt = 0;
 14     List p = L->Next;        //当前p指向第一个结点
 15     while (p)
 16     {
 17         cnt++;
 18         p = p->Next;
 19 
 20     }
 21     return cnt;
 22 
 23 }
 24 
 25 ElementType FindKth(List L, int K)
 26 {
 27     Position p = L->Next;
 28     int cnt = 1;
 29     while (p && cnt < K)
 30     {
 31         p = p->Next;
 32         cnt++;
 33     }
 34     if ((cnt == K) && p)
 35         return p->Data;
 36     else
 37         return ERROR;
 38 }
 39 
 40 Position Find(List L, ElementType X)
 41 {
 42     Position p = L -> Next;
 43     while (p && p->Data != X)
 44         p = p->Next;
 45     if (p)
 46         return p;
 47     else
 48         return NULL;
 49 }
 50 
 51 List Insert(List L, ElementType X, int i)
 52 {
 53     Position tmp, pre;
 54     tmp = (Position)malloc(sizeof(struct LNode));
 55 
 56     int cnt = 0;
 57     pre = L;
 58     while (pre && cnt < i - 1)
 59     {
 60         pre = pre->Next;
 61         cnt++;
 62     }
 63     if (pre == NULL || cnt != i - 1)        //如果所招结点不再L中
 64     {
 65         printf("Insert position parameter error!\n");
 66         free(tmp);
 67         return L;
 68     }
 69     else
 70     {
 71         tmp->Data = X;
 72         tmp->Next = pre->Next;
 73         pre->Next = tmp;
 74         return L;
 75     }
 76 
 77 }
 78 
 79 bool Delete(List L, int i)
 80 {
 81     Position tmp, pre;
 82     int cnt = 0;
 83     pre = L;
 84 
 85 
 86     while (pre && cnt < i - 1)
 87     {
 88         pre = pre->Next;
 89         cnt++;
 90     }
 91     if (pre == NULL || cnt != i - 1 || pre->Next == NULL)        //i出错或链表为空
 92     {
 93         printf("Delete position parameter error!\n");
 94         return false;
 95     }
 96     else
 97     {
 98         tmp = pre->Next;
 99         pre->Next = tmp->Next;
100         free(tmp);
101         return true;
102     }
103 
104 
105 }
106 
107 void printList(List L)
108 {
109     Position p;
110     p = L -> Next;
111     while (p)
112     {
113         printf("%d ", p->Data);
114         p = p->Next;
115     }
116     printf("\n");
117     return;
118 }


相关文章
|
5月前
|
存储 算法 C语言
线性表,双向链表,静态链表,循环链表(约瑟夫环)(上)
线性表,双向链表,静态链表,循环链表(约瑟夫环)
69 5
|
12月前
|
存储 算法 索引
线性表的顺序存储和链式存储
线性表的顺序存储和链式存储
|
6天前
|
存储 Java
java数据结构,线性表链式存储(单链表)的实现
文章讲解了单链表的基本概念和Java实现,包括头指针、尾节点和节点结构。提供了实现代码,包括数据结构、接口定义和具体实现类。通过测试代码演示了单链表的基本操作,如添加、删除、更新和查找元素,并总结了操作的时间复杂度。
java数据结构,线性表链式存储(单链表)的实现
|
5月前
|
存储 C语言
线性表,双向链表,静态链表,循环链表(约瑟夫环)(下)
线性表,双向链表,静态链表,循环链表(约瑟夫环)
60 6
|
存储
线性表的链式存储结构
线性表的链式存储结构
|
存储 算法 C++
线性表和链表
线性表和链表
116 0
|
存储
线性表的链式存储——链表
线性表的链式存储——链表
187 0
|
存储 C++
线性表的顺序存储——顺序表
线性表的顺序存储——顺序表
161 2
线性表的顺序存储——顺序表
|
存储 API 索引
链表——单链表
单向链表是链表的一种,它由多个结点组成,每个结点都由一个数据域和一个指针域组成,数据域用来存储数据,指针域用来指向其后继结点。链表的头结点的数据域不存储数据,指针域指向第一个真正存储数据的结点。
87 0
链表——单链表
线性表的链式存储实现(不带头结点)
线性表的链式存储实现(不带头结点)