单链表

最新推荐文章于 2023-03-15 22:18:29 发布
最新推荐文章于 2023-03-15 22:18:29 发布
阅读量2.7k 收藏 21
点赞数 7
分类专栏： c语言 文章标签： 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39426934/article/details/85458201
版权

标题// 定义单链表结点类型`

typedef struct _LNODE_
{
    // 数据域
    LELEMENT data;
    // 指针域
    struct _LNODE_ *next;
} LNODE;`

2. 创建线性表

// 定义线性表(单链表)类型
typedef struct
{
    // 线性表长度
    int length;
    // 头指针
    LNODE *head;
} LLIST;
void LListCreate(LLIST *list)
{
	list->length = 0;
	list->head = (LNODE*) malloc (sizeof(LNODE));
	list->head->next = NULL;
}

3. 清空线性表

void LListClear(LLIST *list)
{
	LNODE *s;
	while(list->head->next)
	{
		s = list->head->next;
		list->head->next = s->next;
		free(s);
	}
	list->length = 0;
}

4. 销毁线性表

// 销毁线性表
void LListDestroy(LLIST *list)
{
	LListClear(list);
	free(list->head);
	list->head = NULL;
}

线性表长度

// 线性表长度
int LListLength(const LLIST *list)
{
	return list->length;
}

判断空表

int LListEmpty(const LLIST *list)
{
	return NULL == list->head->next;
}

插入元素

void LListInsert(LLIST *list, int index, const LELEMENT *element)
{
	int k;
	LNODE *p = list->head, *s;
	if(index < 1 || index > list->length + 1)
	{
		puts("不正确的位置!");
	} 
	else
	{
		for(k = 1; k < index; ++k)
		{
			p = p->next;  
		}
		s = (LNODE*) malloc (sizeof(LNODE));
		s->data = *element;
		s->next = p->next;
		p->next = s;
		++list->length;
	}
}

删除元素

void LListRemove(LLIST *list, int index, LELEMENT *element)
{
	int k;
	LNODE *p = list->head, *s;
	if(index < 1 || index > list->length )
	{
		puts("不正确的位置!");
	} 
	else
	{
		for(k = 1; k < index; ++k)
		{
			p = p->next;
		}
		s = p->next;
		*element = s->data;
		p->next = s->next;
		free(s);
		--list->length;
	}
}

输出线性表

// 输出线性表
void LListOutput(const LLIST *list)
{
	const LNODE *p;
	putchar('(');
	for(p = list->head->next; p; p = p->next)
	{
		if(p != list->head->next)
		{
			putchar(',');
		}
		putchar(' ');
		LElementOutput(&p->data);
	}
	putchar(' ');
	putchar(')');
}

输入线性表

// 输入线性表
void LListInput(LLIST *list)
{
	char x;
	LELEMENT element;
	LNODE *p = list->head, *s;
	LListClear(list);
	scanf("(");
	while(scanf(" %c", &x), x != (')'))
	{
		ungetc(x, stdin);
		if(list->head->next)
		{
			scanf(",");
		}
		LElementInput(&element);
		s = (LNODE*)malloc(sizeof(LNODE));
		s->data = element;
		p->next = s;
		p = s;
		++list->length;
	}
	p->next = NULL;
}

设置元素

// 设置元素
void LListSet(LLIST *list, int index, const LELEMENT *element)
{
	int i;
	LNODE *p = list->head;
	if(index < 1 || index > list->length)
	{
		puts("不正确的位置!");
	}
	else
	{
		for(i = 1; i <= index; ++i)
		{
			p = p->next;
		}
		p->data = *element;
		
	}
}

读取元素

// 读取元素
void LListGet(const LLIST *list, int index, LELEMENT *element)
{
	int i;
	LNODE *p = list->head;
	if(index < 1 || index > list->length)
	{
		puts("不正确的位置!");
	}
	else
	{
		for(i = 1; i <= index; ++i)
		{
			p = p->next;
		}
		*element = p->data;
	}
}

线性表赋值(复制)

LLIST* LListAssign(LLIST *dst, const LLIST *src)
{
	const LNODE *p = src->head->next;
	LNODE *q = dst->head, *s;
	LListClear(dst); 
	while(p)
	{
		s = (LNODE*)malloc(sizeof(LNODE));
		s->data = p->data;
		q->next = s;
		q = q->next;
		p = p->next;
	}
	q->next = NULL;
	dst->length = src->length; 
	return dst;
}

综合应用(主菜单)

编写主函数，显示如下主菜单。
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 Q退出 > _
要求：

若用户输入L或l，则输出线性表的长度；
若用户输入E或e，则输出线性表是否为空表；
若用户输入N或n，则输入位序和数据元素，将数据元素插入到线性表的对应位置；
若用户输入R或r，则输入位序，删除线性表对应位置的数据元素，并输出该元素；
若用户输入C或c，则清空线性表；
若用户输入S或s，则输入位序和数据元素，设置线性表对应位置的数据元素；
若用户输入G或g，则输入位序，读取线性表对应位置的数据元素，并输出该元素；
若用户输入I或i，则输入线性表；
若用户输入O或o，则输出线性表；
若用户输入其它字符，则报告错误；
程序反复显示主菜单，供用户反复使用，直到用户选择Q或q为止。

运行效果如下：
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 Q退出 > t
不正确的选项!
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 Q退出 > L
0
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 Q退出 > e
空表
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 Q退出 > i
( 1.5, 2.5, 3.5 )
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 Q退出 > s
位置: 3
元素: 0.9
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 Q退出 > o
( 1.5, 2.5, 0.9 )
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 Q退出 > G
位置: 1
元素: 1.5
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 Q退出 > C
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 Q退出 > o
( )
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 Q退出 > n
位置: 1
元素: 2.8
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 Q退出 > N
位置: 2
元素: 5.3
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 Q退出 > n
位置: 2
元素: 7.1
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 Q退出 > o
( 2.8, 7.1, 5.3 )
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 Q退出 > R
位置: 2
元素: 7.1
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 Q退出 > o
( 2.8, 5.3 )
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 Q退出 > L
2
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 Q退出 > e
非空表
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 Q退出 > Q

int main()
{
    LLIST list;
    LELEMENT element;
    char choice;
    int index;
    LListCreate(&list);
	do
	{
		printf("L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 Q退出 > ");
		scanf(" %c", &choice);
			
		choice = toupper(choice);
		switch(choice)
		{
			case 'L':
				printf("%d\n", LListLength(&list));
				break;
			case 'E':
				puts(LListEmpty(&list) ? "空表" : "非空表");
				break;
			case 'N':
				printf("位置: ");
				scanf("%d", &index);
				printf("元素: ");
				LElementInput(&element);
				LListInsert(&list, index, &element);
				break; 
			case 'R':
				printf("位置: ") ;
				scanf("%d", &index);
				LListRemove(&list, index, &element);
				printf("元素: ");
				LElementOutput(&element);
				putchar('\n');
				break;
			case 'C':
				LListClear(&list);
				break;
			case 'S':
				printf("位置: ");
				scanf("%d", &index);
				printf("元素: ");
				LElementInput(&element);
				LListSet(&list, index, &element);
				break;
			case 'G': 
				printf("位置: ");
				scanf("%d", &index);
				LListGet(&list, index, &element);
				printf("元素: ");
				LElementOutput(&element);
				putchar('\n');
				break;
			case 'I':
				LListInput(&list);
				break;
			case 'O':
				LListOutput(&list);
				putchar('\n');
				break;
			case 'Q':
				break;
			default:
				puts("不正确的选项!");
		}
		
	}while(choice != 'Q');
    LListDestroy(&list);
    return 0;
}

查找元素(基础版)

int LListFind(const LLIST *list, const LELEMENT *element)
{
	LNODE *p = list->head->next;
	int k, s = 0;
	for(k = 1; k <= list->length && !s; ++k)
	{
		if(LElementEq(&p->data, element))
		{
			s = k;
		}
		else
		{
			p = p->next;
		}
  }
	return s;
}

查找元素(增强版)

int LListFind2(const LLIST *list, int start, const LELEMENT *elm)
{
	int s = 0, k;
	LNODE *p = list->head;
	for (k = 0; k < start; ++k)
	{
		p = p->next;
	} 
	while (s == 0 && p)
	{
		if (LElementEq(&p->data, elm))
		{
			s = k;
		}
		p = p->next;
		++k;
	}
	return s;
}

线性表逆置`

