(数据结构)带头结点的单链表操作——C实现（新增一些面试经典题目）

已于 2022-01-27 15:58:40 修改
阅读量1.2k 收藏 19
点赞数 5
分类专栏： 数据结构 文章标签： 数据结构 c语言 面试
于 2020-07-21 22:29:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44824574/article/details/107481547
版权

带头结点的单链表

特点：逻辑相邻，物理不相邻
头结点：只在其指针域存放下一结点的地址，用于标记链表的起始（第一个有效数据节点的地址），不存数据。
头结点的空间：栈区或全局区
有效数据的空间：堆区

声明单链表结点类型

typedef struct LNode
{
	int data;//数据域
	struct LNode* next;//指针域
}LNode,* Linklist

操作

链表初始化

//链表初始化
void InitLinkList(Linklist plist)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return;
	}

	plist->next = NULL;
}

为了实现以下插入，删除等一系列操作，先封装以下功能：

获取节点个数

//获取结点个数
int ListLength(Linklist plist)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
 		return 0 ;
	}

	int length = 0;
	Linklist p = plist->next;
	while (p)
	{
		length++;
		p = p->next;
	}

	return length;
}

根据位置找结点

//根据位置找结点
Linklist GetNode(Linklist plist,int pos)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return NULL;
	}

	if(pos < 0) return NULL;

	Linklist p = plist;

	while(pos && p != NULL)
	{
		p = p->next;
		pos--;
	}

	return p;
}

申请节点

static Linklist _ApplyNode(int val,Linklist next)
{
	Linklist s = (Linklist)malloc(sizeof(LNode));
	assert(s != NULL);
	if (s == NULL)
	{
		printf("Insert Fail : Apply Space Error\n");
		return NULL;
	}

	s->data = val;
	s->next = next;
	return s;
	
}

插入

void Insert(Linklist plist, int val, int pos)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return;
	}

	//判断pos位置是否合法
	if(pos < 0  || pos >ListLength(plist))
	{
		printf("Insert error : Pos is Error\n");
		return ;
	}

	Linklist p = GetNode(plist,pos);

	p->next = _ApplyNode(val,p->next);
}

头插

//头插
void Insert_Head(Linklist plist, int val)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return;
	}

    plist->next = _ApplyNode(val,plist->next);
}

尾插

//尾插
void Insert_Tail(Linklist plist, int val)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return;
	}

	Insert(plist,val,ListLength(plist));
}

删除

1.先找到要删除节点的前一个节点，
2.再通过这个节点访问要删除的结点
3.让删除节点的前一个节点的next指向删除节点的next域
4.释放空间

//删除
void Delete(Linklist plist,int pos)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return;
	}

	if(pos < 0 || pos > ListLength(plist))
	{
		printf("Delete Fail : Pos is Error\n");
		return ;
	}

	Linklist p = GetNode(plist,pos-1);//要删除节点的前一个节点

	Linklist q = p->next;//要删除的节点pos位置

	p->next = q->next;

	free(q);
}

头删

//头删
void Delete_Head(Linklist plist)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return;
	}
	Linklist q = plist ->next;
	if(q != NULL )
	{
		plist->next = q->next;
	}

	free(q);
}

尾删

//尾插
void Delete_Tail(Linklist plist)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return;
	}
	Delete(plist,ListLength(plist));
}

判空

//判空
int ListEmpty(Linklist plist)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		printf("Not have Head\n");//不是一个单链表
		return 0 ;
	}

	if(plist->next == NULL)//空
	{
		return 1;
	}
	return 0;
}

置空

//置空
void Clear(Linklist plist)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return;
	}

	while(!ListEmpty(plist))
	{
		Delete_Head(plist);
	}
}

显示

//显示
void Show(Linklist plist)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return;
	}

	Linklist p = plist->next;

	while(p)
	{
		printf("%d ——> ",p->data);
		p = p ->next; 
	}
	printf("NULL\n");
}

逆置

void Reverse_list(Linklist plist)
 {
 	if(plist == NULL || plist->next == NULL)
 	{
 		return;
 	}
	 Linklist p= NULL;//记录当前要处理的节点位置

	 Linklist q = plist->next;//当前要处理结点的后一个结点
	 Linklist s = q->next;

	 while(1)
	 {
		 q->next = p;
		 p = q;
		 q = s;
		 if(q == NULL)
		 {
		 	break;
		 }
		s = s->next;
	}
	plist->next = p;
 }

