数据结构学习笔记 --- 线性表 （双向链表、循环链表）

最新推荐文章于 2022-10-18 22:32:36 发布
最新推荐文章于 2022-10-18 22:32:36 发布
阅读量400 收藏 4
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gzw1623231307/article/details/56472682
版权

1. 引言


本文讨论双向链表、循环链表的一些基本操作。


2. 双向链表


2.1 双向链表的存储结构 
typedef struct DuLNode
{
	ElemType 	data;
	DuLNode 	*prior,*next;
}DuLNode,*DuLinkList;

2.2 双向链表的基本操作（带头结点）

（1）在带头结点的双向链表L中第i个位置之前插入元素e，i的合法值为1≤i≤表长+1

Status ListInsert(DuLinkList L,int i,ElemType e)
{
	int 			j = 0;
	DuLinkList 		p = L, s;
	
	// 寻找第i-1个结点
	while (j < i-1 && p)
	{
		p = p->next;
		j++; 
	}
	
	if (!p || j > i-1)
		return ERROR;
	
	s = (DuLinkList)malloc(sizeof(DuLNode));
	if (!s) exit(OVERFLOW);
	
	s->data = e;
	
	// 插入位置为表长加1时
	if (!p->next)
	{
		s->next  = p->next;
		s->prior = p;
		p->next  = s;
	}
	// 插入位置不为表长加1时
	else
	{
		s->next = p->next;
		p->next->prior = s;
		p->next  = s;
		s->prior = p;

	}
	return OK;
}

（2 ） 删除带头结点的双向链表L的第i个元素，i的合法值为1≤i≤表长 

// 删除带头结点的双向链表L的第i个元素，i的合法值为1≤i≤表长
Status ListDelete(DuLinkList L,int i,ElemType &e)
{
	int 			j = 0;
	DuLinkList 		p = L, q;
	
	// 寻找第i个结点,并令p指向其前驱
	while (j < i-1 && p->next)
	{
		p = p->next;
		j++; 
	}
	
	if (!p->next || j > i-1)
		return ERROR;

	q = p->next;
	e = q->data;
	
	//删除最后一个元素时
	if (q->next)
	{
		p->next = q->next;
		q->next->prior = p;
	}
	//删除元素不为最后一个
	else
	{
		p->next = q->next;		
	}
	
	free(q);
	return OK;
}

（3）其他的基本操作很简单，在此将不再一一列举，把他放在我的下载资料里（dulist.cpp），含main函数，测试这些基本操作。


3. 循环链表


3.1 设立尾指针的单循环链表

// 设立尾指针的单循环链表的12个基本操作
#include "ds.h"
using namespace std;

//#define TEST_ALGO

typedef 	int		ElemType;

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


void InitList(LinkList &L);
void DestoryList(LinkList &L);
void ClearList(LinkList &L); // 改变头指针L
Status ListEmpty(LinkList L);
int ListLength(LinkList L);
Status GetElem(LinkList L, int i, ElemType &e);
int LocateElem(LinkList L, ElemType e, Status(*compare)(ElemType, ElemType));
Status PriorElem(LinkList L, ElemType cur_e, ElemType &pre_e);
Status NextElem(LinkList L, ElemType cur_e, ElemType &next_e);
Status InsertList(LinkList &L, int i, ElemType e);  // 改变头指针L
Status DeleteList(LinkList &L, int i, ElemType &e); // 改变头指针L
void ListTraverse(LinkList L, void(*vi)(ElemType &e));

void MergeList(LinkList &La,LinkList Lb);

Status compare(ElemType e1, ElemType e2);
void print(ElemType &e);


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

void DestroyList(LinkList &L)
{ // 操作结果：销毁线性表L
  LinkList q,p=L->next; // p指向头结点
  while(p!=L) // 没到表尾
  {
    q=p->next;
    free(p);
    p=q;
  }
  free(L);
  L=NULL;
}

