数据结构基础

最新推荐文章于 2022-02-15 00:30:00 发布
最新推荐文章于 2022-02-15 00:30:00 发布
阅读量276 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54670782/article/details/120183081
版权

链表

struct Student
{
char name[20];
struct B // 上面有名字 底下没有 不占空间 结构体定义==数据类型
// 24字节 数据类型不占空间
{
int a;
};
int age;
};

struct Student
{
char name[20];
struct // 上面没有名字 底下有 占空间
// 28字节
{
int a;
}B;
int age;
};

struct Student
{
char name[20];
struct B // 上面有名字 底下有 占空间
// 28字节
{
int a;
}B;
int age;
};

struct Student
{
char name[20];
struct // 上面没有名字 底下没有 占空间
// 28字节
{
int a;
};
int age;
};

双向链表
为什么要有双向链表？ 因为单链表有自身局限性（只能向后跑，不也能向前跑）
双向链表是啥？ 和单链表相比，多了一个直接前驱指针
在这里插入图片描述

特殊情况（容易出错的点）：
正常来说单链表需要处理2根线 而双向链表需要处理4根线
但是头插函数比较特殊，需要防止出现空链表导致少处理一根线
按位置删除函数也比较特殊，有可能删除的是最后一个节点
头删函数比较特殊 有可能只有一个有效节点需要删除

如果需要前驱 一般用于插入和删除操作等等
for(DNode *p=plist; p->next!=NULL; p=p->next);
如果不需要前驱 一般用于查找和打印
for(DNode *p=plist->next; p!=NULL; p=p->next);

dlist.h

#pragma once

typedef int ELEMTYPE;
typedef struct DNode
{
	int data;//数据域
	struct DNode* next;//直接后继指针；
	struct DNode* prior;//新添加的：直接前驱指针
}DNode,*PDNode;
//双向链表的函数声明:
//增删改查

//初始化
void Init_dlist(PDNode plist);//Node * == PDNode

//头插
bool Insert_head(PDNode plist, int val);

//尾插
bool Insert_tail(PDNode plist, int val);

//按位置插入  pos  
bool Insert_pos(PDNode plist, int pos, int val);

//头删
bool Del_head(PDNode plist);

// 尾删
bool Del_tail(PDNode plist);

//按位置删除 pos 
bool Del_pos(PDNode plist, int pos);

//按值删除 遇到值为val的第一个有效节点 删除掉 释放其内存
bool Del_val(PDNode plist, int val);

//查找search 查找值我val的第一个节点，返回其地址
struct DNode* Search(PDNode plist, int val);

//寻找值为val的节点的前驱
PDNode Get_prior(PDNode plist, int val);

//寻找值为val的节点的后继
PDNode Get_next(PDNode plist, int val);

//判空
bool IsEmpty(PDNode plist);

dlist.cpp

#include<stdio.h>
#include<assert.h>
#include<malloc.h>
#include"dlist.h"

//初始化
void Init_dlist(PDNode plist)//Node * == PDNode
{
	assert(plist != NULL);
//	plist->data; 不使用  所以不需要初始化
	plist->next = NULL;
	plist->prior =NULL;
}

//头插
bool Insert_head(PDNode plist, int val)
{
	assert(plist != NULL);
	//1.创造新结点
	DNode* pnewnode = (DNode*)malloc(sizeof(DNode) * 1);
	assert(pnewnode != NULL);
	pnewnode->data = val;
	//2.找到合适的插入位置
	// 这个函数是头插 所以这一步不做处理
	//3.插入(双向链表的头插比较特殊，因为有可能只需要修改3条线）
	//3.1先处理自身两条线
	//3.2再处理特殊的那条线（下一个结点的前驱线）
	//3.3再处理头结点的next线
	pnewnode->next = plist->next;
	pnewnode->prior = plist;
	if (plist->next != NULL)
	{
		plist->next->prior = pnewnode;
	}
	plist->next = pnewnode;
	/*  这个代码正确
	pnewnode->next = plist->next;
	pnewnode->prior = plist;
	plist->next = pnewnode;
	//特殊的一步：有可能是个空链表，导致不需要更改下一个结点的前驱
	if (pnewnode->next != NULL)
	{
		pnewnode->next->prior = pnewnode;
	}
	*/
	return true;
}