判断两个单链表是否相交

若相交返回第一个相交的结点地址，若不相交返回空
算法： 必须通过结点的地址进行判断，不能通过data域进行判断

  1. 先通过比较两个结点的长度差值，让长的链表先走这个差值，因为对于两个相交的链表来说，相交后的部分应该有同一个尾结点，在相交前应该从同一逻辑位置开始遍历
  2. 两个链表的指针同时往后走，每走一步判断两个结点是否相等
Linklist IsIntersect(Linklist p1,Linklist p2)
{
	if(ListEmpty(p1) || ListEmpty(p2))
	{
		return NULL;
	}
    if(p1 == NULL || p2 == NULL)
	{
		return NULL;
	}

	int len1 = ListLength(p1);
	int len2 = ListLength(p2);

	if(len1 > len2)
	{
		for(int i = 0;i < len1 - len2;i++)
		{
			p1 = p1->next;
		}
	}
	else
	{
		for(int i = 0;i < len2 - len1;i++)
		{
			p2 = p2->next;
		}
	}
	while(p1 != NULL)
	{
		if(p1 == p2)
			return p1;
		
		p1 = p1->next;
		p2 = p2->next;
	}

	return NULL;
}

找到倒数第k个结点

时间复杂度尽可能低地找
算法： 用两个指针来实现，先让一个指针向后走k个位置，然后两个指针同步往后走，当之前的指针为空时，后面的指针就是倒数第k个位置

Linklist R_GetNode(Linklist plist,int k)
{
	if (plist == NULL || plist->next == NULL || k <= 0)
	{
		return NULL;
	}

	Linklist p = plist;
	Linklist q = plist;

	if(k <= 0) return NULL;

	for(int i = 0;i < k && p != NULL;i++)
	{
		p = p->next; 
	}

	//k值大于链表长度
	if(p == NULL)
	{
		return NULL;
	}

	while(p != NULL)
	{
		p = p->next;
		q = q->next;
	}
	return q;
}

删除p结点（p是指向链表中的某一个不为尾结点的结点）o（1）

算法： 删除一个节点不是删除结点本身，而是要删除这个节点存储的值

int DeleteNodeofP(Linklist plist,Linklist p)
{
	if(plist == NULL || p == NULL)
	{
		return 0;
	}

	if(p->next == NULL)//p指向尾结点
	{
		Delete_Tail(plist);//O（n）
		return 1;
	}

	Linklist q = p->next;
	p->data = q->data;
	p->next = q->next;
	free(q);
	return 1;
}

判断单链表是否有环

//判断单链表是否有环
bool IsCircle(Linklist plist)
{
	if(plist->next == NULL || plist == NULL)
	{
		return false;
	}
	Linklist fast = plist;//快指针
	Linklist slow = plist;//慢指针

	while(fast != NULL && fast->next != NULL)//fast->next != NULL保证快指针一次走两步两个节点能够成功
	{
		fast = fast->next->next;
		slow = slow->next;
	
		if(fast == slow)
		{
			break;
		}
	}

	if(fast == NULL || fast->next == NULL)//链表长度为奇数fast->next为空，偶数时fast为空
		return false;
	else
		return true;
}

找到有环单链表入环的第一个节点

//找到有环单链表入环的第一个节点
Linklist InToCircle(Linklist plist)
{
	Linklist fast = plist;//快指针
	Linklist slow = plist;//慢指针

	while(fast != NULL && fast->next != NULL)
	{
		fast = fast->next->next;
		slow = slow->next;
	
		if(fast == slow)
		{
			break;
		}
	}

	if(fast == NULL || fast->next == NULL)//链表长度为奇数fast->next为空，偶数时fast为空
		return NULL;

	//公式分析：
	/*
	设起点到入环点的距离为x，入环点到相遇点的距离为y，相遇点再到入环点的距离为k
	则快指针走过x+y+(k+y)n（n为圈数）
	慢指针走过x+y
	所以有2*（x+y）= x+y+(k+y)n
	——》x=(k+y)(n-1) + k
	*/
	slow = plist;
	while(slow != fast)
	{
		slow = slow->next;
		fast = fast->next;
	}
	return slow;
}

