Chapter 3(线性表)

其他 2018-07-17 22:39:46 阅读次数: 0


1.单链表 
//单链表代码，手打纯手工


//***********************************link.h***********************************
#ifndef LINK_H
#define LINK_H


#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>


typedef int datatype;

typedef struct link
{
	datatype data;
	struct link *next;


}Node,*Link;


//创建单链表
Link linkCreate();


//获得链表长度
size_t length(Link link);

//判断链表是否为空
bool isEmpty(Link link);

//获得第i个前的地址
Node *addressFront(Link link,size_t i);

//获取第i个节点的值
datatype getElement(Link link,size_t i);


//查找元素num是否存在
bool isExist(Link link,datatype num);

//插入元素
bool insert(Link link,size_t i,datatype num);

//在链表头插入元素
bool pushFront(Link link,datatype num);

//在链表尾插入元素
bool pushBack(Link link,datatype num);

//删除第i个元素
bool deleteI(Link link,size_t i);


//删除包含元素num的第一个节点
bool deleteNum(Link link,datatype num);

//遍历打印整个链表
void travel(Link link);

//清空链表
bool clear(Link link);

//销毁链表
bool destroy(Link link);

//链表翻转
bool reverse(Link link);

//链表指定长度反转
void reverseN(Link link,int n);




#endif //LINK_H



//*************************link.c****************************************
#include "link.h"




//创建单链表头
Link linkCreate()
{
	Node *p = (Node *)malloc(sizeof(Node));
	p->next = NULL;
	return p;
}


//获得链表长度
size_t length(Link link)
{
	size_t count = 0;
	Node *node = link->next;
	while(node)
	{
		count++;
		node = node->next;
	}
	return count;
}

//判断链表是否为空
bool isEmpty(Link link)
{
	if(NULL == link->next)return true;
	return false;
}


//获得第i个前的地址，供内部使用
Node *addressFront(Link link,size_t i)
{
	if(NULL == link)return NULL;//头节点为空，返回NULL
	
	if(i > (length(link)+1))return NULL;//i越界,len+1是可取的，相当于最后加上这个数，i不能为0.返回于NULL

	if(isEmpty(link))return link;//当链表为空时，返回头节点地址

	Node *pre  = link; //保存前一个节点的地址
	Node *curr = link->next;
	for(size_t j = 1;j < i;j++)
	{
		pre  = curr;
		curr = curr->next; 
	}

	return pre;
}

//获取第i个节点的值
datatype getElement(Link link,size_t i)
{
	Node *node = addressFront(link,i);
	return node->next->data;
}


//查找元素num是否存在
bool isExist(Link link,datatype num)
{
	if(NULL == link)return false;

	Node *node = link->next;
	
	while(node)
	{
		if(num == node->data)return true;
		node = node->next;
	}
	return false;
}

//插入元素
bool insert(Link link,size_t i,datatype num)
{
	if(NULL == link)return false;
	if(i > (length(link)+1)||i <= 0)return false;


	Node *pre  = addressFront(link,i);//获得第i-1个节点的地址
	Node *node = (Node *)malloc(sizeof(Node));//申请内存存放新节点
	Node *save = pre->next; //将原来的第i个节点的地址保存在save中
	
	pre->next = node; //将原来的第i-1个节点指向新节点

	node->data = num; //为新节点的数据域赋值
	node->next = save;//将新节点指向原来的第i个节点
	
	return true;
}

//在链表头插入元素
bool pushFront(Link link,datatype num)
{
	return insert(link,1,num);
}

//在链表尾插入元素
bool pushBack(Link link,datatype num)
{
	return insert(link,length(link)+1,num);
}

//删除第i个元素
bool deleteI(Link link,size_t i)
{
	if(NULL == link)return false;
	if(i>length(link) || i<=0)return false;


	Node *pre = addressFront(link,i);
	Node *node= pre->next;

	pre->next = node->next;
	free(node);
	node = NULL;
	return true;
}


//删除包含元素num的第一个节点
bool deleteNum(Link link,datatype num)
{
	if(NULL == link)return false;
	
	Node *pre  = link;
	Node *curr = link->next;
	while(curr)
	{
		if(num == curr->data)
		{
			pre->next = curr->next;
			free(curr);
			curr = NULL;
			return true;
		}
		pre = curr;
		curr= curr->next;
	}

	return false;
}

//遍历打印整个链表
void travel(Link link)
{
	if(NULL == link)return;

	Node *node = link->next;
	while(node)
	{
		printf("%d ",node->data);
		node = node->next;
	}
	printf("\n");
}

//清空链表
bool clear(Link link)
{
	if(NULL == link)return false;

	Node *node = link->next;//从头节点开始释放
	
	while(node)
	{
		Node *temp = node->next;//保存下一个节点的地址
		free(node);//释放当前节点
		node = temp;//将下一个节点地址赋给node
	}
	link->next = NULL;//头节点指向空

	return true;
}

//销毁链表
bool destroy(Link link)
{
	if(NULL == link)return false;

	clear(link);
	free(link);
	link = NULL;
	return true;
}


//链表翻转
bool reverse(Link link)
{
	if(NULL == link)return false;

	Node *pre = link->next;
	Node *curr= pre->next;

	while(curr)
	{
		Node *temp = curr->next;//保存当前节点的下一个节点地址
		curr->next = pre;//将当前节点指向上一个节点

		pre = curr;//将上一个节点指向当前节点
		curr= temp;//将当前节点指向喜爱一个节点
	}
	
	link->next->next = NULL;//将原来第一个节点指向空
	link->next = pre;//将头节点指向原来的最后一个节点
	return true;
}


