线性表实现——单链表

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <time.h>
  4
  5 #define OK 1
  6 #define ERROR 0
  7 typedef int Status;
  8 typedef int ElemType;
  9
 10 typedef struct Node
 11 {
 12     ElemType data;
 13     struct Node* next;
 14 }Node;
 15
 16 typedef struct Node* LinkList;
 17
 18 Status InitList(LinkList* L)  //初始化操作,建立一个空的线性表.想把头指针里面的值改掉,所以传个头指针的地址
 19 {
 20     *L = (LinkList)malloc(sizeof(Node));
 21     if (!(*L))
 22         return ERROR;
 23     (*L)->next = NULL;
 24     return OK;
 25 }
 26 Status ListEmpty(LinkList L)  //若线性表为空,返回true,否则返回false
 27 {
 28     if (L->next == NULL)
 29         return OK;
 30     return ERROR;
 31 }
 32 Status ClearList(LinkList* L) //清空线性表
 33 {
 34     LinkList p = (*L)->next;
 35     LinkList q;
 36     while(p!= NULL)
 37     {
 38         q = p;
 39         p = p->next;
 40         free(q);
 41     }
 42     (*L)->next = NULL;
 43     return OK;
 44 }
 45 Status GetElem(LinkList L,int  i,ElemType *e)  //查找线性表中的第i个位置的元素值,并赋值给e
 46 {
 47     int j = 0;
 48     while (L && j < i)
 49     {
 50         L = L->next;
 51         j++;
 52     }
 53     if (!L || j > i)
 54         return ERROR;
 55     *e = L->data;
 56     return OK;
 57 }
 58 Status LocateElem(LinkList L, ElemType e) //查找线性表L中与给定值e相等的元素,如果查找成功,则返回第一个相同的元素在L中的下标;否则,返回0表示失败
 59 {
 60     int i=1;
 61     LinkList p = L->next;
 62     while (p != NULL && p->data != e)
 63     {
 64         p = p->next;
 65         i++;
 66     }
 67     if (!p)
 68         return ERROR;
 69     return i;
 70 }
 71 Status ListInsert(LinkList* L, int i, ElemType e)  //在线性表L的第i个位置插入元素e
 72 {
 73     LinkList p, q;
 74     p = *L;
 75     int j = 1;
 76     while (p && j<i)    //尾部插入时,p指向最后一个值,而j=i-1
 77     {
 78         p = p->next;
 79         j++;
 80     }
 81     if (!p || j > i)
 82         return ERROR;
 83
 84     q = (LinkList)malloc(sizeof(Node));
 85     q->data = e;
 86     q->next = p->next;
 87     p->next = q;
 88
 89     return ERROR;
 90 }
 91 Status ListDelete(LinkList*L, int i, ElemType* e) //删除线性表L中第i个位置元素,并用e返回其值
 92 {
 93     LinkList p, q;
 94     p = *L;
 95     int j = 1;
 96     //while (p && j<i)
 97     while (p->next && j<i)
 98     {
 99         p = p->next;
100         j++;
101     }
102     //if (!p || j > i)
103     if (!(p->next) || j > i)
104         return ERROR;
105     q = p->next;
106     *e = q->data;
107     p->next = q->next;
108     free(q);
109     return OK;
110 }
111 Status CreateListHead(LinkList *L, int n)
112 {
113     LinkList p;
114     int i;
115     (*L) = (LinkList)malloc(sizeof(Node));
116     (*L)->next = NULL;
117     for (i = 0; i < n; i++)
118     {
119         p = (LinkList)malloc(sizeof(Node));
120         p->data = i;
121         p->next = (*L)->next;
122         (*L)->next = p;
123     }
124     return OK;
125 }
126 Status CreateListTail(LinkList *L, int n)
127 {
128     LinkList p;
129     int i;
130     (*L) = (LinkList)malloc(sizeof(Node));
131     //(*L)->next = NULL;
132     LinkList q = (*L);
133     for (i = 0; i < n; i++)
134     {
135         p = (LinkList)malloc(sizeof(Node));
136         p->data = i+10;
137         q->next = p;
138         q = p;
139     }
140     q->next = NULL;
141     return OK;
142 }
143 Status visit(ElemType n)
144 {
145     printf("-> %d  ", n);
146     return OK;
147 }
148 Status ListTraverse(LinkList L)
149 {
150     LinkList p = L->next;
151     while (p != NULL)
152     {
153         visit( p->data);
154         p = p->next;
155     }
156     return OK;
157 }
158
159 int ListLength(LinkList L)  //返回线性表L的长度
160 {
161     int i = 0;
162     LinkList p = L->next;
163     while (p != NULL)
164     {
165         i++;
166         p = p->next;
167     }
168     return i;
169 }
170
171 int main()
172 {
173     LinkList L;
174     Status i,j;
175     char opp=‘-1‘;
176     ElemType e;
177     int pos = 1;
178     int k=0;
179
180     i = InitList(&L);
181     printf("链表L初始化完毕,ListLength(L)=%d\n\n", ListLength(L));
182
183     printf("\n1.遍历操作 \n2.插入操作  \n3.删除操作 \n4.获取结点数据\n5.查找某个数是否在链表中 \n6.头插法创建链表 \n7.尾插法创建链表 \n8.置空链表 \n0.退出 \n请选择你的操作:\n");
184
185     while (opp != ‘0‘) {
186         scanf_s("%c", &opp);
187         switch (opp) {
188         case ‘1‘:
189                 ListTraverse(L);
190                 printf("\n");
191                 break;
192
193         case ‘2‘:
194                 srand((unsigned)time(NULL));
195                 for (j = 1; j <= 10; j++)
196                 {
197                         i = ListInsert(&L, 1, rand() % 100);
198                 }
199                 printf("在L的表头依次插入10个随机数后:");
200                 ListTraverse(L);
201                 printf("\n");
202                 printf("链表L创建完毕,ListLength(L)=%d\n\n", ListLength(L));
203                 break;
204         case ‘3‘:
205                 printf("要删除第几个元素?");
206                 scanf_s("%d", &pos);
207                 ListDelete(&L, pos, &e);
208                 printf("删除第%d个元素成功,现在链表为:\n", pos);
209                 ListTraverse(L);
210                 printf("\n");
211                 break;
212
213         case ‘4‘:
214                 printf("你需要获取第几个元素?");
215                 scanf_s("%d", &pos);
216                 GetElem(L, pos, &e);
217                 printf("第%d个元素的值为:%d\n", pos, e);
218                 printf("\n");
219                 break;
220         case ‘5‘:
221                 printf("输入你需要查找的数:");
222                 scanf_s("%d", &pos);
223                 k = LocateElem(L, pos);
224                 if (k)
225                     printf("第%d个元素的值为%d\n", k, pos);
226                 else
227                     printf("没有值为%d的元素\n", pos);
228                 printf("\n");
229                 break;
230         case ‘6‘:
231                 CreateListHead(&L, 10);
232                 printf("整体创建L的元素(头插法):\n");
233                 ListTraverse(L);
234                 printf("\n");
235                 break;
236
237         case ‘7‘:
238                 CreateListTail(&L, 10);
239                 printf("整体创建L的元素(尾插法):\n");
240                 ListTraverse(L);
241                 printf("\n");
242                 break;
243
244         case ‘8‘:
245                 i = ClearList(&L);
246                 printf("\n清空L后:ListLength(L)=%d\n", ListLength(L));
247                 ListTraverse(L);
248                 printf("\n");
249                 break;
250
251         case ‘0‘:
252                 exit(0);
253         }
254     }
255 }
时间: 2024-12-25 01:09:45

