王道 2.07-2.08查找

最新推荐文章于 2021-10-24 11:55:21 发布
最新推荐文章于 2021-10-24 11:55:21 发布
阅读量229 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cup3380544530/article/details/107889713
版权

目录

在这里插入图片描述在这里插入图片描述

以下代码都是带头结点的

1.查找

1.1按位查找 GetElem(L,i) L中第i个结点–O(n)

在插入时写过,前面是找i-1个结点
在这里插入图片描述
别人调用查找,想知道找没找到,只需要判断返回值是不是NULL,

模拟过程:
当i=0时,找到头结点,return p=L,返回头结点
i=8时 开始:j=0,p=L,不为空
第一轮循环 p指向除了头结点的第一个位置,j=1
第二轮循环 p指向除了头结点的第二个位置,j=2
第五轮循环 p指向除了头结点的第五个位置,但第五个位置并没有数,是NULL的,此时j=5
第六轮循环 while(p!=NULL)不满足,跳出循环,return p=NULL;
代码如下:

LNode *GetElem(LinkList L,int i){//按位查找
	if(i<0){
		return NULL;//因为i从0开始,0是头结点
	}
	LNode *p;
	int j=0;
	p=L;//L是头结点,p最开始指向头结点
	while(p!=NULL&&j<i){
		p=p->next;//找到i-1;p指向i-1的下一个
		j++;
	}
	return p;//返回找到的结点
}

在ListInset()里面直接调用

bool ListInsert(ListList &L,int i,ELemType e){
	if(i<1)
		return false;
	LNode *p=GetElem(L,i-1);
	return InsertNextNode(p,e);
}

顺序表查找按位查找:O(1)

1.2按值查找 LocateElem(L,e)–O(n)

LNode *p=L->next;
while(p!=NULL&&p->data!=e){
p=p->next;
}
return p;

LNode * LocateElem(LinkList L,ElemType e){
	LNode *p=L->next;
	while(p!=NULL&&p->data!=e){
		p=p->next;
	}
	return p;
}

1.3求单链表的长度–O(n)

和按值查找相似,加一个计数器

int Length(LinkList L){
	int i=0;
	LNode *p=L;
	while(p->next!=NULL){
		p=p->next;
		i++;
	}
	return i;
}

2.单链表的建立

尾插就是
1
1 2
1 2 3
头插就是
1
2 1
3 2 1

头插法和尾插法都是在指定结点后插的基础上;
指定结点后插: 在p结点之后插入
尾插法: 把指针p换成了r, r始终是表尾指针 s->data=x; r->next=s; r=s;
头插法: 把指针p换成了L, L是头指针 == s->data=x; s->next=L->next; L->next=s==

2.1指定结点的后插 指定位置的前插

指定结点的后插

/*------------------指定结点的后插-----------------------*/
bool InsertNextNode(LNode *p,ElemType e)
{ /* 尾插法在p结点之后插入元素e*/
	if(p==NULL)
		return false;
	LinkList s;//LNode *s;
	if(s=NULL) /* i小于或者大于表长*/ 
		return false;
	s=(LinkList)malloc(sizeof(LNode)); /* 生成新结点*/ s->data=e; /* 插入L中*/
	s->data=e;
	s->next=p->next; 
	p->next=s; 
	return true;
}

指定位置的插入

/*----------------- 第i个位置之前插入元素e ------------------*/
bool ListInsert(LinkList L,int i,ElemType e) /* 尾插法正向插入 */
{ //在带头结点的单链线性表L中
	//O(n^2)
//每次都找i,插入到i到位置,第一次1回;第二次找2回,然后插入;第三次找3回找到i,然后插入
	LinkList p=L;//LNode *p;p=L;
	LinkList s;//LNode *s;
	int j=0;
	while(p&&j<i-1) /* 寻找第i-1个结点,
	while(p!=NULL&&j<i-1)*/
	{
		p=p->next;
		j++;
	}
	if(!p||j>i-1) /* i小于或者大于表长*/ 
	//if(p==NULL) 
		return false;
	s=(LinkList)malloc(sizeof( LNode)); /* 生成新结点*/ 
	s->data=e; /* 插入L中*/
	s->next=p->next; 
	p->next=s; 
	return true;
}

2.2尾插法

尾插有两种方式
① 每次从头扫描,插到最后一个位置ListInsert() —O(n^2)
用上面指定位置的前插方式