头文件

#pragma once

/*typedef struct LNode
{
     union
      {
		int data;//存储数据节点
		int length;//头结点记录链表中节点的个数
	   };
	struct LNode* next;
}LNode;*/

//对于单链表节点类型的声明
typedef struct LNode
{
	int data;
	struct LNode* next;
}LNode;

typedef struct LNode* Linklist;

//链表初始化
void InitLinkList(Linklist plist);

//插入
void Insert(Linklist plist, int val, int pos);

//获取结点个数
int ListLength(Linklist plist);

//根据位置找结点
Linklist GetNode(Linklist plist,int pos);

//头插
void Insert_Head(Linklist plist, int val);

//尾插
void Insert_Tail(Linklist plist, int val);

//删除
void Delete(Linklist plist,int pos);

//头删
void Delete_Head(Linklist plist);

//尾插
void Delete_Tail(Linklist plist);

//判空
int ListEmpty(Linklist plist);

//置空
void Clear(Linklist plist);

//显示
void Show(Linklist plist);

//判断两个单链表是否相交
Linklist IsIntersect(Linklist p1,Linklist p2);

//找到倒数第k个结点
Linklist R_GetNode(Linklist plist,int k);

//删除p结点（p是指向链表中的某一个不为尾结点的结点）o（1）
int DeleteNodeofP(Linklist plist,Linklist p);

//判断单链表是否有环
bool IsCircle(Linklist plist);

//找到有环单链表入环的第一个节点
Linklist InTo(Linklist plist);

//单链表逆置
 void Reverse_list(Linklist plist);

测试用例

#include <stdio.h>
#include "singlelist.h"

//LNode head;  //全局定义的头结点
int main()
{
    LNode head;   //栈区定义的头结点
    InitLinkList(&head);

	Insert_Head(&head,10);
	Show(&head);

	Insert_Tail(&head,20);
	Show(&head);

	Delete_Head(&head);
	Show(&head);

	Clear(&head);
	Show(&head);
}

功能实现

#include "singlelist.h"
#include<assert.h>
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
static Linklist _ApplyNode(int val,Linklist next)
{
	Linklist s = (Linklist)malloc(sizeof(LNode));
	assert(s != NULL);
	if (s == NULL)
	{
		printf("Insert Fail : Apply Spave Error\n");
		return NULL;
	}

	s->data = val;
	s->next = next;
	return s;
	
}

//链表初始化
void InitLinkList(Linklist plist)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return;
	}

	plist->next = NULL;
}

//获取结点个数
int ListLength(Linklist plist)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
 		return 0 ;
	}

	int length = 0;
	Linklist p = plist->next;
	while (p)
	{
		length++;
		p = p->next;
	}

	return length;
}

//根据位置找结点
Linklist GetNode(Linklist plist,int pos)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return NULL;
	}

	if(pos < 0) return NULL;

	Linklist p = plist;

	while(pos && p != NULL)
	{
		p = p->next;
		pos--;
	}

	return p;
}

//插入
void Insert(Linklist plist, int val, int pos)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return;
	}

	//判断pos位置是否合法
	if(pos < 0  || pos >ListLength(plist))
	{
		printf("Insert error : Pos is Error\n");
		return ;
	}

	Linklist p = GetNode(plist,pos);

	p->next = _ApplyNode(val,p->next);
}

//头插
void Insert_Head(Linklist plist, int val)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return;
	}

    plist->next = _ApplyNode(val,plist->next);
}

//尾插
void Insert_Tail(Linklist plist, int val)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return;
	}

	Insert(plist,val,ListLength(plist));
}

//删除
void Delete(Linklist plist,int pos)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return;
	}

	if(pos < 0 || pos > ListLength(plist))
	{
		printf("Delete Fail : Pos is Error\n");
		return ;
	}

	Linklist p = GetNode(plist,pos-1);//要删除节点的前一个节点

	Linklist q = p->next;//要删除的节点,pos位置

	p->next = q->next;

	free(q);
}

//头删
void Delete_Head(Linklist plist)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return;
	}
	Linklist q = plist ->next;
	if(q != NULL )
	{
		plist->next = q->next;
	}

	free(q);
}


//尾插
void Delete_Tail(Linklist plist)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return;
	}
	Delete(plist,ListLength(plist));
}