void LListReverse(LLIST *list)
{
	LNODE *h = list->head->next, *s;
	list->head->next = NULL;
	while(h)
	{
		s = h;
		h = s->next;
		s->next = list->head->next;
		list->head->next = s;
	}
}

按值删除

void LListRemoveValue(LLIST *list, const LELEMENT *element)
{
	LNODE *p = list->head, *s;
	while (p->next)
	{
		if (LElementEq(&p->next->data, element))
		{
			s = p->next;
			p->next = s->next;
			free(s);
			--list->length;
		}
		else 
		{
			p = p->next;
		}
	} 
}

单值化(去重)

void LListUnique(LLIST *list)
{
	LELEMENT element;
	LNODE *k = list->head, *s, *p;
	while (k->next)
	{
		k = k->next;
		element = k->data;
		p = k;
		while (p->next)
		{
			if (LElementEq(&p->next->data, &element))
			{
				s = p->next;
				p->next = s->next;
				free(s);
				--list->length;
			}
			else 
			{
				p = p->next;
			}
		}
		
	}
}

线性表排序

void LListSort(LLIST *list)
{
	LNODE *s, *k, *p, *h = list->head->next;
	list->head->next = NULL;
	while (h)
	{
		s = h;
		k = list->head;
		p = k->next;
		h = h->next;
		while (p && LElementLt(&p->data, &s->data))
		{
			p = p->next;
			k = k->next;
		}
		k->next = s;
		s->next = p;
	}
}