//链表指定长度反转工具
void reverseTool(Node *prev,Node *curr,int num)
{
	if(NULL == curr)return;

	Node *prevNode = curr;
	Node *currNode = curr->next;

	int count = 1;
	while(currNode)
	{
		Node *nextNode = currNode->next;
		currNode->next = prevNode;
		prevNode = currNode;
		currNode = nextNode;
		count++;

		if(num == count)
		{
			Node *temp = prev->next;
			prev->next->next =currNode;
			prev->next = prevNode;
			reverseTool(temp,currNode,num);
			return;
		}
	}

	prev->next->next = currNode;
	prev->next = prevNode;
}

//链表指定长度反转
void reverseN(Link link,int n)
{	
	Node *node = link->next;
	reverseTool(link,node,n);
}



//************************linkTest.c*****************************************


#include "link.h"

int main(int argc,char *argv[])
{
	Link head = linkCreate();
	travel(head);
	insert(head,1,77);
	travel(head);
	insert(head,1,777);
	travel(head);
	insert(head,3,7777);
	travel(head);
	printf("length = %d\n",length(head));

	pushFront(head,52);
	travel(head);
	printf("length = %d\n",length(head));


	pushBack(head,00);
	travel(head);
	printf("length = %d\n",length(head));

	//deleteNum(head,777);
	//deleteI(head,2);
	travel(head);
	printf("length = %d\n",length(head));
	

	printf("-----\n");
	reverseN(head,2);
	//clear(head);
	travel(head);
	return 0;
}
377
 