//判空
int ListEmpty(Linklist plist)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		printf("Not have Head\n");//不是一个单链表
		return 0 ;
	}

	if(plist->next == NULL)//空
	{
		return 1;
	}
	return 0;
}

//置空
void Clear(Linklist plist)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return;
	}

	while(!ListEmpty(plist))
	{
		Delete_Head(plist);
	}
}
//显示
void Show(Linklist plist)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return;
	}

	Linklist p = plist->next;

	while(p)
	{
		printf("%d ——> ",p->data);
		p = p ->next; 
	}
	printf("NULL\n");
}

//判断两个单链表是否相交,若相交则返回第一个相交的结点，若没有相交，则返回空
Linklist IsIntersect(Linklist p1,Linklist p2)
{
	if(ListEmpty(p1) || ListEmpty(p2))
	{
		return NULL;
	}
    if(p1 == NULL || p2 == NULL)
	{
		return NULL;
	}

	int len1 = ListLength(p1);
	int len2 = ListLength(p2);

	if(len1 > len2)
	{
		for(int i = 0;i < len1 - len2;i++)
		{
			p1 = p1->next;
		}
	}
	else
	{
		for(int i = 0;i < len2 - len1;i++)
		{
			p2 = p2->next;
		}
	}
	while(p1 != NULL)
	{
		if(p1 == p2)
			return p1;

		p1 = p1->next;
		p2 = p2->next;

		
	}

	return NULL;
}

//找到倒数第k个结点
Linklist R_GetNode(Linklist plist,int k)
{
	if (plist == NULL || plist->next == NULL || k <= 0)
	{
		return NULL;
	}

	Linklist p = plist;
	Linklist q = plist;

	if(k <= 0) return NULL;

	for(int i = 0;i < k && p != NULL;i++)
	{
		p = p->next; 
	}

	//k值大于链表长度
	if(p == NULL)
	{
		return NULL;
	}

	while(p != NULL)
	{
		p = p->next;
		q = q->next;
	}
	return q;
}

//删除p结点（p是指向链表中的某一个不为尾结点的结点）o（1）
int DeleteNodeofP(Linklist plist,Linklist p)
{
	if(plist == NULL || p == NULL)
	{
		return 0;
	}

	if(p->next == NULL)//p指向尾结点
	{
		Delete_Tail(plist);
		return 1;
	}

	Linklist q = p->next;
	p->data = q->data;
	p->next = q->next;
	free(q);
	return 1;
}

//判断单链表是否有环
bool IsCircle(Linklist plist)
{
	Linklist fast = plist;//快指针
	Linklist slow = plist;//慢指针

	while(fast != NULL && fast->next != NULL)
	{
		fast = fast->next->next;
		slow = slow->next;
	
		if(fast == slow)
		{
			break;
		}
	}

	if(fast == NULL || fast->next == NULL)//链表长度为奇数fast->next为空，偶数时fast为空
		return false;
	else
		return true;
}

//找到有环单链表入环的第一个节点
Linklist InToCircle(Linklist plist)
{
	Linklist fast = plist;//快指针
	Linklist slow = plist;//慢指针

	while(fast != NULL && fast->next != NULL)
	{
		fast = fast->next->next;
		slow = slow->next;
	
		if(fast == slow)
		{
			break;
		}
	}

	if(fast == NULL || fast->next == NULL)//链表长度为奇数fast->next为空，偶数时fast为空
		return NULL;

	//画图分析可知slow和fast第一次相遇的位置距离入环点的距离等于头结点到入环点的距离
	slow = plist;
	while(slow != fast)
	{
		slow = slow->next;
		fast = fast->next;
	}
	return slow;
}

//单链表逆置
 void Reverse_list(Linklist plist)
 {
	 Linklist p= plist->next;//记录当前要处理的节点位置

	 Linklist q ;//当前要处理结点的后一个结点

      //由于第一个元素没有真正意义上的前驱，故在循环前要初始化头结点的指针域为NULL，用来表示它没有前驱，刚好合适
	 plist ->next = NULL;

	 while(p)
	 {
		 q = p->next;//q记录下p的后继结点
		 p->next = plist->next;//使p的前驱变后继
		 plist->next = p;//plist->next指向已处理的结点
		 p = q;//p指向下一个待处理的结点
	 }
 }