//尾插
bool Insert_tail(PDNode plist, int val)
{
	assert(plist != NULL);
	//申请新节点
	DNode* pnewnode = (DNode*)malloc(sizeof(DNode) * 1);
	assert(pnewnode != NULL);
	pnewnode->data = val;
	//找到插入位置
	DNode* p = plist;
	for (p; p->next != NULL; p = p->next);
		//插入
		pnewnode->next = p->next;//pnewnode->next=NULL;
		pnewnode->prior = p;
		p->next = pnewnode;
		return true;
}

//按位置插入  pos  
bool Insert_pos(PDNode plist, int pos, int val)
{
	assert(plist != NULL);
	if (pos<0 || pos>Get_length(plist))
		return false;
	//1.申请新节点
	DNode* pnewnode = (DNode*)malloc(sizeof(DNode) * 1);
	assert(pnewnode != NULL);
	pnewnode->data = val;
	//2.找到插入位置 pos
	DNode* p = plist;
	for (int i = 0; i < pos; i++)
	{
		p = p->next;
	}
	//3. 插入
	pnewnode->next = p->next;
	pnewnode->prior = p;
	if (p->next != NULL)
	{
		p->next->prior = pnewnode;
	}
	p->next = pnewnode;
	return true;
}


//头删  需要更改两条线 第三条和第四条
bool Del_head(PDNode plist)
{
	assert(plist != NULL && plist->next != NULL);
	if (plist == NULL || plist->next == NULL)
		return false;
	DNode* p = plist->next;
	if (p->next != NULL)
	{
		p->next->prior = plist;//第三条线
	}
	plist->next = p->next;//第四条线
	free(p);
	p = NULL;
	return true;
}


//尾删
bool Del_tail(PDNode plist)
{
	assert(plist != NULL);
	//找到删除的结点
	DNode* p = plist;
	for (p; p->next != NULL; p = p->next);//这里for循环执行完 p指向最后一个节点
	//删除：1.变更连线 2.以及释放内存
		p->prior->next = NULL;
	free(p);
	p = NULL;
	return true;
}
//按位置删除 pos 
bool Del_pos(PDNode plist, int pos)
{
	assert(plist != NULL);
	if (pos < 0 || pos >= Get_length(plist))
		return false;
	//1.找到删除的结点
	DNode* p = plist;
	for (int i = 0; i <=pos; i++)
	{
		p = p->next;
	}//此时for循环执行完毕后 p不再是指向待删除结点的前驱，而是直接指向待删除结点

	//2.删除：1.更改连线 2.释放内存
	if (p->next != NULL)//如果待删除结点的下一个节点存在
	{
		p->next->prior = p->prior;
	}
	p->prior->next = p->next;
	free(p);
	p = NULL;
	return true;
}

//按值删除 遇到值为val的第一个有效节点 删除掉 释放其内存
bool Del_val(PDNode plist, int val)
{
	assert(plist != NULL);
	//1.通过search函数找到这个值为val的节点
	DNode* p = Search(plist, val);
	if (p == NULL)
	{
		return false;
	}
	//2.删除
	if (p->next != NULL)//如果待删除结点的下一个节点存在
	{
		p->next->prior = p->prior;
	}
	p->prior->next = p->next;//更改前驱节点的next域
	free(p);
	p = NULL;
	return true;
}

//查找search 查找值我val的第一个节点，返回其地址
struct DNode *Search(PDNode plist, int val)
{
	assert(plist != NULL);
	DNode* p = plist->next;
	for (p; p != NULL; p = p->next)
	{
		if (p->data == val)
		{
			return p;
		}
	}
	return NULL;
}

//寻找值为val的节点的前驱
PDNode Get_prior(PDNode plist, int val)
{
	assert(plist != NULL);
	DNode* p = Search(plist, val);
	
	return p == NULL ? NULL : p->prior;
}

//寻找值为val的节点的后继
PDNode Get_next(PDNode plist, int val)
{
	assert(plist != NULL);
	DNode* p = Search(plist, val);

	return p == NULL ? NULL : p->next;
}