② 用表尾指针 List_TailInsert —O(n)
每次循环都申请一个新的结点s,让链表最后一个结点r和s连上,再让r指向新的结点
用上面指定结点的后插方式 在这里插入图片描述

LinkList List_TailInsert(LinkList &L){	
	L=(LinkList)malloc(sizeof(LNode));//初始化空表
	L->next=NULL;//健壮性
	LNode *s;
	LNode *r=L;//r是表尾指针!!!!!
	int x;
	scanf("%d",&x);
	while(x!=9999){//输入9999完成插入
		s=(LinkList)malloc(sizeof(LNode));//新插入的结点s
		s->data=x;//给s赋值
		r->next=s;//把r和s连上
		r=s;//!!!r指向s,也就是新插入的结点s,目前最后一个结点
		scanf("%d",&x);
	}//每次循环都申请一个新的结点s,让链表最后一个结点r和s连上,再让r指向新的结点
	r->next=NULL;//1 2 3 4 5 NULL
	return L;
}

2.3头插法

应用:链表逆置
在这里插入图片描述

/*-------------------头插法建立单链表------------*/
LinkList List_HeadInsert(LinkList &L){
	L=(LinkList)malloc(sizeof(LNode));
	L->next=NULL;
	int x;
	scanf("%d",&x);
	LNode *s;
	while(x!=9999){
		s=(LinkList)malloc(sizeof(LNode));
		s->data=x;
		s->next=L->next;//右边箭头  
		L->next=s;//左边箭头
		scanf("%d",&x);
	}
	return L;
}//单链表逆置问题!!!


#include "stdafx.h"
#include "stdio.h"
#include "stdlib.h"	//exit function, malloc function

#define TRUE 1
#define FALSE 0
#define INFEASIBLE -1

typedef int ElemType;
typedef int Status;
typedef struct LNode
{
ElemType data;
 struct LNode *next;
}LNode, *LinkList;

bool InitList(LinkList &L)
{ /* 操作结果： 构 造 一 个 空 的 线 性 表 L */
	L=(LinkList)malloc(sizeof(LNode)); /* 产生头结点,并使L指向此头结点*/ 
	if(!L) /* 存储分配失败*/
		return false;
	//	exit(OVERFLOW);
	L->next=NULL; /* 指针域为空*/
	return true;
}

/* 不用头插尾插,直接ListInsert()时用
void CreateList(LinkList &L, int n)
{
	int i;
	LinkList p;
	L=(LinkList) malloc(sizeof(LNode)); 
	L->next=NULL;
	for(i=0;i<n;i++)
	{
		p=(LinkList)malloc(sizeof(LNode)); 
		printf("input a data:\n"); 
		scanf("%d",&(p->data));
		p->next = L->next;
		L->next=p;
	}
}
*/

/*----------------- 第i个位置之前插入元素e ------------------*/
bool ListInsert(LinkList L,int i,ElemType e) /* 尾插法正向插入 */
{ //在带头结点的单链线性表L中
	//O(n^2)
//每次都找i,插入到i到位置,第一次1回;第二次找2回,然后插入;第三次找3回找到i,然后插入
	LinkList p=L;//LNode *p;p=L;
	LinkList s;//LNode *s;
	int j=0;
	while(p&&j<i-1) /* 寻找第i-1个结点,
	while(p!=NULL&&j<i-1)*/
	{
		p=p->next;
		j++;
	}
	if(!p||j>i-1) /* i小于或者大于表长*/ 
	//if(p==NULL) 
		return false;
	s=(LinkList)malloc(sizeof( LNode)); /* 生成新结点*/ 
	s->data=e; /* 插入L中*/
	s->next=p->next; 
	p->next=s; 
	return true;
}
/*------------------指定结点的后插-----------------------*/
bool InsertNextNode(LNode *p,ElemType e)
{ /* 尾插法在p结点之后插入元素e*/
	if(p==NULL)
		return false;
	LinkList s;//LNode *s;
	if(s=NULL) /* i小于或者大于表长*/ 
		return false;
	s=(LinkList)malloc(sizeof(LNode)); /* 生成新结点*/ s->data=e; /* 插入L中*/
	s->data=e;
	s->next=p->next; 
	p->next=s; 
	return true;
}