Dutkig
关注
  • 5
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【头歌】单链表的基本操作
qq_39977056的博客
01-23 1万+
由于单链表中每个结点的存储地址是存放在其前趋结点的指针域中的，而第一个结点无前趋，头指针L指向第一个结点，对于整个单链表的读取必须从头指针开始，同时，由于单链表中最后一个结点的指针域为“空”（NULL），没有直接后继元素，对于整个单链表的读取必须在尾结点结束。要在带头结点的单链表L中删除第i个结点，则同样要先找到第i-1个结点，使p指向第i-1个结点，使q指向第i个结点，然后令第i-1个结点的指针域指向第i+1个结点，而后删除q指向的第i个结点并释放结点空间。= NULL时，才能进行删除结点的操作。
数据结构-带头节点的单链表（C语言）超详细讲解
m0_56992713的博客
10-17 2万+
前面我们学到线性表的顺序存储结构（顺序表），发现它有着明显的缺点：插入和删除元素时需要频繁的移动元素，运算效率低。必须按事先估计的最大元素个数申请连续的存储空间。存储空间估计大了，造成浪费空间；估计小了，容易产生溢出，空间难以扩大。 采用链式存储结构的线性表（链表）可以克服以上的不足。 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(存放的数据元素)+指针(指示下一个元素存储位置，单、双链表的最后一个节点除外，它们.
单链表的基本操作实现
IMIS_TwentyEight的博客
10-10 543
一．实验目的      巩固线性表的数据结构的存储方法和相关操作，学会针对具体应用，使用线性表的相关知识来解决具体问题。 二．.实验内容 1.建立一个由n个学生成绩的顺序表，n的大小由自己确定，每一个学生的成绩信息由自己确定，实现数据的对表进行插入、删除、查找等操作。分别输出结果。 三.实验程序如下 1 2 3 4 5 6 7
按递增次序输出带头节点单链表的数据元素并释放其空间
vivi_and_qiao的博客
09-19 3617
#include "stdafx.h" #include&lt;stdio.h&gt; #include&lt;malloc.h&gt; #include&lt;stdlib.h&gt; typedef int type; typedef struct lnode //定义链表结点的数据结构 { int data; struct lnode *next; }Lnode; ty...
【数据结构|链表】单链表基本操作
爱喝冰红茶的方舟的博客
10-24 1043
链表基本操作实现
数据结构：不带头结点单链表的实现及其一些基本操作.cpp
08-03
实现单链表及其一些基本操作函数（不带头结点） 1.头文件包含 2.宏定义及节点类型描述 3.初始化、判断是否为空 4.指定位置插入操作 5.在p节点后插入元素e 6.在p节点前插入元素e 7.删除操作：删除第i个节点，...
c代码-不带头结点单链表创建——头插法
07-14
在C语言中，单链表是一种常见的数据结构，用于存储一系列有序或无序的数据元素。在本主题中，我们将深入探讨如何使用头插法创建一个不带头结点的单链表。头插法是一种在链表头部插入新节点的方法，这与尾插法相反，...
数据结构 数据结构 带头结点的单链表 操作大全（c++实现） 操作大全（c++实现）代码讲解
09-27
对博文中函数关系的说明 最全的带头结点的单链表操作（c++实现） 已由Keynote转为ppt 博客地址： blog.csdn.net/u012350104
实验3-带头结点的单链表
weixin_30502157的博客
11-03 2802
实验1： 1 /*编写函数void delx(linklist head, datatype x)，删除带头结点单链表head中第一个值为x 的结点。 2 并构造测试用例进行测试。 3 */ 4 /**********************************/ 5 /*文件名称：lab3_01.c */ 6 /**********...
线性表-第2章-《数据结构习题集》答案解析-严蔚敏吴伟民版
热门推荐
StrayedKing-245176013
12-26 8万+
严蔚敏吴伟民版《数据结构习题集》第2章线性表部分答案+习题解析。
C语言之算法与数据结构练习篇-寻找带头结点单链表的倒数第K个位置上的数
jiaojiao3701的博客
05-18 297
C语言之算法与数据结构练习篇-寻找带头结点单链表的倒数第K个位置上的数 算法思想：设置两个工作指针p,q同时指向头指针;其中p先走k步，然后p,q在同时走当p遍历到单链表的尾部时，q对应的就是单链表的倒数第K个位置上的数 完整代码如下 #include<stdio.h> #include<stdlib.h> //定义单链表结构 typedef struct node{ int value; struct node *next; }Node; //定义头指针 type
实验三 带头节点的单链表
逝不等琴生的博客
12-06 2816
前言 熟练掌握带头节点的单链表的相关操作， 头文件 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; /**************************************/ /* 链表实现的头文件，文件名slnklist2.h */ /**************************************/ typedef int...
数据结构（C语言版）——带头结点的单链表的基本操作
隔壁家的程序员小白
07-25 9547
带头结点的单链表结构体定义初始化插入删除遍历获取内容检索判空求长度清空销毁链表的合并直接合并非递减排序合并源代码及数据测试测试结果 结构体定义 struct LNode { ElemType data; //数据域 struct LNode *next; //next指针域 }; typedef struct LNode *LinkList;//定义为LinkList的指针类型 初始化 初始化操作是构造一个空的线性表L。即把头结点的下一个结点置为空即可。 Status Ini
【链表】查找倒数第k个结点
lbcvvv的博客
07-23 329
【链表】查找倒数第k个结点题目主要思想c++源代码结果 题目 设计一个函数,在带附加头结点的单链表中查找倒数第k个结点。若查找成功,函数通过参数表送出该结点的data域的 值,并返回rue,否则只返回 false;在主函数中,调用该数并查找倒数第4个结点的值,如果查找成功,则输出查找 到的值(加一个回车),否则什么都不输出。 主要思想 定义两个工作指针p和q ； 先让p进行移动直到正数第K个数 ； 然后q指针开始跟随p指针一起移动 ； 直至“”p“”指针遍历到链表末尾 ； 此时“”q“”指针指的就是倒数
《数据结构》上机实验(第二章)——线性表 Ⅲ
Miss Z的博客
08-03 1989
1. L1=(x1,x2,…,xn),L2=(y1,y2,...,yn)L1=(x_1,x_2,…,x_n),L2=(y_1,y_2,...,y_n)L1=(x1​,x2​,…,xn​),L2=(y1​,y2​,...,yn​)，它们是两个线性表，采用带头结点的单链表存储，合并L1、L2，结果放在线性表L3中。 要求如下： L3=(x1,y1,x2,y2,...,xm,ym,xm+1,...,xn)                    m≤nL3=(x_1,y_1,x_2,y_2,...,x_m,y_m,
算法与数据结构重点归纳
weixin_45683301的博客
06-20 5615
1、算法 for(i=n-1; i>=1; i–) for(j=1; j<=i; j++) if(A[j]>A[j+1]) A[j]与A[j+1]对换； 其中n为正整数，则最后一行语句的频度（执行次数）在最坏情况下是( D ) A. O(n) B. O(nlog2n) C. O(n3) D. O(n2) 2、设某算法完成对n个元素进行处理，所需的时间是T(n)=100nlog2n+200n+500，则该算法的时间复杂度是( C ) A. O(1) B. O(n) C. O(
带头结点的单链表简单实现
nb_zsy的博客
09-23 300
/*带头结点的单链表实现*/ #include <stdio.h> #include <stdlib.h> typedef struct ElemType { int id; char name[10]; }ElemType; typedef struct Node { ElemType data; struct Node* next; }ListNode,*LinkList; /*初始化该链表*/ int InitList(LinkList* L) { *L = (
单链表 简单题（单链表基本操作）
菇凉小伙de博客
10-08 1296
题目描述： 有一个带头结点的单链表L=（a1,b1,a2,b2,......an,bn),设计一个算法将其拆分成两个带头结点的单链表L1和L2，其中L1=（a1,a2,a3...an),L2=(b1,b2,b3....bn),要求L1使用L的头结点。 解题思路： 利用原单链表L中的所有节点通过改变指针域重组成两个单链表L1和L2，由于L1中节点的相对顺序与L中的相同，所以采用尾插法建立单链表...
带头结点单链表删除x的c语言实现
最新发布
07-27
以下是使用 C 语言实现删除带头结点单链表中元素 x 的代码： ```c #include #include // 定义链表节点结构 struct ListNode { int val; struct ListNode* next; }; // 创建一个新节点 struct ListNode* ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值