1 
//单链表代码，手打纯手工
2
3
4 
//***********************************link.h***********************************
5 
#ifndef LINK_H
6 
#define LINK_H
7
8
9 
#include <stdbool.h>
10 
#include <stdio.h>
11 
#include <stdlib.h>
12
13
14 
typedef int datatype;
15
16 
typedef struct link
17 
{
18 
    datatype data;
19 
    struct link *next;
20
21
22 
}Node,*Link;
23
24
25 
//创建单链表
26 
Link linkCreate();
27
28
29 
//获得链表长度
30 
size_t length(Link link);
31
32 
//判断链表是否为空
33 
bool isEmpty(Link link);
34
35 
//获得第i个前的地址
36 
Node *addressFront(Link link,size_t i);
37
38 
//获取第i个节点的值
39 
datatype getElement(Link link,size_t i);
40
41
42 
//查找元素num是否存在
43 
bool isExist(Link link,datatype num);
44
45 
//插入元素
46 
bool insert(Link link,size_t i,datatype num);
47
48 
//在链表头插入元素
49 
bool pushFront(Link link,datatype num);
50
51 
//在链表尾插入元素
52 
bool pushBack(Link link,datatype num);
53
54 
//删除第i个元素
55 
bool deleteI(Link link,size_t i);
56
57
58 
//删除包含元素num的第一个节点
59 
bool deleteNum(Link link,datatype num);
60
61 
//遍历打印整个链表
62 
void travel(Link link);
63
64 
//清空链表
65 
bool clear(Link link);
66
67 
//销毁链表
68 
bool destroy(Link link);
69
70 
//链表翻转
71 
bool reverse(Link link);
72
73 
//链表指定长度反转
74 
void reverseN(Link link,int n);
75
76
77
78
79 
#endif //LINK_H
80
81
82
83 
//*************************link.c****************************************
84 
#include "link.h"
85
86
87
88
89 
//创建单链表头
90 
Link linkCreate()
91 
{
92 
    Node *p = (Node *)malloc(sizeof(Node));
93 
    p->next = NULL;
94 
    return p;
95 
}
96
97
98 
//获得链表长度
99 
size_t length(Link link)
100 
{
101 
    size_t count = 0;
102 
    Node *node = link->next;
103 
    while(node)
104 
    {
105 
        count++;
106 
        node = node->next;
107 
    }
108 
    return count;
109 
}
110
111 
//判断链表是否为空
112 
bool isEmpty(Link link)
113 
{
114 
    if(NULL == link->next)return true;
115 
    return false;
116 
}
117
118
119 
//获得第i个前的地址，供内部使用
120 
Node *addressFront(Link link,size_t i)
121 
{
122 
    if(NULL == link)return NULL;//头节点为空，返回NULL
123
124 
    if(i > (length(link)+1))return NULL;//i越界,len+1是可取的，相当于最后加上这个数，i不能为0.返回于NULL
125
126 
    if(isEmpty(link))return link;//当链表为空时，返回头节点地址
127
128 
    Node *pre  = link; //保存前一个节点的地址
129 
    Node *curr = link->next;
130 
    for(size_t j = 1;j < i;j++)
131 
    {
132 
        pre  = curr;
133 
        curr = curr->next;
134 
    }
135
136 
    return pre;
137 
}
138
139 
//获取第i个节点的值
140 
datatype getElement(Link link,size_t i)
141 
{
142 
    Node *node = addressFront(link,i);
143 
    return node->next->data;
144 
}
145
146
147 
//查找元素num是否存在
148 
bool isExist(Link link,datatype num)
149 
{
150 
    if(NULL == link)return false;
151
152 
    Node *node = link->next;
153
154 
    while(node)
155 
    {
156 
        if(num == node->data)return true;
157 
        node = node->next;
158 
    }
159 
    return false;
160 
}
161
162 
//插入元素
163 
bool insert(Link link,size_t i,datatype num)
164 
{
165 
    if(NULL == link)return false;
166 
    if(i > (length(link)+1)||i <= 0)return false;
167
168
169 
    Node *pre  = addressFront(link,i);//获得第i-1个节点的地址
170 
    Node *node = (Node *)malloc(sizeof(Node));//申请内存存放新节点
171 
    Node *save = pre->next; //将原来的第i个节点的地址保存在save中
172
173 
    pre->next = node; //将原来的第i-1个节点指向新节点
174
175 
    node->data = num; //为新节点的数据域赋值
176 
    node->next = save;//将新节点指向原来的第i个节点
177
178 
    return true;
179 
}
180
181 
//在链表头插入元素
182 
bool pushFront(Link link,datatype num)
183 
{
184 
    return insert(link,1,num);
185 
}
186
187 
//在链表尾插入元素
188 
bool pushBack(Link link,datatype num)
189 
{
190 
    return insert(link,length(link)+1,num);
191 
}
192
193 
//删除第i个元素
194 
bool deleteI(Link link,size_t i)
195 
{
196 
    if(NULL == link)return false;
197 
    if(i>length(link) || i<=0)return false;
198
199
200 
    Node *pre = addressFront(link,i);
201 
    Node *node= pre->next;
202
203 
    pre->next = node->next;
204 
    free(node);
205 
    node = NULL;
206 
    return true;
207 
}
208
209
210 
//删除包含元素num的第一个节点
211 
bool deleteNum(Link link,datatype num)
212 
{
213 
    if(NULL == link)return false;
214
215 
    Node *pre  = link;
216 
    Node *curr = link->next;
217 
    while(curr)
218 
    {
219 
        if(num == curr->data)
220 
        {
221 
            pre->next = curr->next;
222 
            free(curr);
223 
            curr = NULL;
224 
            return true;
225 
        }
226 
        pre = curr;
227 
        curr= curr->next;
228 
    }
229
230 
    return false;
231 
}
232
233 
//遍历打印整个链表
234 
void travel(Link link)
235 
{
236 
    if(NULL == link)return;
237
238 
    Node *node = link->next;
239 
    while(node)
240 
    {
241 
        printf("%d ",node->data);
242 
        node = node->next;
243 
    }
244 
    printf("\n");
245 
}
246
247 
//清空链表
248 
bool clear(Link link)
249 
{
250 
    if(NULL == link)return false;
251
252 
    Node *node = link->next;//从头节点开始释放
253
254 
    while(node)
255 
    {
256 
        Node *temp = node->next;//保存下一个节点的地址
257 
        free(node);//释放当前节点
258 
        node = temp;//将下一个节点地址赋给node
259 
    }
260 
    link->next = NULL;//头节点指向空
261
262 
    return true;
263 
}
264
265 
//销毁链表
266 
bool destroy(Link link)
267 
{
268 
    if(NULL == link)return false;
269
270 
    clear(link);
271 
    free(link);
272 
    link = NULL;
273 
    return true;
274 
}
275
276
277 
//链表翻转
278 
bool reverse(Link link)
279 
{
280 
    if(NULL == link)return false;
281
282 
    Node *pre = link->next;
283 
    Node *curr= pre->next;
284
285 
    while(curr)
286 
    {
287 
        Node *temp = curr->next;//保存当前节点的下一个节点地址
288 
        curr->next = pre;//将当前节点指向上一个节点
289
290 
        pre = curr;//将上一个节点指向当前节点
291 
        curr= temp;//将当前节点指向喜爱一个节点
292 
    }
293
294 
    link->next->next = NULL;//将原来第一个节点指向空
295 
    link->next = pre;//将头节点指向原来的最后一个节点
296 
    return true;
297 
}
298
299
300 
//链表指定长度反转工具
301 
void reverseTool(Node *prev,Node *curr,int num)
302 
{
303 
    if(NULL == curr)return;
304
305 
    Node *prevNode = curr;
306 
    Node *currNode = curr->next;
307
308 
    int count = 1;
309 
    while(currNode)
310 
    {
311 
        Node *nextNode = currNode->next;
312 
        currNode->next = prevNode;
313 
        prevNode = currNode;
314 
        currNode = nextNode;
315 
        count++;
316
317 
        if(num == count)
318 
        {
319 
            Node *temp = prev->next;
320 
            prev->next->next =currNode;
321 
            prev->next = prevNode;
322 
            reverseTool(temp,currNode,num);
323 
            return;
324 
        }
325 
    }
326
327 
    prev->next->next = currNode;
328 
    prev->next = prevNode;
329 
}
330
331 
//链表指定长度反转
332 
void reverseN(Link link,int n)
333 
{
334 
    Node *node = link->next;
335 
    reverseTool(link,node,n);
336 
}
337
338
339
340 
//************************linkTest.c*****************************************
341
342
343 
#include "link.h"
344
345 
int main(int argc,char *argv[])
346 
{
347 
    Link head = linkCreate();
348 
    travel(head);
349 
    insert(head,1,77);
350 
    travel(head);
351 
    insert(head,1,777);
352 
    travel(head);
353 
    insert(head,3,7777);
354 
    travel(head);
355 
    printf("length = %d\n",length(head));
356
357 
    pushFront(head,52);
358 
    travel(head);
359 
    printf("length = %d\n",length(head));
360
361
362 
    pushBack(head,00);
363 
    travel(head);
364 
    printf("length = %d\n",length(head));
365
366 
    //deleteNum(head,777);
367 
    //deleteI(head,2);
368 
    travel(head);
369 
    printf("length = %d\n",length(head));
370
371
372 
    printf("-----\n");
373 
    reverseN(head,2);
374 
    //clear(head);
375 
    travel(head);
376 
    return 0;
377 
}