//判空
bool IsEmpty(PDNode plist)
{
	assert(plist != NULL);
	return plist->next == NULL;
}


//获取其有效值长度
int Get_length(PDNode plist)
{
	assert(plist != NULL);
	int count = 0;
	for (DNode* p = plist->next; p != NULL; p = p->next)
	{
		count++;
	}
	return count;
}

//清空
void Clear(PDNode plist)
{
	Destroy(plist);
}

//销毁 不需要更改下一个节点的前驱  只需要沿着next这条线全部释放掉即可
//1.一直头删  2.不需要头结点参与释放
//第一种方法简单：原因是第一种方法只使用了一个临时指针，而第二种方法使用了两个临时指针
void Destroy(PDNode plist)
{
	assert(plist != NULL);
	while (plist->next != NULL)
	{
		DNode* p = plist->next;
		plist->next = p->next;
		free(p);
	}
}
void Destroy2(PDNode plist)
{
	assert(plist != NULL);
	DNode* p = plist->next;
	DNode* q = NULL;
	plist->next = NULL;
	while (p != NULL)
	{
		q = p->next;
		free(p);
		p = q;
	}
}

//打印
void Show(PDNode plist)
{
	for (DNode* p = plist->next; p != NULL; p = p->next)
	{
		printf("%d", p->data);
	}
	printf("\n");
}

循环链表

循环链表，将单链表中终端结点的指针由空指针改为指向头结点，就使整个单链表形成一个环，这种头尾相接的单链表称为单循环链表，简称循环链表。
在这里插入图片描述

clist.h

//clist == circle list
#pragma once

//循环链表（相比较单链表，唯一的区别，就是让最后一个节点的next域不再指向NULL，而是指向头结点）

//循环链表的结构体定义
typedef int ELEM_TYPE;
typedef struct CNode
{
	ELEM_TYPE data;
	struct CNode* next;
}CNode, * PClist;

//循环链表可执行的操作：（增删改查）
//初始化
void Init_clist(PClist pl);

//头插
bool Insert_head(PClist pl, int val);

//尾插
bool Insert_tail(PClist pl, int val);

//按位置插入
bool Insert_pos(PClist pl, int pos, int val);

//头删
bool Del_head(PClist pl);

//尾删
bool Del_tail(PClist pl);

//按位置删除
bool Del_pos(PClist pl, int pos);

//按值删除，删除遇到的第一个值为val的节点 如果值为val的节点不存在，则返回false
bool Del_val(PClist pl, int val);

//查找  查找值为val的第一个节点，找到则返回其节点地址，否则返回NULL
struct CNode* Search(PClist pl, int val);

//判空
bool IsEmpty(PClist pl);

//获取循环链表有效元素个数
int Get_length(PClist pl);

//打印
void Show(PClist pl);

//清空
void Clear(PClist pl);

//销毁1 一直头删的方式释放内存
void Destroy(PClist pl);

//销毁2
void Destroy2(PClist pl);

//寻找值为val的节点的前驱
PClist Get_prior(PClist pl, int val);

//寻找值为val的节点的后继
PClist Get_next(PClist pl, int val);

clist.cpp

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include"clist.h"

//初始化
void Init_clist(PClist pl)
{
	assert(pl != NULL);
	if (pl == NULL)
		return;

	//pl->data; 头结点的数据域不使用
	pl->next = pl;
}

//头插
bool Insert_head(PClist pl, int val)
{
	//assert pl

	//1.申请新节点
	CNode* pnewnode = (CNode*)malloc(sizeof(CNode) * 1);
	assert(pnewnode != NULL);
	pnewnode->data = val;

	//2.找到合适的插入位置
	//因为是头插函数 所以不需要找它的插入位置

	//3.插入
	pnewnode->next = pl->next;
	pl->next = pnewnode;

	return true;
}

