【数据结构】单链表解析+完整代码（插入、删除、尾插法、头插法、按值和按位查找、前插和后插）带头结点和不带两种实现

已于 2024-02-29 13:41:31 修改
阅读量778 收藏 13
点赞数 5
分类专栏： 数据结构 文章标签： 数据结构 链表 c++ 算法 c语言 c#
于 2024-02-29 10:45:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61628700/article/details/136364386
版权

文章目录

3.1 单链表

3.1.1 单链表的定义

  • 定义

    线性表的链式存储。

    • 结点结构：data+next（结点自身的数据＋指向后继的指针）

    • 特点：元素分散在内存中，非随机存取的存储结构。

    • 局限性：无法逆向检索，有时不方便。（双链表可双向检索）

//定义单链表节点类型
typedef struct LNode{
    ElemType data; //数据域
    Struct LNode *next; //指针域，指向下一个结点
}LNode,*LinkList;
//注：
//LNode —— 强调返回的是一个结点
//LinkList —— 强调的是一个单链表

  • 初始化——带头结点

    //带头结点初始化
bool InitList(LinkList &L){
    L=(LNode*)malloc(sizeof(LNode)); //为头结点分配内存
    if(L==NULL)return false; //内存不足，分配失败
    L->next=NULL; //头结点后还没有结点
    return true;
}

//带头结点判空
bool Empty(LinkList L){
    if(L->next==NULL)
        return true;
    else
        return false;
}

  • 初始化——不带头结点

    //不带头结点初始化
bool InitList(LinkList &L){
    L=NULL;
    return true;
}

//不带头结点判空
bool Empty(LinkList L){
    if(L==NULL)
        return true;
    else
        return false;
}

  • 带头结点和不带头结点的区别

    • 头结点：不存储数据，只指向链表中第一个结点的位置

    • 不带头结点，写代码麻烦。原因：

      1.带头结点后，链表第一个位置上的结点与其他位置的操作可以一致，不用特殊处理。

      2.空表和非空表的处理得到统一。

3.1.2 单链表的插入
A.按位序插入（带头结点）

  • 将值为e的新结点插入到位置i，步骤：

    1.找到要插入的位置，即第i-1个结点；

    2.在其后插入新结点，插入步骤如图：

bool ListInsert(LinkList &L,int i,ElemType e){
	if(i<1)return false;
    
    LNode *p; //指针p指向当前扫描到的结点
    int j=0; //记录当前p指向第几个结点
    p=L; //初始时，L指向头结点，头结点不存数据
    
    //循环找到第i-1个结点，即要插入的位置
    while(p!=NULL && j<i-1){
        p=p->next;
        j++;
    }
    if(p==NULL)return false;//i值不合法
    
    //插入结点
    LNode *s=(LNode*)malloc(sizeof(LNode)); //为要插入的结点开辟内存
    s->data=e; //将数值复值到新结点数据域
    s->next=p->next; //将新结点和后继结点连接
    p->next=s; //将新结点和前驱连接
    
    return true;
}
  • 时间复杂度： O ( n ) O(n) O(n)
B.按位序插入（不带头结点）

  • 在非第一个插入时，与带头结点相同。但插入第一位时不同，当在第一位插入时要重新赋值头结点。

  • 即在带头结点插入的基础上，插入以下一段即可：

bool ListInsert(LinkList &L,int i,ElemType e){
	if(i<1)return false;
    
    //插入第1个结点的操作与其它结点不同
    if(i==1){
        LNode *s=(LNode*)malloc(sizeof(LNode));
        s->data=e;
        s->next=L;
        L=s; //头指针指向新结点
        return true;
    }
    
    LNode *p; //指针p指向当前扫描到的结点
    int j=0; //记录当前p指向第几个结点
    p=L; //初始时，L指向头结点，头结点不存数据
    
    //循环找到第i-1个结点，即要插入的位置
    while(p!=NULL && j<i-1){
        p=p->next;
        j++;
    }
    if(p==NULL)return false;//i值不合法
    
    //插入结点
    LNode *s=(LNode*)malloc(sizeof(LNode)); //为要插入的结点开辟内存
    s->data=e; //将数值复值到新结点数据域
    s->next=p->next; //将新结点和后继结点连接
    p->next=s; //将新结点和前驱连接
    
    return true;
}
  • 时间复杂度： O ( n ) O(n) O(n)
  • 后续不做特殊说明，则默认为带头结点。