合并线性表(简单合并)

void LListMerge(LLIST *dst, const LLIST *src1, const LLIST *src2)
{
	LNODE *s;
	LNODE *p = src1->head->next, *k = dst->head;
	dst->length = src1->length + src2->length;
	while (p)
	{
		
		s = (LNODE*)malloc(sizeof(LNODE));
		s->data = p->data;
		k->next = s;
		k = s;
		p = p->next;
	}
	p = src2->head->next;
	while(p)
	{
		
		s = (LNODE*)malloc(sizeof(LNODE));
		s->data = p->data;
		k->next = s;
		k = s;
		p = p->next;
	}
	k->next = NULL;
}

合并线性表(交错合并)

void LListMerge2(LLIST *dst, const LLIST *src1, const LLIST *src2)
{
	int i;
	LNODE *p = src1->head->next, *k = src2->head->next, *h = dst->head, *s;
	dst->length = src1->length + src2->length;
	for(i = 1; i <= dst->length; ++i)
	{
		if(p)
		{
			
			s = (LNODE*)malloc(sizeof(LNODE));
			s->data = p->data;
			h->next = s;
			h = s;
			p = p->next; 
		}
		if (k)
		{
			
			s = (LNODE*)malloc(sizeof(LNODE));
			s->data = k->data;
			h->next = s;
			h = s;
			k = k->next;
		}
	}
	h->next = NULL;
}

判断线性表是否相同

int LListEq(const LLIST *list1, const LLIST *list2)
{
	int ok = 0;
	LNODE *k = list1->head->next, *h = list2->head->next;
	if (list1->length == list2->length)
	{
		ok = 1;
		while(ok && k)
		{

			if (LElementNe(&k->data, &h->data))
			{
				ok = 0;
			}
			k = k->next;
			h = h->next;
		}
	}
	return ok;
}

// 判断线性表不同
int LListNe(const LLIST *list1, const LLIST *list2)
{
	int ok = 1;
	LNODE *k = list1->head->next, *h = list2->head->next;
	if(list1->length == list2->length)
	{
		ok = 0;
		while(!ok  && k)
		{
			
			if (LElementNe(&k->data, &h->data))
			{
				ok = 1;
			}
			k = k->next;
			h = h->next;
		}
	} 
	return ok;
}

高级应用(主菜单)

L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 F查找 V逆置 T排序 U去重 Q退出 > _