void ClearList(LinkList &L) // 改变L
{ // 初始条件：线性表L已存在。操作结果：将L重置为空表
  LinkList p,q;
  L=L->next; // L指向头结点
  p=L->next; // p指向第一个结点
  while(p!=L) // 没到表尾
  {
    q=p->next;
    free(p);
    p=q;
  }
  L->next=L; // 头结点指针域指向自身
}

Status ListEmpty(LinkList L)
{ // 初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE
  if(L->next==L) // 空
    return TRUE;
  else
    return FALSE;
}

int ListLength(LinkList L)
{ // 初始条件：L已存在。操作结果：返回L中数据元素个数
  int i=0;
  LinkList p=L->next; // p指向头结点
  while(p!=L) // 没到表尾
  {
    i++;
    p=p->next;
  }
  return i;
}

Status GetElem(LinkList L,int i,ElemType &e)
{ // 当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
  int j=1; // 初始化，j为计数器
  LinkList p=L->next->next; // p指向第一个结点
  if(i<=0||i>ListLength(L)) // 第i个元素不存在
    return ERROR;
  while(j<i)
  { // 顺指针向后查找，直到p指向第i个元素
    p=p->next;
    j++;
  }
  e=p->data; // 取第i个元素
  return OK;
}

int LocateElem(LinkList L,ElemType e,Status(*compare)(ElemType,ElemType))
{ // 初始条件：线性表L已存在，compare()是数据元素判定函数
  // 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。
  //           若这样的数据元素不存在，则返回值为0
  int i=0;
  LinkList p=L->next->next; // p指向第一个结点
  while(p!=L->next)
  {
    i++;
    if(compare(p->data,e)) // 满足关系
      return i;
    p=p->next;
  }
  return 0;
}

Status PriorElem(LinkList L,ElemType cur_e,ElemType &pre_e)
{ // 初始条件：线性表L已存在
  // 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，
  //           否则操作失败，pre_e无定义
  LinkList q,p=L->next->next; // p指向第一个结点
  q=p->next;
  while(q!=L->next) // p没到表尾
  {
    if(q->data==cur_e)
    {
      pre_e=p->data;
      return TRUE;
    }
    p=q;
    q=q->next;
  }
  return FALSE; // 操作失败
}

Status NextElem(LinkList L,ElemType cur_e,ElemType &next_e)
{ // 初始条件：线性表L已存在
  // 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，
  //           否则操作失败，next_e无定义
  LinkList p=L->next->next; // p指向第一个结点
  while(p!=L) // p没到表尾
  {
    if(p->data==cur_e)
    {
      next_e=p->next->data;
      return TRUE;
    }
    p=p->next;
  }
  return FALSE; // 操作失败
}

Status ListInsert(LinkList &L,int i,ElemType e) // 改变L
{ // 在L的第i个位置之前插入元素e
  LinkList p=L->next,s; // p指向头结点
  int j=0;
  if(i<=0||i>ListLength(L)+1) // 无法在第i个元素之前插入
    return ERROR;
  while(j<i-1) // 寻找第i-1个结点
  {
    p=p->next;
    j++;
  }
  s=(LinkList)malloc(sizeof(LNode)); // 生成新结点
  s->data=e; // 插入L中
  s->next=p->next;
  p->next=s;
  if(p==L) // 改变尾结点
    L=s;
  return OK;
}

Status ListDelete(LinkList &L,int i,ElemType &e) // 改变L
{ // 删除L的第i个元素，并由e返回其值
  LinkList p=L->next,q; // p指向头结点
  int j=0;
  if(i<=0||i>ListLength(L)) // 第i个元素不存在
    return ERROR;
  while(j<i-1) // 寻找第i-1个结点
  {
    p=p->next;
    j++;
  }
  q=p->next; // q指向待删除结点
  p->next=q->next;
  e=q->data;
  if(L==q) // 删除的是表尾元素
    L=p;
  free(q); // 释放待删除结点
  return OK;
}