C.指定结点的后插操作

  • 即在指定结点p后，插入元素e。

    相当于在按位序插入的基础上，省去循环查找第i-1个结点的步骤。

bool InsertNextNode(LNode *p,ElemType e){
    if(p==NULL)return false;
    LNode *s=(LNode*)malloc(sizeof(LNode));
    if(s==NULL)return false;
    
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true;
}
  • 时间复杂度： O ( 1 ) O(1) O(1)
D.指定结点的前插操作

  • 方法一：

    传入头结点，遍历链表找到指定节点的前驱结点，再按后插的方式插入。

    • 时间复杂度： O ( n ) O(n) O(n)

  • 方法二： better!

    按后插的方式在指定结点后插入新结点，再交换指定节点和新结点的数值。

    • 时间复杂度： O ( 1 ) O(1) O(1)
    bool InsertPriorNode(LNode *p,ElemType e){
    if(p==NULL)return false;
    LNode *s=(LNode*)malloc(sizeof(LNode));
    if(s==NULL)return false;
    
    s->next=p->next;
    p->next=s; //连接s和p后
    s->data=p->data; //p数据复制到s
    p->data=e; //原s的数据给p
    return true;
}

    或者传入的是新结点，而不是数据时，也同理：

    bool InsertPriorNode(LNode *p,LNode *s){
    if(p==NULL||s==NULL)return false;
    
    s->next=p->next;
    p->next=s; //连接s和p后
    //交换值
    ElemType t=p->data;
    p->data=s->data;
    s->data=t;
    return true;
}
3.1.3 单链表的删除
A.按位序删除

  • 删除第i个结点的步骤

    1.找到要插入位置的前驱结点，即第i-1个结点。（如图，q是要删结点）

    2.将要删除结点从链表中断开，即前驱结点的next指向要删结点的后驱结点。

    3.释放已删除的结点空间。

bool ListDelete(LinkList &L,int i,ElemType &e){
    if(i<1)return false;
    LNode *p;
    p=L; //p从头开始扫描
    int j=0; //当前p指向第几个结点
    while(p!=NULL && j<i-1){
        p=p->next;
        j++;
    }
    if(p==NULL)return false; //i值不合法
    if(p->next==NULL)return false; //i-1后无结点
    
    LNode *q=p->next; //存储要删结点
    e=q->data; //e存储要删结点的值
    p->next=q->next; //将要删结点断开
    free(q);
    return true;
}
  • 时间复杂度： O ( n ) O(n) O(n)
B.删除指定结点

  • 方法：

    与指定结点的前插操作类似。

    1.交换指定结点和其后继结点的数据域；

    2.删除指定结点的后继结点。

    在这里插入图片描述

    • 时间复杂度： O ( 1 ) O(1) O(1)
bool DeleteNode(LNode*p){
    if(p=NULL)return false;
    
    LNode*q=p->next; //q指向指定结点p的后继
    p->data=p->next->data; //与后继结点交换数据
    p->next=q->next; //将q结点断开（q里存的是要删结点的数据）
    free(q);
    return true;
}

  • 注：

    若要删结点是最后一个结点，这样做有空指针的错误，只能用 从表头依次寻找p前驱的方法来删除。

3.1.4 单链表的查找
A.按位查找

  • 查找第i个元素

    从链表第一个开始往后循环查找。

    i是链表中元素下标。

LNode *GetElem(LinkList L,int i){
    if(i<0)return NULL;
    LNode *p=L;
    int j=0;
    while(p!=NULL&&j<i){
        p=p->next;
        j++;
    }
    return p;
}

  • 可以用于按位查找、删除中的封装：

B.按值查找

  • 找到数据域==e的结点

    时间复杂度： O ( n ) O(n) O(n)

LNode* LocateElem(LinkList L,ElemType e){
    LNode *p=L->next;
    while(p!=NULL&&p->data!=e)
        p=p->next;
    return p;
}
3.1.5 单链表的建立
A.尾插法

  • 步骤

    1.建立头结点（初始化）；

    2.定义两个结点：一个指向表头结点s，另一个指向表尾结点r；

    3.循环输入结点值，并为新结点开辟空间；

    4.在表尾结点后插入新结点；

    5.更新表尾结点r，保证r永远指向最后一个结点；

    6.退出循环后，尾结点置空。