若用户输入L或l，则输出线性表的长度；
若用户输入E或e，则输出线性表是否为空表；
若用户输入N或n，则输入位序和数据元素，将数据元素插入到线性表的对应位置；
若用户输入R或r，则输入位序，删除线性表对应位置的数据元素，并输出该元素；
若用户输入C或c，则清空线性表；
若用户输入S或s，则输入位序和数据元素，设置线性表对应位置的数据元素；
若用户输入G或g，则输入位序，读取线性表对应位置的数据元素，并输出该元素；
若用户输入I或i，则输入线性表；
若用户输入O或o，则输出线性表；
若用户输入F或f，则输入待查的数据元素，若查找成功，则输出首个匹配的数据元素的位序，否则报告失败；
若用户输入V或v，则将线性表逆置；
若用户输入T或t，则根据数据元素的值按升序排序；
若用户输入U或u，则去掉线性表中重复元素；
若用户输入其它字符，则报告错误；
程序反复显示主菜单，供用户反复使用，直到用户选择Q或q为止。

运行效果如下：

L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 F查找 V逆置 T排序 U去重 Q退出 > i
( 8.3, 7.8, 4.9, 6.5, 2.1, 7.8, 7.8, 2.1, 3.6 )
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 F查找 V逆置 T排序 U去重 Q退出 > f
元素: 2.1
位序: 5
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 F查找 V逆置 T排序 U去重 Q退出 > F
元素: 4.8
查找失败!
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 F查找 V逆置 T排序 U去重 Q退出 > v
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 F查找 V逆置 T排序 U去重 Q退出 > O
( 3.6, 2.1, 7.8, 7.8, 2.1, 6.5, 4.9, 7.8, 8.3 )
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 F查找 V逆置 T排序 U去重 Q退出 > t
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 F查找 V逆置 T排序 U去重 Q退出 > O
( 2.1, 2.1, 3.6, 4.9, 6.5, 7.8, 7.8, 7.8, 8.3 )
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 F查找 V逆置 T排序 U去重 Q退出 > u
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 F查找 V逆置 T排序 U去重 Q退出 > o
( 2.1, 3.6, 4.9, 6.5, 7.8, 8.3 )
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 F查找 V逆置 T排序 U去重 Q退出 > i
( 6.1, 8.3, 1.5, 6.1, 4.7, 1.5, 1.5, 8.3, 6.1, 8.3, 8.3 )
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 F查找 V逆置 T排序 U去重 Q退出 > U
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 F查找 V逆置 T排序 U去重 Q退出 > O
( 6.1, 8.3, 1.5, 4.7 )
L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 F查找 V逆置 T排序 U去重 Q退出 > q