//尾插
bool Insert_tail(PClist pl, int val)
{
	//assert
	//1.申请新节点
	CNode* pnewnode = (CNode*)malloc(sizeof(CNode));
	assert(pnewnode != NULL);
	pnewnode->data = val;

	//2.找到合适的插入位置
	CNode* p = pl;
	for (p; p->next != pl; p = p->next);//for循环执行完毕后 p就指向了最后一个节点

	//3.插入
	pnewnode->next = p->next;//pnewnode->next = pl;
	p->next = pnewnode;

	return true;
}

//按位置插入
bool Insert_pos(PClist pl, int pos, int val)
{
	//assert pl pos
	if (pos<0 || pos>Get_length(pl))
		return false;

	//1.申请新节点
	CNode* pnewnode = (CNode*)malloc(sizeof(CNode) * 1);
	assert(pnewnode != NULL);
	pnewnode->data = val;

	//2.找到合适的插入位置
	CNode* p = pl;
	for (int i = 0; i < pos; i++)
	{
		p = p->next;
	}

	//3.插入
	pnewnode->next = p->next;
	p->next = pnewnode;

	return true;
}

//头删
bool Del_head(PClist pl)
{
	//assert

	//1.找到删除节点的前驱
	if (pl->next == pl)
		return false;

	//2.删除节点（2.1改变节点指向 2.2释放内存）
	CNode* p = pl->next;
	pl->next = p->next;
	free(p);
	p = NULL;

	return true;
}

//尾删
bool Del_tail(PClist pl)
{
	assert(pl != NULL && pl->next != pl);//断言头结点存在  断言不能光头结点存在
	if (pl == NULL || pl->next == pl)
	{
		return false;
	}

	//1.找到删除节点的前驱  走一步看两步
	CNode* p = pl;
	for (p; p->next != pl; p = p->next)//走一步
	{
		if (p->next->next == pl)//看两步
		{
			break;//for while  switch
		}
	}
	//2.删除节点
	CNode* q = p->next;
	p->next = q->next;//p->next = pl;
	free(q);
	q = NULL;

	return true;
}

//按位置删除
bool Del_pos(PClist pl, int pos)
{
	//assert pl pos
	if (pl == NULL || pos < 0 || pos >= Get_length(pl))
		return false;

	//1.找到删除节点的前驱
	CNode* p = pl;
	for (int i = 0; i < pos; i++)
	{
		p = p->next;
	}

	//2.删除
	CNode* q = p->next;
	p->next = q->next;
	free(q);
	q = NULL;

	return true;
}

//按值删除，删除遇到的第一个值为val的节点 如果值为val的节点不存在，则返回false
bool Del_val(PClist pl, int val)
{
	//assert
	//1.通过调用Get_prior函数来获取删除节点的前驱
	CNode* p = Get_prior(pl, val);
	if (p == NULL)
	{
		return false;
	}
	//2.删除

	CNode* q = p->next;
	p->next = q->next;
	free(q);
	q = NULL;

	return true;
}

//查找  查找值为val的第一个节点，找到则返回其节点地址，否则返回NULL
struct CNode* Search(PClist pl, int val)
{
	//assert
	CNode* p = pl->next;
	for (p; p != pl; p = p->next)
	{
		if (p->data == val)
		{
			return p;
		}
	}
	return NULL;
}

//判空
bool IsEmpty(PClist pl)
{
	//return pl->next == NULL; 单链表的判空
	return pl->next == pl;//循环链表的判空
}

//获取循环链表有效元素个数
int Get_length(PClist pl)
{
	//assert
	int count = 0;
	for (CNode* p = pl->next; p != pl; p = p->next)
	{
		count++;
	}
	return count;
}

//打印
void Show(PClist pl)
{
	//assert
	for (CNode* p = pl->next; p != pl; p = p->next)
	{
		printf("%d ", p->data);
	}
	printf("\n");
}

//清空
void Clear(PClist pl)
{
	Destroy(pl);
}

//销毁1 一直头删的方式释放内存
void Destroy(PClist pl)
{
	//assert
	while (pl->next != pl)
	{
		CNode* p = pl->next;
		pl->next = p->next;
		free(p);
	}
}

//销毁2
void Destroy2(PClist pl)
{
	//assert
	assert(pl != NULL && pl->next != pl);

	CNode* p = pl->next;
	CNode* q = NULL;

	while (p != pl)
	{
		q = p->next;
		free(p);
		p = q;
	}

	pl->next = pl;
}