线性表实现——单链表的相关文章

续上文----线性表之单链表(C实现)

本文绪上文线性表之顺序表(C实现) 本文将继续使用单链表实现线性表 的另外一种存储结构.这种使用 链表实现的存储结构在内存中是 不连续的. C实现代码如下: #include<stdio.h> typedef struct node { int data; struct node *next; }Node; //链表的初始化 Node* InitList(int number) { int i; Node *pHead=(Node *)malloc(sizeof(Node)); Node *T

[大话数据结构]线性表之单链表结构和顺序存储结构

线性表定义: 零个或者多个数据元素的有限序列.元素之间是有顺序的,如果元素存在多个,则第一个元素无前驱,最后一个元素无后继.其他每个元素都有且只有一个前驱和后继.并且数据元素的类型要相同. 线性表的抽象数据类型: ADT 线性表(List) Data 线性表的数据对象集合为{a1,a2,...,an},每个元素的类型均为DataType. 其中,除第一个元素a1外,每一个元素有且只有一个直接前驱元素,除了最后一个元素an外,每一个元素有且只有一个直接后继元素. 数据元素之间的关系是一对一的关系.

Java数据结构-线性表之单链表LinkedList

线性表的链式存储结构,也称之为链式表,链表:链表的存储单元可以连续也可以不连续. 链表中的节点包含数据域和指针域,数据域为存储数据元素信息的域,指针域为存储直接后继位置(一般称为指针)的域. 注意一个头结点和头指针的区别: 头指针: 指向链表的第一个节点的指针,若链表有头结点,则是指向头结点的指针: 头指针具有标识作用,所以常用头指针作为链表的名字: 不论链表是否为空,头指针都不为空: 是链表的必要元素. 头结点: 头结点是为了操作的统一和方便而设立的,放在第一个元素节点的前面,其数据域一般无意