void ListTraverse(LinkList L,void(*vi)(ElemType &))
{ // 初始条件：L已存在。操作结果：依次对L的每个数据元素调用函数vi()
  LinkList p=L->next->next; // p指向首元结点
  while(p!=L->next) // p不指向头结点
  {
    vi(p->data);
    p=p->next;
  }
  printf("\n");
}

//两个仅设表尾指针的循环链表的合并
void MergeList(LinkList &La,LinkList Lb)
{ // 将Lb合并到La的表尾，由La指示新表
  LinkList p=Lb->next;
  Lb->next=La->next;
  La->next=p->next;
  free(p);
  La=Lb;
}

Status compare(ElemType a, ElemType b)
{
	if (a == b)
		return TRUE;
	else
		return FALSE;
}

void print(ElemType &e)
{
	printf("%d ", e);
}

int main()
{
   LinkList L;
   ElemType e;
   int j;
   Status i;
   InitList(L); // 初始化单循环链表L
   i=ListEmpty(L);
   printf("L是否空 i=%d(1:空 0:否)\n",i);
   ListInsert(L,1,3); // 在L中依次插入3,5
   ListInsert(L,2,5);
   i=GetElem(L,1,e);
   j=ListLength(L);
   printf("L中数据元素个数=%d,第1个元素的值为%d。\n",j,e);
   printf("L中的数据元素依次为：");
   ListTraverse(L,print);
   PriorElem(L,5,e); // 求元素5的前驱
   printf("5前面的元素的值为%d。\n",e);
   NextElem(L,3,e); // 求元素3的后继
   printf("3后面的元素的值为%d。\n",e);
   printf("L是否空 %d(1:空 0:否)\n",ListEmpty(L));
   j=LocateElem(L,5,compare);
   if(j)
     printf("L的第%d个元素为5。\n",j);
   else
     printf("不存在值为5的元素\n");
   i=ListDelete(L,2,e);
   printf("删除L的第2个元素：\n");
   if(i)
   {
     printf("删除的元素值为%d,现在L中的数据元素依次为：",e);
     ListTraverse(L,print);
   }
   else
     printf("删除不成功！\n");
   ClearList(L);
   printf("清空L后，L是否空：%d(1:空 0:否)\n",ListEmpty(L));
   DestroyList(L);
   
   // 测试两个仅设表尾指针的循环链表的合并
   int n=5,k;
   LinkList La,Lb;
   InitList(La);
   for(k=1;k<=n;k++)
     ListInsert(La,k,k);
   printf("La="); // 输出链表La的内容
   ListTraverse(La,print);
   InitList(Lb);
   for(k=1;k<=n;k++)
     ListInsert(Lb,1,k*2);
   printf("Lb="); // 输出链表Lb的内容
   ListTraverse(Lb,print);
   MergeList(La,Lb);
   printf("La+Lb="); // 输出合并后的链表的内容
   ListTraverse(La,print);
   return 0;
}

3.2 双向循环链表（带头结点）

// 带头结点的双向循环链表的基本操作(14个)

#include "ds.h"
using namespace std;

typedef 	int		ElemType;

typedef struct DuLNode
{
	ElemType 	data;
	DuLNode 	*prior,*next;
}DuLNode,*DuLinkList;

void InitList(DuLinkList &L);
void DestroyList(DuLinkList &L); 
void ClearList(DuLinkList L);
Status ListEmpty(DuLinkList L);
int ListLength(DuLinkList L);
Status GetElem(DuLinkList L,int i,ElemType &e);
DuLinkList GetElemP(DuLinkList L,int i); // 另加
int LocateElem(DuLinkList L,ElemType e,Status(*compare)(ElemType,ElemType));
Status PriorElem(DuLinkList L,ElemType cur_e,ElemType &pre_e);
Status NextElem(DuLinkList L,ElemType cur_e,ElemType &next_e);
Status ListInsert(DuLinkList L,int i,ElemType e);
Status ListDelete(DuLinkList L,int i,ElemType &e);
void ListTraverse(DuLinkList L,void(*vi)(ElemType));
void ListTraverseBack(DuLinkList L,void(*print)(ElemType));