//寻找值为val的节点的前驱
PClist Get_prior(PClist pl, int val)
{
	//assert
	CNode* p = pl;
	for (p; p->next != pl; p = p->next)
	{
		if (p->next->data == val)
		{
			return p;
		}
	}
	return NULL;
}

//寻找值为val的节点的后继
PClist Get_next(PClist pl, int val)
{
	//assert
	CNode* p = Search(pl, val);
	/*if(p == NULL)
		return NULL;
	return p->next;*/

	return p == NULL ? NULL : p->next;
}

双向循环链表
双向循环链表和双向链表的区别:
1.最后一个节点的next指针不再指向NULL 而是指向头结点
2.头结点的prior指针不再指向NULL，而是指向尾结点

在这里插入图片描述

dclist.h

#pragma once
typedef int ELEM_TYPE;
typedef struct DCList
{
	ELEM_TYPE data;//数据域
	struct DCList* next;//后继指针
	struct DCList* prior;//前驱指针
}DCList, * PDClist;

//循环链表可执行的操作：（增删改查）
//初始化
void Init_dclist(PDClist pl);

//头插
bool Insert_head(PDClist pl, int val);

//尾插
bool Insert_tail(PDClist pl, int val);

//按位置插入
bool Insert_pos(PDClist pl, int pos, int val);

//头删
bool Del_head(PDClist pl);

//尾删
bool Del_tail(PDClist pl);

//按位置删除
bool Del_pos(PDClist pl, int pos);

//按值删除，删除遇到的第一个值为val的节点 如果值为val的节点不存在，则返回false
bool Del_val(PDClist pl, int val);

//查找  查找值为val的第一个节点，找到则返回其节点地址，否则返回NULL
PDClist Search(PDClist pl, int val);

//判空
bool IsEmpty(PDClist pl);

//获取循环链表有效元素个数
int Get_length(PDClist pl);

//打印
void Show(PDClist pl);

//清空
void Clear(PDClist pl);

//销毁1 一直头删的方式释放内存
void Destroy(PDClist pl);

//销毁2
void Destroy2(PDClist pl);

//寻找值为val的节点的前驱
PDClist Get_prior(PDClist pl, int val);

//寻找值为val的节点的后继
PDClist Get_next(PDClist pl, int val);

dclist.cpp

#include <stdio.h>
#include <malloc.h>
#include <assert.h>
#include "dclist.h"


//循环链表可执行的操作：（增删改查）
//初始化
void Init_dclist(PDClist pl)
{
	assert(pl != NULL);
	if (NULL == pl)
		return;

	//pl->data; 头结点的数据域不使用 浪费掉
	pl->next = pl;
	pl->prior = pl;
}

DCList* BuyNode(int val)
{
	DCList* pnewnode = (DCList*)malloc(sizeof(DCList) * 1);
	assert(pnewnode != NULL);
	pnewnode->data = val;
	pnewnode->next = NULL;
	pnewnode->prior = NULL;

	return pnewnode;
}
//头插
bool Insert_head(PDClist pl, int val)
{
	//1.assert
	assert(pl != NULL);
	if (pl == NULL)
		return false;
	//2.申请新节点
	DCList* pnewnode = BuyNode(val);
	assert(pnewnode != NULL);

	//3.插入
	pnewnode->next = pl->next;
	pnewnode->prior = pl;

	if (pl->next != pl)//证明在头插之前，就至少存在一个有效节点
	{
		pl->next->prior = pnewnode;
	}

	pl->next = pnewnode;

	//下面的代码是对比双向链表新加入的代码
	if (pl->prior == pl)//（1.如果插入之前就有有效节点，则这个指针不需要修改 2.如果是个空的链表，则这个指针需要做修改）
	{
		pl->prior = pnewnode;//是让pl->prior 永远指向最后一个节点
	}

	return true;
}