数据结构:线性表之单链表

线性表(亦作顺序表)是最基本.最简单.也是最常用的一种数据结构.线性表中数据元素之间的关系是一对一的关系,即除了第一个和最后一个数据元素之外,其它数据元素都是首尾相接的.线性表有两种存储结构: ①顺序存储结构,即存储单元在一段连续的地址上存储,常见的数组就是顺序存储结构的线性表: ②链式存储结构,即存储单元在不连续的地址上存储.因为其不连续性,除了要存数据元素信息(数据域)外,还要存储它后继元素(结点)的地址(指针域,链).学习链式结构最好将结点结构牢记于心,如下图: 链表的每个结点只含有一个指

【Java】 大话数据结构(2) 线性表之单链表

本文根据<大话数据结构>一书,实现了Java版的单链表. 书中的线性表抽象数据类型定义如下(第45页): 实现程序: package LinkList; /** * 说明: * 1.<大话数据结构>中没有线性表的长度,但提到可以存储于头节点的数据域中. * 本程序的线性表长度存放于count变量中,线性表长度可以使程序比较方便. * 2.程序中,第i个位置代表第i个结点,头结点属于第0个结点 * 3.因为链表为泛型,整表创建采用整型(随机整数做元素),所以有出现一些类型转换 * 4

数据结构学习总结(2) 线性表之单链表

一,回忆链表 链表,别名链式存储结构或单链表,用于存储逻辑关系为 "一对一" 的数据.与顺序表不同,链表不限制数据的物理存储状态,换句话说,使用链表存储的数据元素,其物理存储位置是随机的. 例如,使用链表存储 {1,2,3},数据的物理存储状态如图 1 所示: 图 1 链表随机存储数据 我们看到,图 1 根本无法体现出各数据之间的逻辑关系.对此,链表的解决方案是,每个数据元素在存储时都配备一个指针,用于指向自己的直接后继元素.如图 2 所示: 图 2 各数据元素配备指针 像图 2 这样

线性表的单链表的定义、初始化等操作

#include <stdio.h> #include <stdlib.h> #define OK 1 #define ERR 0 #define MAXSIZE 100 typedef int ElemType; //定义 typedef struct Node { ElemType data; struct Node *next; }Node,*LinkedList; //初始化 LinkedList LinkedListInit() { Node *L; L = (Node

线性表之单链表学习小结(初学数据结构必看)

花了好几个小时,详细规划出了整个过程,包括所有基本操作...有什么疑问请下方留言 #include<iostream> using namespace std; #define ElemType char #define ERROR 0 #define OK 1 typedef struct Node { ElemType data; struct Node *next; }Node,*LinkList; void init_linklist(LinkList L)/*对单链表进行初始化*/

线性表之单链表实现一元多项式相加

一元多项式定义: 设a0,a1,a2,-,an-1,an都是数域F中的数(注:1,2,--,n-1,n均为a的下角标),n是非负整数,那么表达式 anx^n +an-1x^(n-1)+-+a2x^2 +a1x + a0(an≠0) (1) 叫做数域F上一个文字x的多项式或一元多项式.在多项式(1)中,a0叫做零次多项式或常数项,a1x叫做一次项,一般,aix叫做i次项,ai叫做i次项的系数.一元多项式用符号f(x),g(x),-来表示. 说一下思路,利用带有两个数据元素的链表实现加法运算,数据域