/*-------------------尾插法建立单链表------------*/
LinkList List_TailInsert(LinkList &L){	
	L=(LinkList)malloc(sizeof(LNode));//初始化空表
	L->next=NULL;//健壮性
	LNode *s;
	LNode *r=L;//r是表尾指针!!!!!
	int x;
	scanf("%d",&x);
	while(x!=9999){//输入9999完成插入
		s=(LinkList)malloc(sizeof(LNode));//新插入的结点s
		s->data=x;//给s赋值
		r->next=s;//把r和s连上
		r=s;//!!!r指向s,也就是新插入的结点s,目前最后一个结点
		scanf("%d",&x);
	}//每次循环都申请一个新的结点s,让链表最后一个结点r和s连上,再让r指向新的结点
	r->next=NULL;//1 2 3 4 5 NULL
	return L;
}

/*-------------------头插法建立单链表------------*/
LinkList List_HeadInsert(LinkList &L){
	L=(LinkList)malloc(sizeof(LNode));
	L->next=NULL;
	int x;
	scanf("%d",&x);
	LNode *s;
	while(x!=9999){
		s=(LinkList)malloc(sizeof(LNode));
		s->data=x;
		s->next=L->next;//右边箭头
		L->next=s;//左边箭头
		scanf("%d",&x);
	}
	return L;
}//单链表逆置问题!!!


/*--------------------单链表按位查找-------------------*/

//1. 这个是j从1开始
bool GetElem(LinkList L,int i,int &e) // 
{ // L为带头结点的单链表的头指针。当第i个元素存在时,其值赋给e并返回true,否则返回false
	int j=1; // j为计数器
	LinkList p=L->next; // p指向第一个结点
	while(p&&j<i) // 顺指针向后查找,直到p指向第i个元素或p为空
	{
		p=p->next;
		j++;
	}
	if(!p||j>i) // 第i个元素不存在 
		return false;
	e=p->data; //取第i个元素 
	return true;
}

/*
//2.  j从0开始;
bool GetElem(LinkList L,int i,int &e){
	if(i<0)
		return false;
	if(i==0)
		//e=L->data;
		return true;
	int j=0;
	LNode *p;
	p=L->next;
	while(p!=NULL&&j<i)
	{
		p=p->next;
		j++;
	}
	if(p==NULL)
		return false;
	e=p->data;
	return true;
}
*/
/*
//3. 结点类型 王道书上面的
LNode *GetElem(LinkList L,int i){//
	if(i<0){
		return NULL;//因为i从0开始,0是头结点
	}
	LNode *p;
	int j=0;
	p=L;//L是头结点,p最开始指向头结点
	while(p!=NULL&&j<i){
		p=p->next;//找到i-1;p指向i-1的下一个
		j++;
	}
	return p;//返回找到的结点
}

/*-------------------单链表按值查找------------------------*/

LNode * LocateElem(LinkList L,ElemType e){ //按值查找
	LNode *p=L->next;
	while(p!=NULL&&p->data!=e){
		p=p->next;
	}
	return p;
}

/*--------------单链表长度-------------------------*/
int ListLength(LinkList L)
{ /* 初始条件：线性表L已存在。操作结果：返回L中数据元素个数*/ 
	int i=0;
	LinkList p=L->next; /* p指向第一个结点*/
	//或者写成LNode *p=L->next;
	while(p)//等价于while(p!=NULL) /* 没到表尾*/  
	{
		p=p->next;
		i++;
	}
	//上面要是p=L,while就是(p->next!=NULL)
	/*	
	LNode *p=L;
	while(p->next!=NULL){
		p=p->next;
		len++;
	}*/
	return i;
}


bool ListTraverse(LinkList L)
{
	LinkList p=L->next; 
	while(p)
	{
		printf("%d	",p->data); p=p->next;
	}
	printf("\n"); 
	return true;
}

int main()
{
	int k;
	ElemType e;
	LinkList L;

	InitList(L); 
/*	
	ListInsert(L,1,1); ListInsert(L,1,2); ListInsert(L,1,3); 
	ListInsert(L,1,4); ListInsert(L,1,9); ListInsert(L,1,6); 
*/
//	List_TailInsert(L);
	List_HeadInsert(L);//输出是相反的
	ListTraverse(L); 
	k=ListLength(L);
 
	printf("链表长度为：%d\n",k);

	GetElem(L,4,e);             
	printf("链表的第4个元素为：%d\n",e);//i从0开始

	ListInsert(L,2,10);
	printf("链表在第2位插入10后为:\n");
	ListTraverse(L);

	getchar();  
	return 0;
}