2.静态链表 
//静态链表代码，纯手打

//********************static_link.h***********************
#ifndef STATIC_LINK_H
#define STATIC_LINK_H

#include <stdio.h>
#include <stdbool.h>
#define MAXSIZE 1000

typedef int datatype;


typedef struct Static_linklist
{
	datatype data;
	int curr;
}Node,static_link[MAXSIZE];


//初始化静态链表
bool InitList(static_link link);



//获取链表长度
size_t length(static_link link);

//Malloc_SLL若备用链表非空，则返回分配的节点下标，否则返回0
int Malloc_SLL(static_link link);

//Free_SSL将下标为K的空闲节点回收到备用链表
void Free_SSL(static_link link,int k);

//插入元素
bool insert(static_link link,int i,datatype num);

//删除元素
bool Delete(static_link link,int i );

//判断链表是否为空
bool isEmpty(static_link link);

//获取第i个对象的值
datatype getElement(static_link link,int i);


//历遍整个链表
void travel(static_link link);

#endif //STATIC_LINK_H



//********************static_link.c***********************
#include "static_link.h"


//初始化静态链表
bool InitList(static_link link)
{
	if(NULL == link)return false;
	for(int i = 0;i < MAXSIZE-1;i++)
	{
		link[i].curr = i+1;
	}
	link[MAXSIZE-1].curr = 0;
	return true;
}



//获取链表长度
size_t length(static_link link)
{
	if(NULL == link)return false;

	size_t index = link[MAXSIZE-1].curr;
	size_t count = 0;
	
	while(index)
	{
		count++;
		index = link[index].curr;
	}

	return count;
}

//Malloc_SLL若备用链表非空，则返回分配的节点下标，否则返回0
int Malloc_SLL(static_link link)
{
	if(0 == link[0].curr)return 0;

	int result = link[0].curr;
	link[0].curr = link[link[0].curr].curr;
	return result;
}

//Free_SSL将下标为K的空闲节点回收到备用链表
void Free_SSL(static_link link,int k)
{
	link[k].curr = link[0].curr;
	link[0].curr = k;
}

//插入元素
bool insert(static_link link,int i,datatype num)
{
	if(i<1 || i > length(link)+1)return false; //当输入的i小于1或者比链表长度+1大，则非法。
	int index = Malloc_SLL(link);

	if(index)
	{
		link[index].data = num;
		
		int index_front = MAXSIZE-1;
		for(int j = 1;j < i;j++)
		{
			index_front = link[index_front].curr;
		}
		link[index].curr = link[index_front].curr;
		link[index_front].curr = index;
		return true;
	}
	return false;
}

//删除元素
bool Delete(static_link link,int i )
{
	if(i<1 || i > length(link))return false;
	size_t index = MAXSIZE-1;
	for(int j =1;j < i;j++)
	{
		index = link[index].curr;
	}
	size_t tmp = link[index].curr;
	link[index].curr = link[tmp].curr;
	Free_SSL(link,i);
	return true;
}

//判断链表是否为空
bool isEmpty(static_link link)
{
	return !link[MAXSIZE-1].curr;
}

//获取第i个对象的值
datatype getElement(static_link link,int i)
{
	if(i<1 || i>length(link))return ~(1<<(sizeof(datatype)*8-1))+1;//这里由于函数的返回值是数据类型，因此不能返回false来报告输入错误，因此后面取了这个数据类型的最大值+1输出表示输入下标不合法

	size_t index = link[MAXSIZE-1].curr;
	for(size_t j = 1;j < i;j++)
	{
		index = link[index].curr;
	}
	return link[index].data;
}

//历遍整个链表
void travel(static_link link)
{
	size_t index = link[MAXSIZE-1].curr;
	while(index)
	{
		printf("%d ",link[index].data);
		index = link[index].curr;
	}
	printf("\n");
}



//********************static_linkTest.c***********************
#include "static_link.h"





int main()

{

	Node arr[MAXSIZE];

	InitList(arr);

	

	printf("isEmpty: %d \n",isEmpty(arr));



	travel(arr);

	insert(arr,1,77);

	insert(arr,2,25);

	printf("isEmpty: %d \n",isEmpty(arr));

	travel(arr);

	//Delete(arr,2);

	//travel(arr);

	//printf("isEmpty: %d \n",isEmpty(arr));

	printf("arr[2]:%d \n",getElement(arr,2));

	printf("arr[3]:%d \n",getElement(arr,3));

	return 0;

}
220
 