int compare(ElemType a,ElemType b);
void print(ElemType c);

void InitList(DuLinkList &L)
{ // 产生空的双向循环链表L
  L=(DuLinkList)malloc(sizeof(DuLNode));
  if(L)
    L->next=L->prior=L;
  else
    exit(OVERFLOW);
}

void DestroyList(DuLinkList &L)
{ // 操作结果：销毁双向循环链表L
  DuLinkList q,p=L->next; // p指向第一个结点
  while(p!=L) // p没到表头
  {
    q=p->next;
    free(p);
    p=q;
  }
  free(L);
  L=NULL;
}

void ClearList(DuLinkList L) // 不改变L
{ // 初始条件：L已存在。操作结果：将L重置为空表
  DuLinkList q,p=L->next; // p指向第一个结点
  while(p!=L) // p没到表头
  {
    q=p->next;
    free(p);
    p=q;
  }
  L->next=L->prior=L; // 头结点的两个指针域均指向自身
}

Status ListEmpty(DuLinkList L)
{ // 初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE
  if(L->next==L&&L->prior==L)
    return TRUE;
  else
    return FALSE;
}

int ListLength(DuLinkList L)
{ // 初始条件：L已存在。操作结果：返回L中数据元素个数
  int i=0;
  DuLinkList p=L->next; // p指向第一个结点
  while(p!=L) // p没到表头
  {
    i++;
    p=p->next;
  }
  return i;
}

Status GetElem(DuLinkList L,int i,ElemType &e)
{ // 当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
  int j=1; // j为计数器
  DuLinkList p=L->next; // p指向第一个结点
  while(p!=L&&j<i) // 顺指针向后查找，直到p指向第i个元素或p指向头结点
  {
    p=p->next;
    j++;
  }
  if(p==L||j>i) // 第i个元素不存在
    return ERROR;
  e=p->data; // 取第i个元素
  return OK;
}

int LocateElem(DuLinkList L,ElemType e,Status(*compare)(ElemType,ElemType))
{ // 初始条件：L已存在，compare()是数据元素判定函数
  // 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。
  //           若这样的数据元素不存在，则返回值为0
  int i=0;
  DuLinkList p=L->next; // p指向第1个元素
  while(p!=L)
  {
    i++;
    if(compare(p->data,e)) // 找到这样的数据元素
      return i;
    p=p->next;
  }
  return 0;
}

Status PriorElem(DuLinkList L,ElemType cur_e,ElemType &pre_e)
{ // 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，
  //           前驱，否则操作失败，pre_e无定义
  DuLinkList p=L->next->next; // p指向第2个元素
  while(p!=L) // p没到表头
  {
    if(p->data==cur_e)
    {
      pre_e=p->prior->data;
      return TRUE;
    }
    p=p->next;
  }
  return FALSE;
}

Status NextElem(DuLinkList L,ElemType cur_e,ElemType &next_e)
{ // 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，
  //           否则操作失败，next_e无定义
  DuLinkList p=L->next->next; // p指向第2个元素
  while(p!=L) // p没到表头
  {
    if(p->prior->data==cur_e)
    {
      next_e=p->data;
      return TRUE;
    }
    p=p->next;
  }
  return FALSE;
}

DuLinkList GetElemP(DuLinkList L,int i) // 另加
{ // 在双向链表L中返回第i个元素的地址。i为0，返回头结点的地址。若第i个元素不存在，
  // 返回NULL(算法2.18、2.19要调用的函数)
  int j;
  DuLinkList p=L; // p指向头结点
  if(i<0||i>ListLength(L)) // i值不合法
    return NULL;
  for(j=1;j<=i;j++)
    p=p->next;
  return p;
}