LinkList List_TailInsert(LinkList &L){
    int x;
    L=(LNode*)malloc(sizeof(LNode)); //创建头结点
    LNode *s,*r=L; //s始终指向表头结点，r指向表尾结点
    
    scanf("%d",&x);
    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode)); //创建新结点
        s->data=x;
        r->next=s; //将新结点插入
        r=s; //更新表尾结点的指针，保持r指向最后一个结点
        scanf("%d",&x);
    }
    r->next=NULL; //尾结点指针制空
    return L;
}
B.头插法

  • 注：

    头插法的输入和链表的数据是逆置关系：

LinkList List_HeadInsert(LinkList &L){
    LNode *s;
    int x;
    L=(LNode*)malloc(sizeof(LNode)); //创建头结点
    L->next=NULL; //初始化空链表
    scanf("%d",&x);
    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode)); //创建新结点
        s->data=x;
        s->next=L->next;
        L->next=s; //更新第一个结点
        scanf("%d",&x);
    }
    return L;
}
*完整代码 单链表带头结点
#include<stdio.h>
#include<stdlib.h>

#define ElemType int

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

//初始化
bool InitList(LinkList& L) {
	L = (LNode*)malloc(sizeof(LNode));
	L->next = NULL;
	return true;
}

//求表长
int Length(LinkList L) {
	int len = 0;
	LNode* p = L;
	while (p->next != NULL) {
		len++;
		p = p->next;
	}
	return len;
}

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

//尾插法建立单链表
LinkList List_TailInsert(LinkList& L) {
	int x;
	L = (LNode*)malloc(sizeof(LNode)); //创建头结点
	LNode* s, * r = L; //s指向头结点，r指向尾结点
	scanf("%d", &x);
	while (x != 9999) {
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;
		scanf("%d", &x);
	}
	r->next = NULL;
	return L;
}

//按序查找
LNode* GetItem(LinkList& L, int i) {
	LNode* p = L->next; //头结点中没有元素，所以要从next开始算
	int j = 0;
	while (j < i && p != NULL) {
		p = p->next;
		j++;
	}
	return p;
}

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