1 
//静态链表代码，纯手打
2
3 
//********************static_link.h***********************
4 
#ifndef STATIC_LINK_H
5 
#define STATIC_LINK_H
6
7 
#include <stdio.h>
8 
#include <stdbool.h>
9 
#define MAXSIZE 1000
10
11 
typedef int datatype;
12
13
14 
typedef struct Static_linklist
15 
{
16 
    datatype data;
17 
    int curr;
18 
}Node,static_link[MAXSIZE];
19
20
21 
//初始化静态链表
22 
bool InitList(static_link link);
23
24
25
26 
//获取链表长度
27 
size_t length(static_link link);
28
29 
//Malloc_SLL若备用链表非空，则返回分配的节点下标，否则返回0
30 
int Malloc_SLL(static_link link);
31
32 
//Free_SSL将下标为K的空闲节点回收到备用链表
33 
void Free_SSL(static_link link,int k);
34
35 
//插入元素
36 
bool insert(static_link link,int i,datatype num);
37
38 
//删除元素
39 
bool Delete(static_link link,int i );
40
41 
//判断链表是否为空
42 
bool isEmpty(static_link link);
43
44 
//获取第i个对象的值
45 
datatype getElement(static_link link,int i);
46
47
48 
//历遍整个链表
49 
void travel(static_link link);
50
51 
#endif //STATIC_LINK_H
52
53
54
55 
//********************static_link.c***********************
56 
#include "static_link.h"
57
58
59 
//初始化静态链表
60 
bool InitList(static_link link)
61 
{
62 
    if(NULL == link)return false;
63 
    for(int i = 0;i < MAXSIZE-1;i++)
64 
    {
65 
        link[i].curr = i+1;
66 
    }
67 
    link[MAXSIZE-1].curr = 0;
68 
    return true;
69 
}
70
71
72
73 
//获取链表长度
74 
size_t length(static_link link)
75 
{
76 
    if(NULL == link)return false;
77
78 
    size_t index = link[MAXSIZE-1].curr;
79 
    size_t count = 0;
80
81 
    while(index)
82 
    {
83 
        count++;
84 
        index = link[index].curr;
85 
    }
86
87 
    return count;
88 
}
89
90 
//Malloc_SLL若备用链表非空，则返回分配的节点下标，否则返回0
91 
int Malloc_SLL(static_link link)
92 
{
93 
    if(0 == link[0].curr)return 0;
94
95 
    int result = link[0].curr;
96 
    link[0].curr = link[link[0].curr].curr;
97 
    return result;
98 
}
99
100 
//Free_SSL将下标为K的空闲节点回收到备用链表
101 
void Free_SSL(static_link link,int k)
102 
{
103 
    link[k].curr = link[0].curr;
104 
    link[0].curr = k;
105 
}
106
107 
//插入元素
108 
bool insert(static_link link,int i,datatype num)
109 
{
110 
    if(i<1 || i > length(link)+1)return false; //当输入的i小于1或者比链表长度+1大，则非法。
111 
    int index = Malloc_SLL(link);
112
113 
    if(index)
114 
    {
115 
        link[index].data = num;
116
117 
        int index_front = MAXSIZE-1;
118 
        for(int j = 1;j < i;j++)
119 
        {
120 
            index_front = link[index_front].curr;
121 
        }
122 
        link[index].curr = link[index_front].curr;
123 
        link[index_front].curr = index;
124 
        return true;
125 
    }
126 
    return false;
127 
}
128
129 
//删除元素
130 
bool Delete(static_link link,int i )
131 
{
132 
    if(i<1 || i > length(link))return false;
133 
    size_t index = MAXSIZE-1;
134 
    for(int j =1;j < i;j++)
135 
    {
136 
        index = link[index].curr;
137 
    }
138 
    size_t tmp = link[index].curr;
139 
    link[index].curr = link[tmp].curr;
140 
    Free_SSL(link,i);
141 
    return true;
142 
}
143
144 
//判断链表是否为空
145 
bool isEmpty(static_link link)
146 
{
147 
    return !link[MAXSIZE-1].curr;
148 
}
149
150 
//获取第i个对象的值
151 
datatype getElement(static_link link,int i)
152 
{
153 
    if(i<1 || i>length(link))return ~(1<<(sizeof(datatype)*8-1))+1;//这里由于函数的返回值是数据类型，因此不能返回false来报告输入错误，因此后面取了这个数据类型的最大值+1输出表示输入下标不合法
154
155 
    size_t index = link[MAXSIZE-1].curr;
156 
    for(size_t j = 1;j < i;j++)
157 
    {
158 
        index = link[index].curr;
159 
    }
160 
    return link[index].data;
161 
}
162
163 
//历遍整个链表
164 
void travel(static_link link)
165 
{
166 
    size_t index = link[MAXSIZE-1].curr;
167 
    while(index)
168 
    {
169 
        printf("%d ",link[index].data);
170 
        index = link[index].curr;
171 
    }
172 
    printf("\n");
173 
}
174
175
176
177 
//********************static_linkTest.c***********************
178 
#include "static_link.h"
179
180
181
182
183
184 
int main()
185
186 
{
187
188 
    Node arr[MAXSIZE];
189
190 
    InitList(arr);
191
192
193
194 
    printf("isEmpty: %d \n",isEmpty(arr));
195
196
197
198 
    travel(arr);
199
200 
    insert(arr,1,77);
201
202 
    insert(arr,2,25);
203
204 
    printf("isEmpty: %d \n",isEmpty(arr));
205
206 
    travel(arr);
207
208 
    //Delete(arr,2);
209
210 
    //travel(arr);
211
212 
    //printf("isEmpty: %d \n",isEmpty(arr));
213
214 
    printf("arr[2]:%d \n",getElement(arr,2));
215
216 
    printf("arr[3]:%d \n",getElement(arr,3));
217
218 
    return 0;
219
220 
}


3.循环链表 
//******************************circular_link.h**************************************
#ifndef CIRCULAR_LINK_H
#define CIRCULAR_LINK_H

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
typedef int datatype;

typedef struct circular_link
{
	datatype data;
	struct circular_link *next;
}Node,*Link;


//创建链表
Link create();

//获取链表长度
size_t length(Link link);

//获取第i-1个节点的地址，工具函数内部使用
Node *addressTool(Link link,size_t i);


//插入节点
bool insert(Link link,size_t i,datatype data);