头插法运行结果:在这里插入图片描述

黑糖儿*
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言单链表的查找,单链表的查找、建立操作（C语言）
weixin_39549899的博客
05-20 3320
一、单链表的查找(带头结点)(一)按位查找GetElem(L,i)：按位查找操作。获取表L中第i个位置的元素的值。//按位查找，返回第i个元素(带头结点)LNode * GetElem(LinkList L, int i){if(i<0)return NULL;LNode *p;//指针p指向当前扫描到的结点int j=0;//当前p指向的是第几个结点p = L;//L指向头结点，头结点是第...
双链表基本操作
菇凉小伙de博客
10-10 213
建立双链表：          在双链表中，由于每个节点既包含一个指向后继节点的指针，又包含一个指向前驱节点的指针，所以当访问过每一个节点后既可以依次向后访问每一个节点，也可以依次向前访问每一个节点。因此，与单链表相比，双链表访问一个节点的前后节点更方便。 代码实现： typedef struct DNode {     int data;     struct DNode *prior; ...
王道ch1-线性表的定义，插入，删除，按值查找
比尔·盖薇的博客
10-08 254
#include <iostream> using namespace std; //任务：定义，静态and动态，第i个位置插入元素e，删除第i个元素，按值查找e //静态 /* #define Maxsize 50 typedef struct { int data[Maxsize]; int length; }SqList; */ #define Initsize 50 ty...
单链表基本操作函数
Antler_的博客
11-25 402
/*************************************************************************************/ /* 单链表基本操作函数 /*-------------------------------------------------------------------------------------------------...
数据结构—单链表
qq_43558806的博客
07-18 337
#include <bits/stdc++.h> using namespace std; //定义单链表 typedef struct LNode //定义单链表节点类型,typedef意思是重命名 { int data;//每个节点存放一个数据元素 struct LNode *next;//指针指向下一个节点 } LNode,*LinkList; //LNode *强调返回的是一个节点，LinkList强调这是一个单链表 //初始化单链表(不带头结点），目的是清楚可能留下来
C语言数据结构之链表详细解析
Feeryman_Lee的博客
08-29 1096
单链表的头插法尾插法建立单链表，单链表的查找、插入、删除。 双链表的插入、删除、查找。
王道考研-数据结构笔记
09-16
"王道考研-数据结构笔记"是一份专为准备计算机专业考研的学生编写的参考资料，旨在帮助他们系统地学习和复习这个关键领域的知识点。 首先，我们要理解数据结构的基本概念。数据结构是组织和存储数据的方式，它不仅...
王道2020-408题目1
08-03
B树是一种自平衡的查找树，适合大量数据的存储。 11. **排序算法**：11题比较了直接插入排序和简单选择排序。在元素大部分已排序的情况下，直接插入排序通常优于简单选择排序，因为它在接近有序的数组中表现更好，...
2022王道考研-数据结构笔记.zip
最新发布
06-16
2022年版的“王道考研-数据结构笔记”是一份全面的学习资源，旨在帮助学生深入理解这一主题。 数据结构主要包括数组、链表、栈、队列、树、图以及哈希表等类型。下面将对这些主要的数据结构进行详细的介绍： 1. **...
王道考研-计算机网络笔记.docx
12-18
王道考研自整理的笔记，适合期末~
线性表之链式表示
Soloversion的博客
12-17 545
一、 线性表之链式存储1. 单链表1.1 单链表的定义1.2 单链表的特点1.3 单链表结点类型描述1.4 单链表上基本操作的实现1.4.1 头插法创建单链表实现思路实现代码1.4.2 尾插法创建单链表实现思路实现代码1.4.3 按值查找结点实现思路实现代码1.4.4 插入结点实现思路实现代码1.4.5 删除结点实现思路实现代码2. 双链表2.1 双链表与单链表的区别2.2 双链表的构成2.3 双链表结点类型描述2.4 双链表的基本操作实现2.4.1 双链表的创建实现代码2.4.2 双链表的按位序删除实现代
链表知识总结及代码实现
m0_63330233的博客
10-24 2753
目录 头指针、头结点和首元结点的概念 链表的概念 链表的特性 有关链表的三个讨论 了解顺序表前首先应该了解结点等知识，下面来依次了解相关知识： 头指针、头结点和首元结点的概念 头指针: 是指向链表中第一个结点的指针 首元结点: 是指链表中存储第一个数据元素的结点 头结点: 是在链表的首元结点之前附设的一个结点; 链表的概念 定义：链表，别名链式存储结构或单链表，用于存储逻辑关系为 "一对一" 的数据。与顺序表不同，链表不限制数据的物理存储状态，换句话说，使用链表存储的数据元素...
单链表操作实现getelem_【数据结构】单链表的基本操作（C语言）
weixin_31599065的博客
01-01 4960
线性表的链式存储又称为单链表通过一组任意的存储单元来存储线性表中的数据元素（数据元素存储的位置地址可能连续也可能不连续）通过指针连接不相邻的地址，实现线性逻辑关系单链表的定义 L=(,, , ........)每个结点不仅保存该结点的数据元素data，还保存指向下一数据元素位置的指针nexttypedef struct LNode { ElemType data; struct LNode...
【数据结构】-单链表(无头结点）
RunningSnail的博客
07-18 4076
单链表-无头结点1.头文件及类型定义2.单链表结点类型定义3.函数声明4.基本操作4.1 初始化单链表4.2 判空4.3 插入操作4.3.1 按位插入4.3.2 指定结点插入4.3.2.1 指定结点后插4.3.2.2 指定结点前插4.3.2.2.1 前插法1(时间复杂度为O(n))4.3.2.2.2 前插法2(时间复杂的为O(1))4.4 删除操作4.4.1 按位删除4.4.2 指定结点删除4.4.2.1 删除法1(时间复杂度为O(n))4.4.2.2 删除法2(时间复杂度为O(1))4.5 查找操作4.5
双链表
Lau's Blog
05-06 476
双链表定义和基本运算 #include <stdio.h> #include <malloc.h> typedef int ElemType; typedef struct DNode //定义双链表结点类型 { ElemType data; struct DNode *prior; //指向前驱结点 struct DNode *next; //指向后继结点 ...
单链表的查找及求表长
一个随时准备弃坑的博客
03-30 2452
以下代码均是针对带头结点的单链表： ①按位查找 //按位查找，返回第i个元素（带头结点） LNode *GetElem(LinkList L,int i) { if(i<0) return NULL; LNode *p; //指针p指向当前扫描到的结点 int j=0; //当前p指向的第几个结点 p=L; //L...
采用头插法和尾插法建立单链表
热门推荐
zwz2011303359的博客
03-17 3万+
面说一下如果用C语言建立单链表，分为头插法和尾插法两种。 采用头插法建立单链表 该方法从一个空表开始，生成新结点，并将读取到的数据存放到新结点的数据域中，然后将新结点插入到当前链表的表头，即头结点之后，如图2-4所示。 图2-4  头插法建立单链表 头插法建立单链表的算法如下： 复制纯文本复制 LinkList CreatList1(LinkList &
王道ch1-单链表的定义，创建，按序号查找，按值查找，插入，删除，求表长
比尔·盖薇的博客
10-11 497
定义 typedef struct LNode { int data; struct LNode* next; }LNode,*LinkList; 创建，分为头插法和尾插法 //单链表头插法 LinkList headInsert(LinkList& L) { int x; LNode* s; L = (LinkList)malloc(sizeof(LNode)); L...
单链表操作实现getelem_单链表的基本操作实现
weixin_39934085的博客
01-12 399
一：实现基本单链表这里想实现单链表的基本操作：1.构造空的单链表2.建立包含若干的数据元素的单链表3.求出表长4.获取第i个元素值5.数据元素的插入6.数据元素的删除7.输出顺序表等这里先定义单链表存储结构List；通过自定义函数实现单链表基本操作；然后调试运行程序。list.h#include #include #include #include #include #include // #in...
王道论坛2009-2012计算机统考数据结构真题解析
"王道论坛（www.cskaoyan.com）组织名校高手精心解析的数据结构试题集，涵盖了2009年至2012年计算机统考中的数据结构部分，包括真题和解析，旨在帮助备考研究生入学考试的学生复习和准备。" 在数据结构的学习中，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值