//按位序插入
bool ListInsert(LinkList& L, int i, ElemType e) {
	if (i < 0)return false;

	LNode* p = L;
	int j = 0;
	while (j < i-1 && p!= NULL) {
		p = p->next;
		j++;
	}
	if (p == NULL)return false;

	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

//指定结点后插操作
bool InsertNextNode(LNode* p, ElemType e) {
	if (p == NULL)return false;

	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

//指定结点前插操作
bool InsertPriorNode(LNode* p, ElemType e) {
	if (p == NULL )return false;

	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->next = p->next;
	p->next = s;
	s->data = p->data;
	p->data = e;
	return true;
}

//按位序删除
bool ListDelete(LinkList& L, int i, ElemType& e) {
	LNode* p = L;
	int j=0;
	while (j < i-1 && p != NULL) {
		p = p->next;
		j++;
	}
	if (p == NULL||p->next==NULL)return false;

	LNode* q = p->next;
	e = q->data;
	p->next = q->next;
	free(q);
	return true;
}

//删除指定结点
bool DeleteNode(LNode* p) {
	if (p == NULL)return false;

	LNode* q = p->next;
	p->data = p->next->data;
	p->next = q->next;
	free(q);
	return true;
}

void PrintList(LinkList& L) {
	LNode* p = L->next;
	while (p != NULL) {
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n\n");
}

void DestroyList(LinkList& L) {
	LNode* p = L;
	while (L) {
		p = L;
		L = L->next;
		free(p);
	}
}

int main() {
	LinkList L;

	printf("头插法建立单链表，输入以9999结束：\n");
	L=List_HeadInsert(L);
	PrintList(L);

	DestroyList(L);
	printf("尾插法建立单链表，输入以9999结束：\n");
	L=List_TailInsert(L);
	PrintList(L);

	printf("求表长：%d\n",Length(L));
	printf("\n");

	printf("按位序插入：\n");
	int pos=1, e=998;
	ListInsert(L, pos, e);
	PrintList(L);

	printf("指定结点的后插操作：\n");
	LNode* p =L->next;
	e = 222;
	InsertNextNode(p, e);
	PrintList(L);

	printf("指定结点的前插操作：\n");
	p = L->next;
	e = 111;
	InsertPriorNode(p, e);
	PrintList(L);

	printf("按值查找：\n");
	printf("查找222的位序是：%d\n", LocateElem(L, 222));
	printf("\n");

	printf("按序查找：\n");
	LNode* q = GetItem(L, 2);
	printf("查找第3个元素值是：%d\n", q->data);
	printf("\n");

	printf("按位序删除：\n");
	int ee;
	ListDelete(L, pos, ee);
	printf("删除的结点值：%d\n", ee);
	PrintList(L);

	printf("按指定结点删除：\n");
	p = L->next;
	DeleteNode(p);
	PrintList(L);
}

在这里插入图片描述

*完整代码 单链表不带头结点
#include<stdio.h>
#include<stdlib.h>

#define ElemType int

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

//初始化
bool InitList(LinkList& L) {
	L=NULL;
	return true;
}

//求表长
int Length(LinkList L) {
	int len = 0;
	LNode* p = L;
	while (p!= NULL) {
		len++;
		p = p->next;
	}
	return len;
}

//头插法建立单链表
LinkList List_HeadInsert(LinkList& L) {
	L= NULL;
	LNode* s;
	int x;

	//第一个结点要特殊判断
	scanf("%d", &x);
	L = (LNode*)malloc(sizeof(LNode));
	L->data = x;
	L->next = NULL;

	scanf("%d", &x);
	while (x != 9999) {
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		s->next = L;
		L = s;
		scanf("%d", &x);
	}
	return L;
}

//尾插法建立单链表
LinkList List_TailInsert(LinkList& L) {
	int x;
	L = NULL;

	//第一个结点要特殊判断
	scanf("%d", &x);
	L = (LNode*)malloc(sizeof(LNode));
	L->data = x;
	L->next = NULL;

	LNode* s, * r = L; //s指向头结点，r指向尾结点
	scanf("%d", &x);
	while (x != 9999) {
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;
		scanf("%d", &x);
	}
	r->next = NULL;
	return L;
}

//按序查找
LNode* GetItem(LinkList& L, int i) {
	LNode* p = L;
	int j = 0;
	while (j < i && p != NULL) {
		p = p->next;
		j++;
	}
	return p;
}

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

//按位序插入
bool ListInsert(LinkList& L, int i, ElemType e) {
	if (i < 0)return false;

	//插入第1个结点的操作与其它结点不同
	if (i == 1) {
		LNode* s = (LNode*)malloc(sizeof(LNode));
		s->data = e;
		s->next = L;
		L = s; //头指针指向新结点
		return true;
	}

	LNode* p = L;
	int j = 0;
	while (j < i - 1 && p != NULL) {
		p = p->next;
		j++;
	}
	if (p == NULL)return false;

	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

//指定结点后插操作
bool InsertNextNode(LNode* p, ElemType e) {
	if (p == NULL)return false;

	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

//指定结点前插操作
bool InsertPriorNode(LNode* p, ElemType e) {
	if (p == NULL)return false;

	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->next = p->next;
	p->next = s;
	s->data = p->data;
	p->data = e;
	return true;
}

//按位序删除
bool ListDelete(LinkList& L, int i, ElemType& e) {
	if (i < 1)return false;

	//删除第1个结点的操作与其它结点不同
	if (i == 1) {
		e = L->data;
		LNode* s = L;
		L = L->next;
		free(s);
		return true;
	}

	LNode* p = L;
	int j = 0;
	while (j < i - 1 && p != NULL) {
		p = p->next;
		j++;
	}
	if (p == NULL || p->next == NULL)return false;

	LNode* q = p->next;
	e = q->data;
	p->next = q->next;
	free(q);
	return true;
}

//删除指定结点
bool DeleteNode(LNode* p) {
	if (p == NULL)return false;

	LNode* q = p->next;
	p->data = p->next->data;
	p->next = q->next;
	free(q);
	return true;
}

void PrintList(LinkList& L) {
	LNode* p = L;
	while (p != NULL) {
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n\n");
}

void DestroyList(LinkList& L) {
	LNode* p = L;
	while (L) {
		p = L;
		L = L->next;
		free(p);
	}
}

int main() {
	LinkList L;

	printf("头插法建立单链表，输入以9999结束：\n");
	L = List_HeadInsert(L);
	PrintList(L);

	DestroyList(L);
	printf("尾插法建立单链表，输入以9999结束：\n");
	L = List_TailInsert(L);
	PrintList(L);

	printf("求表长：%d\n", Length(L));
	printf("\n");

	printf("按位序插入：\n");
	int pos = 1, e = 998;
	ListInsert(L, pos, e);
	PrintList(L);

	printf("指定结点的后插操作：\n");
	LNode* p = L;
	e = 222;
	InsertNextNode(p, e);
	PrintList(L);

	printf("指定结点的前插操作：\n");
	p = L;
	e = 111;
	InsertPriorNode(p, e);
	PrintList(L);

	printf("按值查找：\n");
	printf("查找222的位序是：%d\n", LocateElem(L, 222));
	printf("\n");

	printf("按序查找：\n");
	LNode* q = GetItem(L, 2);
	printf("查找第3个元素值是：%d\n", q->data);
	printf("\n");


	printf("按位序删除：\n");
	int ee;
	ListDelete(L, pos, ee);
	printf("删除的结点值：%d\n", ee);
	PrintList(L);

	printf("按指定结点删除：\n");
	p = L;
	DeleteNode(p);
	PrintList(L);
}

在这里插入图片描述

吧啦吧啦嘭
关注
  • 5
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表的基本操作头插法尾插法创建插入删除遍历
12-08
单链表的基本操作，单链表头插法、尾插法、创建、插入、删除、遍历
cpp代码-单链表的建立（头插法、尾插法）
07-14
cpp代码-单链表的建立（头插法、尾插法）
数据结构：图文详解单链表的各种操作（头插法，尾插法，任意位置插入，删除节点，查询节点，求链表的长度，清空链表）
luming的博客
12-02 2133
链表是一种数据结构，它由一系列节点（node）构成，每个节点中包含了数据（data）和指向下一个节点的指针（next）。链表中的节点可以在内存中任何位置，它们通过指针链接在一起，形成一个链式结构。链表相对于数组的优点在于它可以动态地增加、删除节点，而不需要移动大量的数据。链表的缺点是访问元素时需要遍历整个链表，效率较低。
带头结点单链表【详细解析+完整代码】
ChenLin55的博客
05-16 2184
链表是通过一组任意的储存单元来存储线性表中的数据元素。为建立线性关系，每个结点需要一个指针域以及指向下一结点的指针域。带头结点链表头节点不存储数据。
带头节点循环单链表【详细解析+完整代码】
ChenLin55的博客
05-17 4640
循环单链表在单链表的基础上进行改进。思考一下，普通单链表从表头遍历到表尾，时间复杂度为o(n)，如果我想从表尾找到表头呢？时间复杂度也还是o(n)。怎么快速从表尾找到表头，于是引入了循环链表。整个链表形成闭环，表尾找到表头，时间复杂度为o(1)。循环单链表是首尾相连的一种单链表，即将最后一个结点的空指针改为指向头结点或第一个结点的形成一个环型，最后一个结点称为尾指针:tail。判断单链表为空的条件是 head->next == NULL，而判断循环单链表为空的条件是。
带头结点双链表【详细解析+完整代码】
ChenLin55的博客
05-16 1245
单链表的结点中只有一个指向其后继的指针，使得单链表要访问某个结点的前驱结点时，只能从头开始遍历，访问后驱结点的复杂度为O(1)，访问前驱结点的复杂度为O(n)。为了克服上述缺点，引入了双链表。双链表的结点中有两个指针prior和next，分别指向前驱结点和后继结点。
【数据结构】：单链表之增删改查求表长（带头结点和不带头结点均有）
仔仔木的博客
07-10 2863
对单链表的增删改查求表长、C语言、有图解、带头结点和不带头结点
单链表的基本操作代码实现(C语言版)
热门推荐
m0_67647682的博客
08-04 3万+
单链表基本操作取值、按值查找返回元素所在地址、按值查找返回元素所对应序号、结点插入和删除以及头插法和尾插法建立单链表等的实现与解析，链表学习记录。
使用C语言写带头结点的链表，含有创建、输出、查找、删除、插入、合并
hua_you_qiang的博客
03-15 4570
用C语言写出带头结点的链表那些带头结点的链表的题目必要代码定义一个结构体创建一个带头结点的单链表 今天有一位学弟在网上向我吐血求助，让我帮他写c语言带头结点的链表题目。 我想了想，c语言我有一年半载没有接触了。正好温习温习一下，就写下此博客，来回顾一下我学习c语言的汗(Lei)水(Shui)与快(Tong)乐(Ku)。尽管我没有老师写的那么详尽，也没有教科书式的讲的那么专业。但我是站在学生的角度去...
数据结构考研 单链表、双链表、循环链表和静态链表的习题
weixin_42060159的博客
04-21 3584
单链表、双链表、循环链表和静态链表的习题 一、单项选择题 1.关于线性表的顺序存储结构和链式存储结构的描述中，正确的是（ ）。 Ⅰ.线性表的顺序存储结构优于其链式存储结构 Ⅱ.链式存储结构比顺序存储结构能更方便地表示各种逻辑结构 Ⅲ.如频繁使用插入和删除结点操作，顺序存储结构更优于链式存储结构 Ⅳ.顺序存储结构和链式存储结构都可以进行顺序存取 A. Ⅰ、Ⅱ、Ⅲ B. Ⅱ、Ⅳ C. Ⅱ、Ⅲ D. Ⅲ、Ⅳ 本人计算机方向研二在读—— 数据结构专业课可一对一辅导 有辅导经验 直系学长 无
数据结构选择练习题（有解析）
沉在海里的鱼的博客
12-23 1万+
目录 前言 选择题与答案与解析 实验1 线性表 实验2 栈和队列 实验3 二叉树 实验4 二叉搜索树与平衡二叉树 实验5 散列查找 实验6 图的存储与遍历 实验7 最小生成树 实验8 快速排序与归并排序 结语 前言 已经到期末了，昨天进行了一次马原考试，那时候挺紧张的，那时候虽然写完了试卷，但是又4道题是乱写的，因为我刚好没有背，希望不会挂科吧。 然后今天呢，就开始复习数据结构了，然后发现数据结构这学期进行的8次实验的选择题竟然...
ListLink.rar_stl list_单链表_单链表 插入 删除 查找_链表 插入
09-14
数据结构单链表的实现,包含链表元素的删除,查找,插入
单链表的建立、插入、删除、查找.rar_单链表的建立、插入、删除、查找_插入删除
09-23
用C++，实现单链表的建立、插入、删除、查找功能
数据结构单链表的创建，插入，修改，查找以及删除
10-24
数据结构单链表的创建，插入，修改，查找以及删除。线性表操作
数据结构——AVL树
mastershooter的博客
05-16 955
在结点的定义中，我们直接定义成KV模型的结点，并新增一个平衡因子，还有一个_parent指针，也就是说，该结点拥有三个指针+一对键值对+一个平衡因子，在初始化时指针都初始化为空，平衡因子设定成0。//左子树指针//右子树指针//每个结点都包含了一个父结点地址//键值对int _bf;//平衡因子//构造函数, _kv(kv), _bf(0){}
【java-数据结构-栈和队列】
2302_80519942的博客
05-13 587
上篇文章，我们已经完成链表的收尾工作，从本篇文章开始，将进入栈和队列的学习，j觉得小编写的还可以的可以留个关注支持一下~话不多说，上正文~
图论算法＜六＞：数据结构之图Graph详解及代码实现
最新发布
欧特GO
05-16 708
数据结构之图Graph详解及代码实现,包括概念、术语、基础实现代码、BFS/DFS。
Java数据结构单链表 按位插入
05-20
单链表按位插入的思路是先找到要插入的位置，然后将新节点插入到该位置。 具体实现步骤如下： 1. 判断要插入的位置是否合法，如果不合法则直接返回； 2. 找到要插入位置的前一个节点，可以使用循环遍历或者递归查找的方法； 3. 创建新节点，并将新节点的next指针指向前一个节点的next节点； 4. 将前一个节点的next指针指向新节点，完成插入操作。 Java代码实现： ``` public void insertByIndex(int index, Object data) { if (index < 1 || index > size + 1) { System.out.println("插入位置不合法！"); return; } Node newNode = new Node(data); if (index == 1) { // 插入到链表头部 newNode.next = head; head = newNode; } else { // 插入到链表中间或尾部 Node preNode = getNodeByIndex(index - 1); // 找到要插入位置的前一个节点 newNode.next = preNode.next; preNode.next = newNode; } size++; } // 根据下标查找节点 private Node getNodeByIndex(int index) { if (index < 1 || index > size) { System.out.println("查找位置不合法！"); return null; } Node node = head; for (int i = 1; i < index; i++) { node = node.next; } return node; } ``` 注意事项： 1. 插入位置不合法时需要进行判断并给出提示； 2. 插入到链表头部和中间的情况需要分别处理； 3. 插入操作完成后，需要将链表长度size加1。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值