//删除节点
bool Delete(Link link,size_t i);

//历遍节点
void travel(Link link);

//判断节点是否为空
bool isEmpty(Link link);

//获取第i个节点的数据
datatype getElement(Link link,size_t i);




#endif //CIRCULAR_LINK_H


//******************************circular_link.c**************************************
#include "circular_link.h"



//创建链表 创建失败返回NULL
Link create()
{
	Link link = (Link)malloc(sizeof(Node));
	link->next = link;
	return link;
}

//获取链表长度
size_t length(Link link)
{
	if(NULL==link || NULL==link->next)return false;


	Node *node = link->next;
	int count = 0;
	while(node != link)
	{
		count++;
		node = node->next;
	}

	return count;
}

//获取第i-1个节点的地址，工具函数内部使用
Node *addressTool(Link link,size_t i)
{
	Node *node = link;
	for(size_t j = 1;j < i;j++)
	{
		node = node->next;
	}
	return node;
}


//插入节点
bool insert(Link link,size_t i,datatype data)
{	
	if(i<1 || i > length(link)+1)return false;
	if(NULL == link)return false;

	Node *prev = addressTool(link,i);//获取第i-1个节点地址
	Node *curr = prev->next;//获取第i个节点地址
	
	Node *node = (Node *)malloc(sizeof(Node));//创建新节点	
	node->data = data;

	prev->next = node;
	node->next = curr;

	return true;
}

//删除节点
bool Delete(Link link,size_t i)
{
	if(i<1 || i>length(link))return false;
	if(NULL == link)return false;

	Node *prev = addressTool(link,i);
	Node *curr = prev->next;
	Node *temp = curr->next;

	prev->next = temp;
	free(curr);
	curr = NULL;
	return true;
}

//历遍节点
void travel(Link link)
{
	Node *node = link->next;
	while(node != link)
	{
		printf("%d ",node->data);
		node = node->next;
	}
	printf("\n");
}

//判断节点是否为空
bool isEmpty(Link link)
{
	return link->next == link;
}

//获取第i个节点的数据
datatype getElement(Link link,size_t i)
{
	if(i<1 || i > length(link) || NULL == link)return !(1<<(sizeof(datatype)-1))+1;

	Node *node = link->next;

	for(size_t j = 1;j < i;j++)
	{
		node = node->next;
	}
	return node->data;
}


//******************************circular_linkTest.c**************************************

#include "circular_link.h"





int main()

{

	Link head = create();

	printf("isEmpty: %d \n",isEmpty(head));

	printf("%d \n",length(head));

	travel(head);



	insert(head,1,77);

	travel(head);

	printf("isEmpty: %d \n",isEmpty(head));

	insert(head,1,52);

	insert(head,1,44);

	travel(head);

	printf("%d \n",length(head));



	printf("head:1:%d \n",getElement(head,1));

	printf("head:2:%d \n",getElement(head,2));

	printf("head:3:%d \n",getElement(head,3));

	

//	Delete(head,1);

//	travel(head);

//	Delete(head,1);

//	travel(head);

//	Delete(head,1);

//	travel(head);

	return 0;

}
x
 