//尾插
bool Insert_tail(PDClist pl, int val)
{
	//1.assert
	//2.创建新节点
	DCList* pnewnode = BuyNode(val);
	assert(pnewnode != NULL);

	//3.找到合适的插入位置
	DCList* p = pl;
	for (pl; p->next != pl; p = p->next);
	//此时 for循环执行结束，代表指针p此时指向最后一个节点

	//4.插入节点
	pnewnode->next = p->next;//pnewnode->next = pl;
	pnewnode->prior = p;

	p->next = pnewnode;

	//下面的代码是对比双向链表新加入的代码
	pl->prior = pnewnode;//因为是尾插函数，所以每次都得让pl->prior重新指向最后一个有效节点（新插入的节点）

	return true;
}

//按位置插入
bool Insert_pos(PDClist pl, int pos, int val)
{
	//1.assert  pl pos
	//2.申请新的节点
	DCList* pnewnode = BuyNode(val);
	assert(pnewnode != NULL);

	//3.找到合适的插入位置
	DCList* p = pl;
	for (int i = 0; i < pos; i++)
	{
		p = p->next;
	}

	//4.插入
	pnewnode->next = p->next;
	pnewnode->prior = p;
	if (p->next != pl)
	{
		p->next->prior = pnewnode;
	}
	else///else的代码是对比双向链表新加入的代码
	{
		pl->prior = pnewnode;
	}

	p->next = pnewnode;

	return true;
}

//头删
bool Del_head(PDClist pl)
{
	//1.assert
	assert(pl != NULL && pl->next != pl);
	if (pl == NULL || pl->next == pl)
	{
		return false;
	}

	//2.找到删除的位置
	//3.删除
	DCList* p = pl->next;
	if (p->next == pl)//删除的节点就是仅存的节点
	{
		pl->next = pl->prior = pl;
		free(p);
		p = NULL;
	}
	else//删除的节点不是仅存的节点
	{
		pl->next = p->next;
		p->next->prior = pl;
		free(p);
		p = NULL;
	}

	return true;
}

//尾删
bool Del_tail(PDClist pl)
{
	//1.assert
	//2.找到删除的位置
	DCList* p = pl;
	for (p; p->next != pl; p = p->next);
	//此时 for循环执行结束，代表指针p此时指向最后一个节点

	//3.删除
	if (pl->next == p)//if(p->prior == pl)//删除的节点就是仅存的节点//
	{
		pl->next = pl;
		pl->prior = pl;
	}
	else//删除的节点不是仅存的节点
	{
		p->prior->next = pl;//删除节点的上一个节点的next域指向头结点
		pl->prior = p->prior;//让头节点的前驱指针指向新的最后一个节点（删除节点的上一个节点）
	}

	free(p);
	p = NULL;
	return true;
}


//按位置删除
bool Del_pos(PDClist pl, int pos)
{
	//assert pl pos

	if (pos == 0)
		return Del_head(pl);
	if (pos == Get_length(pl) - 1)
		return Del_tail(pl);

	//此时 剩下的情况都是中间节点删除
	DCList* p = pl;
	for (int i = 0; i < pos; i++)
	{
		p = p->next;
	}

	DCList* q = p->next;//q 指向的就是删除的节点本身
	p->next = q->next;
	q->next->prior = p;
	free(q);
	q = NULL;

	return true;
}

//按值删除，删除遇到的第一个值为val的节点 如果值为val的节点不存在，则返回false
bool Del_val(PDClist pl, int val)
{
	//assert
	DCList* p = Search(pl, val);
	if (p == NULL)
	{
		return false;
	}

	//这两行代码  兼容任何情况 
	p->prior->next = p->next;
	p->next->prior = p->prior;
	free(p);
	p = NULL;

	return true;
}

//查找  查找值为val的第一个节点，找到则返回其节点地址，否则返回NULL
PDClist Search(PDClist pl, int val)
{
	//assert
	DCList* p = pl->next;
	for (p; p != pl; p = p->next)
	{
		if (p->data == val)
		{
			return p;
		}
	}

	return NULL;
}

//判空
bool IsEmpty(PDClist pl)
{
	return pl->next == pl;
}

//获取循环链表有效元素个数
int Get_length(PDClist pl)
{
	int count = 0;
	DCList* p = pl->next;
	for (p; p != pl; p = p->next)
	{
		count++;
	}

	return count;
}