int main()
{
	char m;
	LELEMENT x;
	LLIST list;
	int index;
	LListCreate(&list);
	LListClear(&list);
	do
	{
		printf("L长度 E判空 N插入 R删除 C清空 S设置 G读取 I输入 O输出 F查找 V逆置 T排序 U去重 Q退出 > ");
		scanf(" %c", &m);
		m = toupper(m);
		switch (m)
		{
			case 'L':
				printf("%d\n", LListLength(&list));
				break;
			case 'E':
				LListEmpty(&list) ? puts("空表") : puts("非空表"); 
				break;
			case 'N':
				printf("位置: ");
				scanf("%d", &index);
				printf("元素: ");
				LElementInput(&x);
				LListInsert(&list, index, &x);
				break;	
			case 'R':
				printf("位置: ");
				scanf("%d", &index);
				LListRemove(&list, index, &x);
				printf("元素: ");
				LElementOutput(&x);
				putchar('\n'); 
				break;	
			case 'C':
				LListClear(&list);
				break;	
			case 'S':
				printf("位置: ");
				scanf("%d", &index);
				printf("元素: ");
				LElementInput(&x);
				LListSet(&list, index, &x);
				break;	
			case 'G':
				printf("位置: ");
				scanf("%d", &index);
				LListGet(&list, index, &x);
				printf("元素: ");
				LElementOutput(&x);
				putchar('\n');
				break;
			case 'I':
				LListInput(&list);
				break;	
			case 'O':
				LListOutput(&list);
				putchar('\n');
				break;	
			case 'F':
				printf("元素: ");
				LElementInput(&x);
				index = LListFind(&list, &x);
				index ? printf("位序: %d\n", index) : puts("查找失败!");
				break;	
			case 'V':
				LListReverse(&list);
				break;	
			case 'T':
				LListSort(&list);
				break;	
			case 'U':
				LListUnique(&list);
				break;	
			case 'Q':
				break;	 
			default:
				puts("不正确的选项!"); 
		}
	} while (m != 'Q');
	LListDestroy(&list);
	return 0;
}
PTA单链表 - 20. 单值化(去重)
Celia_ahhh的博客
10-19 1685
所指线性表进行单值化处理：每个数据元素只保留第 1 个，后面与之重复的数据元素都被删去。请编写函数，对线性表进行单值化处理：删除表中重复的数据元素。是指示线性表(单链表)的指针，函数将对。修改主函数，对以上函数进行测试。
数据结构【线性表（二）链表】项目一--建立单链表
Sailor_luo的博客
09-21 1027
1. 定义单链表存储结构，用头插法和尾插法建立单链表，并显示建立好以后的结果。 2.复杂度的要求，设计算法并用专门的函数实现算法； 3.理论与实践相结合
【线性表】线性表的指针实现 单链表的基本操作 两个单链表的合并归并
Herk 的博客
10-24 772
目录 1.单链表的基本操作 2.单链表的进阶操作 2.1两个单链表的合并 2.2复制一个单链表 2.3删除单链表中值为x的结点 3.综合示例 1.单链表的基本操作 #include <iostream> using namespace std; typedef int Elemtype; typedef struct LinkNode { Elemtype data; LinkNode *next; } LinkNode, *LIST, *Node; voi
DS单链表--合并
weixin_63504072的博客
03-15 336
假定两个单链表是递增有序，定义并实现以下函数，完成两个单链表的合并，继续保持递增有序。第1行先输入n表示有n个数据，接着输入n个数据。第2行先输入m表示有M个数据，接着输入m个数据。输出合并后的单链表数据，数据之间用空格隔开。
2.单链表知识+基操代码 |二、线性表
qq_45788060的博客
08-18 256
数据结构，单链表基本操作
链表，建立链表、遍历链表、排序、去重、反转。。。。
04-21
(1)．键盘输入一组元素，建立一个无头结点的单向链表（无序）。 (2)．遍历（打印）单向链表。 (3)．把单向链表中元素逆置（不允许申请新的结点空间）。 (4)．在单向链表中删除所有的偶数元素结点。 (5)．对链表排序，排序后链表元素按照非递减方式排列（注意：排序时如果要交换两个结点的顺序，不得通过交换结点的内容，而需要使用改变指针的方式交换结点的位置。建议使用直接插入排序算法）。 (6)．利用算法5建立两个非递减有序单向链表，然后合并成一个非递减链表。 (7)．利用算法1建立的链表，删除链表中的重复元素。 (8)．利用算法1建立的链表，实现将其分解成两个链表，其中一个全部为奇数，另一个全部为偶数（尽量利用已知的存储空间）。 (9)．判断算法1和算法5生成单链表所表示的集合是否相等。 (10)．在主函数中设计一个简单的菜单，分别调试上述算法。
单链表-实验报告.doc
03-10
在计算机科学与技术领域，单链表是一种重要的基础数据结构，它由一系列节点组成，每个节点包含数据域和指针域，其中指针域指向下一个节点。单链表的节点之间通过指针连接，形成一条单向的线性结构。单链表的特点是...
数据结构-单链表-实验报告.rar_C++_tripk8z_单链表_单链表实验_实验报告
09-21
（2）验证单链表及其基本操作的实现； （3）进一步理解算法与程序的关系，能够将单链表算法转换为对应的程序。 1.2 实验要求： （1）用头插法（或尾插法）建立带头结点的单链表； （2）对已建立的单链表实现插入、...
使用C++实现单链表的基本操作：1、创建单链表2、遍历单链表3、单链表插入4、删除单链表5、判断是否为空6、单链表的
03-27
本文将详细阐述如何使用C++来实现单链表的基本操作，包括创建、遍历、插入、删除、判断空、计算长度以及查找节点。 首先，我们从创建单链表开始。单链表是由一系列节点组成的数据结构，每个节点包含一个数据元素和...
头歌数据结构单链表的基本操作
05-18
头歌数据结构单链表的基本操作 第1关单链表的插入操作 第2关单链表的删除操作 第3关单链表的按照序号查找值操作 第4关单链表的按照值查找结点位序的操作 第5关单链表的逆置操作 第6关两个有序单链表的合并操作 稳过 ...
合并两个单链表
热门推荐
qq_51950769的博客
02-16 1万+
1.以下是基于带头结点的单链表的合并（并且两个链表都是有序的链表） p1 ，p2两个指针分别指向两个链表的第一个元素 申请head结点作为新链表的头结点，申请pre指针指向头结点 第一次： 对p1，p2指针指向位置的元素进行比对，将较小的元素挂在head结点之后，调整更小的元素的对应结点的指针，调整pre指针，以便之后将元素依次挂在后面。 之后重复此操作 第二次： 重复第一次的操作 ...
线性表——单链表创建及其操作（指针实现）
weixin_44804187的博客
04-12 766
#include"stdio.h" #include"malloc.h" #include"stdlib.h" #define true -1 #define false -2 /*链表说白了就是由一个头指针引起的一个线性关系的长表，区别两个不同的链表就是看头指针是否 指向同一个头结点，所以我们创建链表先创建头结点。本程序由一个头指针引起头结点的创建，然后再将头 指针指向这个新创建的头结点，完成整个链表的结构*/ typedef int ElemType; typedef struct LNode{
单链表的定义
qq_44962061的博客
03-07 1022
struct LNode{ //定义单链表结点类型 ElemType data; //定义每个节点存放一个数据元素 struct LNode *next; //指针指向下一个节点 }; struct LNode* p=(struct LNode*)malloc(sizeof(struct LNode));
数据结构——线性表(链表)
qq_44890539的博客
01-08 639
文章目录单链表单链表声明单链表初始化(带头结点)单链表判断是否为空(带头结点)单链表判断是否为空(不带头结点)单链表按位序插入(带头结点)单链表按位序插入(不带头结点)单链表后插操作单链表前插操作单链表删除(带头结点)单链表删除(不带头结点)单链表删除指定节点单链表按位查找单链表按值查找求单链表的长度(带头结点)求单链表的长度(不带头结点)尾插法建立单链表(带头结点)尾插法建立单链表(不带头结点)头插法建立单链表(带头结点) (可以用于链表逆置!!!!!!!!!)头插法建立单链表(不带头结点) 单链表 单
线性表中单链表、双链表的创建和实现
hopegrace的博客
07-11 164
1.单链表 // slist.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include<iostream> #include<vector> #include<string> #include<algorithm> using namespace std; typedef struct stude...
单链表练习1--去重
qq_21058391的博客
10-04 550
在进行单链表去重之前，我们先来考虑一下，数组如何就地去重。 我们可以很容易的编写出这样的代码： 如果通过正向遍历来删除的话，就要注意控制遍历的长度。 function arrRemoveRepeatFront(arr) { for(var i=0; i<arr.length; ++i) { if(arr.indexOf(arr[i]) < i) { arr.splice(i, 1
数据结构——线性表（单链表）
weixin_42823298的博客
09-30 1108
单链表是一种链式存取的，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个节点的构成：（元素+指针） 元素就是存储数据的存储单元，指针就是连接每个节点的地址数据。定义：每个结点 除了存放数据元素外，还要存储指向下一个节点的指针；优点：不要求大片连续空间，改变容量方便；缺点：不可随机存取，要耗费一定空间存放指针局限性：无法逆向检索。
数据结构之线性表(五)——单链表(1 定义)
daocaoren_的博客
07-17 568
单链表的定义 单链表：每个结点只有一个指针域的链表。 以下主要针对带头结点的单链表来进行描述的。 非空表：由头指针L指向头节点，再经由头节点指向首元结点，随后一个元素的指针域为空。 空表：该链表中只有一个头结点，并且头结点的指针域为空。 由于单链表由表头唯一确定，所以单链表用头指针的名字来命名。若头指针名是L，则把该链表称为表L。 单链表的表示 单链表的存储结构 其存储结构如上图，那么怎...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值