1 
//******************************circular_link.h**************************************
2 
#ifndef CIRCULAR_LINK_H
3 
#define CIRCULAR_LINK_H
4
5 
#include <stdio.h>
6 
#include <stdbool.h>
7 
#include <stdlib.h>
8 
typedef int datatype;
9
10 
typedef struct circular_link
11 
{
12 
    datatype data;
13 
    struct circular_link *next;
14 
}Node,*Link;
15
16
17 
//创建链表
18 
Link create();
19
20 
//获取链表长度
21 
size_t length(Link link);
22
23 
//获取第i-1个节点的地址，工具函数内部使用
24 
Node *addressTool(Link link,size_t i);
25
26
27 
//插入节点
28 
bool insert(Link link,size_t i,datatype data);
29
30 
//删除节点
31 
bool Delete(Link link,size_t i);
32
33 
//历遍节点
34 
void travel(Link link);
35
36 
//判断节点是否为空
37 
bool isEmpty(Link link);
38
39 
//获取第i个节点的数据
40 
datatype getElement(Link link,size_t i);
41
42
43
44
45 
#endif //CIRCULAR_LINK_H
46
47
48 
//******************************circular_link.c**************************************
49 
#include "circular_link.h"
50
51
52
53 
//创建链表 创建失败返回NULL
54 
Link create()
55 
{
56 
    Link link = (Link)malloc(sizeof(Node));
57 
    link->next = link;
58 
    return link;
59 
}
60
61 
//获取链表长度
62 
size_t length(Link link)
63 
{
64 
    if(NULL==link || NULL==link->next)return false;
65
66
67 
    Node *node = link->next;
68 
    int count = 0;
69 
    while(node != link)
70 
    {
71 
        count++;
72 
        node = node->next;
73 
    }
74
75 
    return count;
76 
}
77
78 
//获取第i-1个节点的地址，工具函数内部使用
79 
Node *addressTool(Link link,size_t i)
80 
{
81 
    Node *node = link;
82 
    for(size_t j = 1;j < i;j++)
83 
    {
84 
        node = node->next;
85 
    }
86 
    return node;
87 
}
88
89
90 
//插入节点
91 
bool insert(Link link,size_t i,datatype data)
92 
{
93 
    if(i<1 || i > length(link)+1)return false;
94 
    if(NULL == link)return false;
95
96 
    Node *prev = addressTool(link,i);//获取第i-1个节点地址
97 
    Node *curr = prev->next;//获取第i个节点地址
98
99 
    Node *node = (Node *)malloc(sizeof(Node));//创建新节点
100 
    node->data = data;
101
102 
    prev->next = node;
103 
    node->next = curr;
104
105 
    return true;
106 
}
107
108 
//删除节点
109 
bool Delete(Link link,size_t i)
110 
{
111 
    if(i<1 || i>length(link))return false;
112 
    if(NULL == link)return false;
113
114 
    Node *prev = addressTool(link,i);
115 
    Node *curr = prev->next;
116 
    Node *temp = curr->next;
117
118 
    prev->next = temp;
119 
    free(curr);
120 
    curr = NULL;
121 
    return true;
122 
}
123
124 
//历遍节点
125 
void travel(Link link)
126 
{
127 
    Node *node = link->next;
128 
    while(node != link)
129 
    {
130 
        printf("%d ",node->data);
131 
        node = node->next;
132 
    }
133 
    printf("\n");
134 
}
135
136 
//判断节点是否为空
137 
bool isEmpty(Link link)
138 
{
139 
    return link->next == link;
140 
}
141
142 
//获取第i个节点的数据
143 
datatype getElement(Link link,size_t i)
144 
{
145 
    if(i<1 || i > length(link) || NULL == link)return !(1<<(sizeof(datatype)-1))+1;
146
147 
    Node *node = link->next;
148
149 
    for(size_t j = 1;j < i;j++)
150 
    {
151 
        node = node->next;
152 
    }
153 
    return node->data;
154 
}
155
156
157 
//******************************circular_linkTest.c**************************************
158
159 
#include "circular_link.h"
160
161
162
163
164
165 
int main()
166
167 
{
168
169 
    Link head = create();
170
171 
    printf("isEmpty: %d \n",isEmpty(head));
172
173 
    printf("%d \n",length(head));
174
175 
    travel(head);
176
177
178
179 
    insert(head,1,77);
180
181 
    travel(head);
182
183 
    printf("isEmpty: %d \n",isEmpty(head));
184
185 
    insert(head,1,52);
186
187 
    insert(head,1,44);
188
189 
    travel(head);
190
191 
    printf("%d \n",length(head));
192
193
194
195 
    printf("head:1:%d \n",getElement(head,1));
196
197 
    printf("head:2:%d \n",getElement(head,2));
198
199 
    printf("head:3:%d \n",getElement(head,3));
200
201
202
203 
//  Delete(head,1);
204
205 
//  travel(head);
206
207 
//  Delete(head,1);
208
209 
//  travel(head);
210
211 
//  Delete(head,1);
212
213 
//  travel(head);
214
215 
    return 0;
216
217 
}

4.双向循环链表 
//**********************************double_link.h************************************
#ifndef DOUBLE_LINK_H
#define DOUBLE_LINK_H

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
typedef int datatype;

typedef struct double_link
{
	datatype data;
	struct double_link *prior;
	struct double_link *next;
}DulNode,*DulLink;


//创建链表
DulLink create();

//链表长度
size_t length(DulLink link);

//链表是否为空
bool isEmpty(DulLink link);

//获取第i-1和节点的地址，工具函数，内部使用
DulNode *addressTool(DulLink link,size_t i);

//插入节点
bool insert(DulLink link,size_t i,datatype data);

//删除节点
bool Delete(DulLink link,size_t i);

//历遍节点
void travel(DulLink link);


#endif //DOUBLE_LINK_H





//**********************************double_link.c************************************
#include "double_link.h"


//创建双向循环链表
DulLink create()
{
	DulLink link = (DulLink)malloc(sizeof(DulNode));
	link->prior = link;
	link->next  = link;
	return link;
}

//链表长度
size_t length(DulLink link)
{
	if(NULL == link)return 0;

	DulNode *node = link->next;
	size_t count = 0;
	while(node != link)
	{
		count++;
		node = node->next;
	}

	return count;
}

//链表是否为空
bool isEmpty(DulLink link)
{
	return (link->next == link);
}

//获取第i-1和节点的地址，工具函数，内部使用
DulNode *addressTool(DulLink link,size_t i)
{	
	DulNode *prev = link;
	for(int j = 1;j < i;j++)
	{
		prev = prev->next;
	}
	return prev;
}

//插入节点
bool insert(DulLink link,size_t i,datatype data)
{
	if(i<1 || i > length(link)+1)return false;
	if(NULL == link)return false;

	DulNode *prev = addressTool(link,i);//获得第i-1个节点的地址
	DulNode *old  = prev->next;//获得原来第i个地址

	DulNode *node = (DulNode *)malloc(sizeof(DulNode));//创建新节点
	node->data = data;

	prev->next = node;  //新节点与prev节点的连接
	node->prior= prev;

	node->next = old;
	old->prior = node;

	return true;
}

//删除节点
bool Delete(DulLink link,size_t i)
{
	if(i<1 || i>length(link))return false;
	if(NULL == link)return false;

	DulNode *prev = addressTool(link,i);//获取第i-1个节点地址
	DulNode *curr = prev->next;
	DulNode *behind = curr->next;

	prev->next = behind;//将第i-1个节点和i+1个节点连接起来
	behind->prior = prev;

	free(curr);//释放第i个节点
	curr = NULL;

	return true;
}

//历遍节点
void travel(DulLink link)
{
	DulNode *node = link->next;
	while(node != link)
	{
		printf("%d ",node->data);
		node = node->next;
	}
	printf("\n");
}



//**********************************double_linkTest.c************************************
#include "double_link.h"