Status ListInsert(DuLinkList L,int i,ElemType e)
{ // 在带头结点的双链循环线性表L中第i个位置之前插入元素e，i的合法值为1≤i≤表长+1
  // 改进算法2.18，否则无法在第表长+1个结点之前插入元素
  DuLinkList p,s;
  if(i<1||i>ListLength(L)+1) // i值不合法
    return ERROR;
  p=GetElemP(L,i-1); // 在L中确定第i个元素前驱的位置指针p
  if(!p) // p=NULL,即第i个元素的前驱不存在(设头结点为第1个元素的前驱)
    return ERROR;
  s=(DuLinkList)malloc(sizeof(DuLNode));
  if(!s)
    return OVERFLOW;
  s->data=e;
  s->prior=p; // 在第i-1个元素之后插入
  s->next=p->next;
  p->next->prior=s;
  p->next=s;
  return OK;
}

Status ListDelete(DuLinkList L,int i,ElemType &e) // 算法2.19
{ // 删除带头结点的双链循环线性表L的第i个元素，i的合法值为1≤i≤表长
  DuLinkList p;
  if(i<1) // i值不合法
    return ERROR;
  p=GetElemP(L,i);  // 在L中确定第i个元素的位置指针p
  if(!p) // p=NULL,即第i个元素不存在
    return ERROR;
  e=p->data;
  p->prior->next=p->next;
  p->next->prior=p->prior;
  free(p);
  return OK;
}

void ListTraverse(DuLinkList L,void(*visit)(ElemType))
{ // 由双链循环线性表L的头结点出发，正序对每个数据元素调用函数visit()
  DuLinkList p=L->next; // p指向头结点
  while(p!=L)
  {
    visit(p->data);
    p=p->next;
  }
  printf("\n");
}

void ListTraverseBack(DuLinkList L,void(*visit)(ElemType))
{ // 由双链循环线性表L的头结点出发，逆序对每个数据元素调用函数visit()。另加
  DuLinkList p=L->prior; // p指向尾结点
  while(p!=L)
  {
    visit(p->data);
    p=p->prior;
  }
  printf("\n");
}

int compare(ElemType a,ElemType b)
{
	if (a == b)
		return TRUE;
	else
		return FALSE;
}
void print(ElemType c)
{
	printf("%d ", c);
}

int main()
{
   DuLinkList L;
   int i,n;
   Status j;
   ElemType e;
   InitList(L);
   for(i=1;i<=5;i++)
     ListInsert(L,i,i); // 在第i个结点之前插入i
   printf("正序输出链表：");
   ListTraverse(L,print); // 正序输出
   printf("逆序输出链表：");
   ListTraverseBack(L,print); // 逆序输出
   n=2;
   ListDelete(L,n,e); // 删除并释放第n个结点
   printf("删除第%d个结点，值为%d，其余结点为：",n,e);
   ListTraverse(L,print); // 正序输出
   printf("链表的元素个数为%d\n",ListLength(L));
   printf("链表是否空：%d(1:是 0:否)\n",ListEmpty(L));
   ClearList(L); // 清空链表
   printf("清空后，链表是否空：%d(1:是 0:否)\n",ListEmpty(L));
   for(i=1;i<=5;i++)
     ListInsert(L,i,i); // 重新插入5个结点
   ListTraverse(L,print); // 正序输出
   n=3;
   j=GetElem(L,n,e); // 将链表的第n个元素赋值给e
   if(j)
     printf("链表的第%d个元素值为%d\n",n,e);
   else
     printf("不存在第%d个元素\n",n);
   n=4;
   i=LocateElem(L,n,compare);
   if(i)
     printf("等于%d的元素是第%d个\n",n,i);
   else
     printf("没有等于%d的元素\n",n);
   j=PriorElem(L,n,e);
   if(j)
     printf("%d的前驱是%d\n",n,e);
   else
     printf("不存在%d的前驱\n",n);
   j=NextElem(L,n,e);
   if(j)
     printf("%d的后继是%d\n",n,e);
   else
     printf("不存在%d的后继\n",n);
   DestroyList(L);
   
   return 0;
}