//打印
void Show(PDClist pl)
{
	DCList* p = pl->next;
	for (p; p != pl; p = p->next)
	{
		printf("%d ", p->data);
	}
	printf("\n");
}

//清空
void Clear(PDClist pl)
{
	Destroy(pl);
}

//销毁1 一直头删的方式释放内存
void Destroy(PDClist pl)
{
	while (pl->next != pl)
	{
		DCList* p = pl->next;
		pl->next = p->next;
		free(p);
		p = NULL;
	}

	pl->prior = pl;
}

//销毁2
void Destroy2(PDClist pl)
{
	DCList* p = pl->next;
	DCList* q;

	while (p != pl)
	{
		q = p->next;
		free(p);
		p = q;
	}

	pl->next = pl;
	pl->prior = pl;
}

//寻找值为val的节点的前驱
PDClist Get_prior(PDClist pl, int val)
{
	DCList* p = Search(pl, val);
	if (p == NULL)
	{
		return NULL;
	}

	return p->prior;
}

//寻找值为val的节点的后继
PDClist Get_next(PDClist pl, int val)
{
	DCList* p = Search(pl, val);
	if (p == NULL)
	{
		return NULL;
	}

	return p->next;
}
Wu~~~~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——双向链表
Labrador_Katie的博客
01-03 872
双向链表
树形数据结构查询 CONNECT BY PRIOR
weixin_30905981的博客
07-16 125
在工作中，经常看到对某表进行相关树形结构的查询，比如针对某集团单位的组织机构、对员工上下级关系方面等都常常用到，把用法在这做个简单的记录，也是在博客园第一条笔记:) 1SELECTlast_name,employee_id,manager_id,LEVEL2FROMemployees3STARTWITHemployee_id=...
c语言中next和prior连在一起,数据结构（C语言版）课后习题答案
weixin_29291573的博客
05-19 1188
第2章 线性表1．选择题(1)顺序表中第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是( )。A．110 B．108 C．100 D．120答案：B解释：顺序表中的数据连续存储，所以第5个元素的地址为：100+2*4=108。(2)在n个结点的顺序表中，算法的时间复杂度是O(1)的操作是( )。 A．访问第i...
数据结构杂谈（四）
弄鹊
02-15 730
双链表、循环链表和静态链表
数据结构-双链表
修心
01-20 1635
双链表   单链表结点中只有一个只指向后继的指针，使得单链表只能从头结点开始一次顺序的先后遍历。要访问某个结点的前驱结点（插入删除操作时），只能从头开始遍历，访问后继节点的时间复杂度为O（1），访问前驱结点的时间复杂度为O（n）。   为了克服单链表的上述缺点，引入了双链表，双链表结点中有两个指针prior 和 next，分别指向其前驱结点和后继结点。   定义   双链表中结点类型描述： typedef struct DNode{ ElemType data; struct DNode
嵌入式数据结构基础学习
最新发布
08-26
数据结构基础：了解和熟悉常见的数据结构，如数组、链表、堆栈和队列等，以便理解和使用嵌入式数据结构。 结构体（Struct）和联合体（Union）：学习结构体和联合体的定义和使用，它们是嵌入式数据结构的基本构建块...
Python数据结构基础
02-16
计算机数据结构是计算机科学领域的一个核心概念，它关系到数据在计算机内部的存储方式以及处理效率。数据结构通常被分为逻辑结构和存储...因此，无论是在学术研究还是在软件开发中，数据结构都是不可忽视的重要基础。
c++与数据结构基础简明教程课后习题答案.pdf
07-13
这些题目都是针对C++基础知识和数据结构的简单应用，涵盖了基本输入输出、条件判断、循环、数值计算以及字符处理等核心概念。 1-7-1 是一个简单的程序，它要求用户输入一个整数并输出其10倍。这展示了基本的输入...
数据结构基础知识.doc
06-19
数据结构基础知识是计算机科学教育的重要组成部分，无论是语言编译、操作系统、数据库系统还是人工智能领域，都离不开对数据结构的理解和应用。 1. **数据结构的概念**： 数据结构研究的对象包括数据本身以及数据...
c语言 建立双向链表 prior,next,C语言数据结构 双向链表的建立与基本操作
weixin_36194075的博客
05-20 619
C语言数据结构 双向链表的建立与基本操作双向链表比单链表有更好的灵活性，其大部分操作与线性表相同。下面总结双向链表与单链表之间的不同之处及我在实现过程中所遇到的问题。1.双向链表的建立双向链表在初始化时，要给首尾两个节点分配内存空间。成功分配后，要将首节点的prior指针和尾节点的next指针指向NULL，这是十分关键的一步，因为这是之后用来判断空表的条件。同时，当链表为空时，要将首节点的next...
梳理 | 数据结构
Lin_Bolun的博客
04-11 181
基本概念 线性表是一种逻辑结构，相同数据类型的n个数据元素的有限序列，除第一个元素外，每个元素有且仅有一个直接前驱,除最后一个元素外,每个元素有且仅有一个直接后继。 线性表具有以下特点: 元素个数有限 逻辑上元素有先后次序 数据类型相同 仅讨论元素间的逻辑关系 数组和链表 – 数组 链表 优点 随机访问性强；查找速度快 插入删除速度快；内存利用率高，不会浪费内存；大小没有固定，扩展和灵活 缺点 插入和删除效率低；可能浪费内存；内存空间要求高，必须有足够的连续内存空间；数组大小固定，
Oracle树形结构查询之prior的理解
weixin_30868855的博客
05-11 297
--1 建表 create table 宇宙( 行星等级 number ,行星名称 varchar2(50) ,上级行星等级 number); --2 数据准备 insert into 宇宙 (行星等级, 行星名称, 上级行星等级)values (1, '地球', 2); insert into 宇宙 (行星等级, 行星名称, 上级行星等级)values...
自己总结的一些常数据结构基础知识
u012590688的专栏
05-07 1744
1   排序方法   平均情况  最好   最坏   辅助空间  稳定性 冒泡                       N*N         1 简单选择                    N*N        1 直接插入                    N*N        1 希尔                                   1  
（Python3）数据结构——06.双向链表的原理及实现
1、、的博客
03-20 497
文章简单介绍了双向链表的原理，并且用Python3实现了它的基本功能。
数据结构
xfyangle的博客
03-27 1万+
数据结构 一些概念 数据结构就是研究数据的逻辑结构和物理结构以及它们之间相互关系，并对这种结构定义相应的运算，而且确保经过这些运算后所得到的新结构仍然是原来的结构类型。 数据：所有能被输入到计算机中，且能被计算机处理的符号的集合。是计算机操作的对象的总称。 数据元素：数据（集合）中的一个“个体”，数据及结构中讨论的基本单位 数据项：数据的不可分割的最小单位。一
数据结构基础知识核心归纳(一)
热门推荐
老蒋也疯狂
09-09 2万+
堆是一种树状的数据结构。一般由程序员分配释放，存放由new创建的对象和数组(C中是由malloc分配和free释放)，JVM不定时查看这个对象，如果没有引用指向这个对象就回收.1)优点：可动态分配内存大小，生成周期不必事先告诉编译器，Java垃圾回收自动回收数据；2)缺点：运行时需动态分配内存，因此，数据存储速度较慢
数据结构中的英文及算法缩写
新海说
12-04 1万+
##前言 最近在复习数据结构，经常会遇到很多英文及其缩写，它们分布不同，意义不同，有时也就很难记忆，在此我将其整理出来，方便记忆和使用，也希望对大家有所帮助。 第一章 算法分析 ADT: O(n): T(b): f(n)： 第2章 线性表 2.1.2 Init_List：线性表的初始化（initial 初始的，initialize 初始化） Length_List：求线性表的长度（length 长...
数据结构基础概念与习题解析
在这个习题集中，我们看到了几个关于数据结构基础概念的选择题和填空题。 1. 数据结构的选择题首先定义了数据结构的含义，正确答案是A.数据元素的组织形式。数据结构不仅仅是数据类型的定义，也不仅仅局限于数据的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值