int main()
{
	DulLink head = create();
	printf("length: %d \n",length(head));
	printf("isEmpty: %d \n",isEmpty(head));

	insert(head,1,77);
	travel(head);
	insert(head,1,52);
	travel(head);
	insert(head,3,1314);
	travel(head);
	
	insert(head,1,74);
	insert(head,1,75);
	travel(head);
	Delete(head,2);
	travel(head);
	Delete(head,1);
	travel(head);
	return 0;
}
x
144
1 
//**********************************double_link.h************************************
2 
#ifndef DOUBLE_LINK_H
3 
#define DOUBLE_LINK_H
4
5 
#include <stdio.h>
6 
#include <stdbool.h>
7 
#include <stdlib.h>
8 
typedef int datatype;
9
10 
typedef struct double_link
11 
{
12 
    datatype data;
13 
    struct double_link *prior;
14 
    struct double_link *next;
15 
}DulNode,*DulLink;
16
17
18 
//创建链表
19 
DulLink create();
20
21 
//链表长度
22 
size_t length(DulLink link);
23
24 
//链表是否为空
25 
bool isEmpty(DulLink link);
26
27 
//获取第i-1和节点的地址，工具函数，内部使用
28 
DulNode *addressTool(DulLink link,size_t i);
29
30 
//插入节点
31 
bool insert(DulLink link,size_t i,datatype data);
32
33 
//删除节点
34 
bool Delete(DulLink link,size_t i);
35
36 
//历遍节点
37 
void travel(DulLink link);
38
39
40 
#endif //DOUBLE_LINK_H
41
42
43
44
45
46 
//**********************************double_link.c************************************
47 
#include "double_link.h"
48
49
50 
//创建双向循环链表
51 
DulLink create()
52 
{
53 
    DulLink link = (DulLink)malloc(sizeof(DulNode));
54 
    link->prior = link;
55 
    link->next  = link;
56 
    return link;
57 
}
58
59 
//链表长度
60 
size_t length(DulLink link)
61 
{
62 
    if(NULL == link)return 0;
63
64 
    DulNode *node = link->next;
65 
    size_t count = 0;
66 
    while(node != link)
67 
    {
68 
        count++;
69 
        node = node->next;
70 
    }
71
72 
    return count;
73 
}
74
75 
//链表是否为空
76 
bool isEmpty(DulLink link)
77 
{
78 
    return (link->next == link);
79 
}
80
81 
//获取第i-1和节点的地址，工具函数，内部使用
82 
DulNode *addressTool(DulLink link,size_t i)
83 
{
84 
    DulNode *prev = link;
85 
    for(int j = 1;j < i;j++)
86 
    {
87 
        prev = prev->next;
88 
    }
89 
    return prev;
90 
}
91
92 
//插入节点
93 
bool insert(DulLink link,size_t i,datatype data)
94 
{
95 
    if(i<1 || i > length(link)+1)return false;
96 
    if(NULL == link)return false;
97
98 
    DulNode *prev = addressTool(link,i);//获得第i-1个节点的地址
99 
    DulNode *old  = prev->next;//获得原来第i个地址
100
101 
    DulNode *node = (DulNode *)malloc(sizeof(DulNode));//创建新节点
102 
    node->data = data;
103
104 
    prev->next = node;  //新节点与prev节点的连接
105 
    node->prior= prev;
106
107 
    node->next = old;
108 
    old->prior = node;
109
110 
    return true;
111 
}
112
113 
//删除节点
114 
bool Delete(DulLink link,size_t i)
115 
{
116 
    if(i<1 || i>length(link))return false;
117 
    if(NULL == link)return false;
118
119 
    DulNode *prev = addressTool(link,i);//获取第i-1个节点地址
120 
    DulNode *curr = prev->next;
121 
    DulNode *behind = curr->next;
122
123 
    prev->next = behind;//将第i-1个节点和i+1个节点连接起来
124 
    behind->prior = prev;
125
126 
    free(curr);//释放第i个节点
127 
    curr = NULL;
128
129 
    return true;
130 
}
131
132 
//历遍节点
133 
void travel(DulLink link)
134 
{
135 
    DulNode *node = link->next;
136 
    while(node != link)
137 
    {
138 
        printf("%d ",node->data);
139 
        node = node->next;
140 
    }
141 
    printf("\n");
142 
}
143
144
145
146 
//**********************************double_linkTest.c************************************
147 
#include "double_link.h"
148
149
150 
int main()
151 
{
152 
    DulLink head = create();
153 
    printf("length: %d \n",length(head));
154 
    printf("isEmpty: %d \n",isEmpty(head));
155
156 
    insert(head,1,77);
157 
    travel(head);
158 
    insert(head,1,52);
159 
    travel(head);
160 
    insert(head,3,1314);
161 
    travel(head);
162
163 
    insert(head,1,74);
164 
    insert(head,1,75);
165 
    travel(head);
166 
    Delete(head,2);
167 
    travel(head);
168 
    Delete(head,1);
169 
    travel(head);
170 
    return 0;
171 
}

附件列表

猜你喜欢

转载自www.cnblogs.com/LyndonMario/p/9326332.html
今日推荐
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
周排行
[编程题]学英语
[codeforces 1288A] Deadline 约数+模
Python的web开发
Docker在Centos 7上的部署
python编码
解决Ubuntu16.04 fatal error: json/json.h: No such file or directory
mysql并发插入
rest接口如何适应jsonp的方案
linux 终端上网设置
高数——等号两边同时求导、积分的解释
每日归档
更多
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022