Nightsong_cc
关注
考研系列-数据结构第二章、线性表
Nelson_hehe的博客
06-09 2180
本文是408考研付费专栏系列-数据结构线性表章节，本文章详细地总结了线性表的相关知识，其中包括：顺序表、链表（单链表、双链表、循环链表、静态链表等）的细节和重要知识点汇总。考研听课、复习的好帮手。
王道计算机考研数据结构--学习笔记Chapter Two 线性表List
m0_63640882的博客
01-11 446
第二章 线性表List线性表的定义（逻辑结构）线性表的基本操作（数据的运算）线性表的分类（物理结构）2.1顺序表（顺序存储）2.1.1顺序表的定义一、静态分配形式的顺序表SqList二、动态分配形式的顺序表SeqList2.1.2顺序表的基本操作三、插入和删除表操作ListInsertAndListDelete四、按位查找和按值查找GetElemAndLocateElem2.2单链表LinkList（链式存储）2.2.1单链表的定义一、定义单链表LinkList2.2.2单链表的基本操作二、指定结点后插操作
数据结构学习笔记(5.线性表之双向循环链表)
haierboos
08-26 119
在前两节的基础上，实现双向循环链表。 本节知识点： 1.双向循环链表的结构： 上面就是双向循环链表的结构图，对于双向链表的插入有3个位置，A、B、C。 但是在插入第一个元素的时候(其实插入第一个元素的时候，就是循环建立的时候)，有些特殊，所以就画了一个图，如下： 本节代码： DcLinkList.c： /************************************...
链表 -- 双向循环链表(线性表）
weixin_30678349的博客
09-05 115
1，双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 2,构建节点类 public class DNode<E> { Object item; DNode<E> ...
线性表-双向循环链表
君上的博客
10-14 202
双向链表其实就是在单线链表上的基础上多加了一个前驱的结点，用来指向上一个元素的地址。
数据结构4-线性表-双循环链表
m0_54591377的博客
07-03 181
数据结构4-线性表-双循环链表
【数据结构学习笔记】二、线性表---链表篇（2）
大家好我叫张同学
01-07 1243
文章目录链表概念:链表分类：单链表的实现： 链表概念: 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 注意: 1.从上图可看出，链式结构在逻辑上是连续的，但是在物理上不一定连续 2.现实中的结点一般都是从堆上申请出来的 3.从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续 链表分类： 单向 双向 带头 不带头 循环 非循环 单向..
【C++数据结构学习笔记---线性表】带头结点的单循环链表
EnCaL
03-13 1549
【C++数据结构学习笔记---线性表】带头结点的单循环链表 一个简单的实现例子，只用到了插入函数以及输出函数，初始化26个英文字母。 插入算法的思路：（insert）本算法为结点后插入 1、声明一结点p指向头结点，初始化i从0开始。 2、遍历链表，让指针p向后移动，直至移动到要插入元素的结点，即向后移动k-1次。 3、在系统中新建一个结点s。 4、使用s->next=p->next
数据结构与算法学习笔记-线性表
qq_53548177的博客
12-10 656
声明：本博客仅为本人学习途中做的笔记 采自青岛大学王卓老师的视频教学 主要内容为算法思路，具体代码实现还需修改后才能运行，望各位看官多多包涵，您的点赞与评论是对我最大的肯定！ # 1.线性表的定义和特点 线性表是具有相凤特性的数据元素的一个有限序列 (a1,a2,...ai−1,ai,ai+1,...,an) (a_1, a_2, ... a_i-_1, a_i,a_i+_1, ..., a_n) (a1​,a2​,...ai​−1​,ai​,ai​+1​,...,an​)\qquad\qquad\q.
小猪的数据结构辅助教程——2.7 线性表中的双向循环链表
热门推荐
Coder-Pig的猪栏
12-26 18万+
小猪的数据结构辅助教程——2.7 线性表中的双向循环链表标签（空格分隔）： 数据结构本节学习路线图与学习要点学习要点： 1.了解引入双向循环链表的原因 2.熟悉双向循环链表的特点以及存储结构 3.掌握双向循环链表的一些基本操作的实现逻辑 4.掌握逆序输出双向循环链表元素逻辑 1.双向循环链表的引入2.双向循环链表的存储结构双向循环链表的特点： 上面也说了，空间换时间，比起循
数据结构----线性表之双向链表
weixin_57248528的博客
08-04 599
双向链表的介绍
【数据结构】带头双向循环链表
柯礼的博客
08-02 259
带头双向循环链表
数据结构-双向链表
辣条不爱辣的博客
10-03 351
单链表的结点中只有一个指示直接后继的指针域，由此，从某个结点出发只能顺指针往后寻查其他结点。若要寻查结点的直接前驱，则需从表头指针出发。为克服单链表这种单向性的缺点，可利用双向链表。 在双向链表中的结点中有两个指针域，其一指向直接后继，另一指向直接前驱。 定义的辅助宏： #define OK 1 #define ERROR 0 #define OVERFLOW -1 #define LIS...
写给初学者的数据结构——初识链表（带头结点）（C++实现）
血柒柒柒柒柒柒柒
07-11 846
学习链表，这篇文章就够了。 1、准备 2、理解 3、操作 4、应用 5、参考资料 6、相关文章(Java和标准C实现) 全文一共3174字，准备、理解、操作大约需要40分钟的阅读时间，感谢遇见！
数据结构--线性表
Jeason
10-25 341
线性结构–线性表数据结构中的逻辑结构分为线性结构和非线性结构，这一章和下一章我们会介绍线性结构，简单地说，线性结构是n个数据元素的有序（次序）集合，它有下列几个特征：1．集合中必存在唯一的一个”第一个元素”；2．集合中必存在唯一的一个”最后的元素”；3．除最后元素之外，其它数据元素均有唯一的”后继”；4．除第一元素之外，其它数据元素均有唯一的”前驱”。这一章我们就来讲解线性结构中线性表，它是最常用且
c语言伪代码大全,数据结构(C语言)教材的伪代码(一)
weixin_42534103的博客
05-18 6093
Status LocateElem_Sq(SqList L, ElemType e, Status(*compare) (ElemType, ElemType)){//线性表L存在,compare()是数据元素判定函数.返回L中第1个与e满足关系compare()的数据元素的位序.//若这样的元素不存在,则返回0;int i = 1;//i的初值为第一个元素的位序ElemType* p = L.e...
[数据结构]第二章--线性表(读书笔记2)
千月星跡
01-23 899
2.3 线性表的链式表示和实现 □什么是线性表的链式表示 线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素(这组存储单元可以是连续的，也可以是不连续的)。线性链表的最后一个结点的指针为空(NULL)。若线性表为空表，则头结点的指针域为"空"。 删除结点：删除指针P所指结点后的结点。p->next = p->next->next； 如何删除首结点：可以加一个虚拟头结点。
双链表及其他链式结构：删除双链表中第i个结点
weixin_63381305的博客
10-18 752
题目中输入一个n，然后输入n个值，随后在输入需要删除的位置（注意双链表的打印的时候是向前向后打印，具体实例请参见测试样例），请补全DeleteElem(DulLinkList *head,int i)函数所缺失的部分来实现这个算法。
数据结构笔记：线性表、链表、栈与队列解析
"这是关于‘专插本’考试的数据结构复习笔记，主要涵盖了数据结构的基本概念、线性表、链表、数组、栈和队列等核心知识点，旨在帮助备考者巩固理论并理解各种数据结构的特性和应用。" 在数据结构的学习中，首要关注...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值