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

最新推荐文章于 2022-10-18 22:32:36 发布
最新推荐文章于 2022-10-18 22:32:36 发布
阅读量363 收藏 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
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构学习笔记(5.线性表之双向循环链表)
haierboos
08-26 102
在前两节的基础上，实现双向循环链表。 本节知识点： 1.双向循环链表的结构： 上面就是双向循环链表的结构图，对于双向链表的插入有3个位置，A、B、C。 但是在插入第一个元素的时候(其实插入第一个元素的时候，就是循环建立的时候)，有些特殊，所以就画了一个图，如下： 本节代码： DcLinkList.c： /************************************...
链表 -- 双向循环链表(线性表）
weixin_30678349的博客
09-05 97
1，双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 2,构建节点类 public class DNode<E> { Object item; DNode<E> ...
线性表-双向循环链表
君上的博客
10-14 179
双向链表其实就是在单线链表上的基础上多加了一个前驱的结点，用来指向上一个元素的地址。
数据结构4-线性表-双循环链表
m0_54591377的博客
07-03 149
数据结构4-线性表-双循环链表
考研复习知识笔记-数据结构
04-16
数据结构笔记-考研复习 数据结构是计算机科学中的一门重要学科，研究如何组织、存储和使用数据。...这些知识点是考研复习笔记中的一些重要内容，通过学习和掌握这些知识点，可以更好地理解和应用数据结构。
数据结构笔记-《考研王道笔记知识点整理》
最新发布
05-23
《考研王道笔记知识点整理》中的内容涵盖了数据结构的基础概念、数据结构的三要素、算法的基本概念以及线性表的定义。 1. **数据结构的基本概念**： - 数据是描述客观事物属性的符号集合，数据元素是数据的基本...
笔记-数据结构.docx
08-07
数据结构笔记 数据结构是一门基础学科，...线性表、链表和双向链表是数据结构的基本形式，它们是计算机科学和技术的基础。通过学习数据结构，可以帮助我们更好地理解计算机科学和技术，并且能够更好地设计和实现算法。
数据结构学习笔记.docx
11-26
数据结构是计算机科学中的核心概念，...以上就是数据结构学习笔记的主要内容，涵盖了时间复杂度、空间复杂度、线性表、栈、队列、字符串、数组和矩阵等核心概念。理解并掌握这些知识对于深入学习计算机科学至关重要。
双向链表API及C语言实现
03-29
双向链表的API和C语言...另外还有线性表顺序存储、单链表、循环链表的C语言实现，文章及代码资源均已上传，可在专栏《数据结构与算法学习笔记》中查看，欢迎大家查看下载，如果内容有不合理的地方，欢迎大家批评指正。
小猪的数据结构辅助教程——2.7 线性表中的双向循环链表
热门推荐
Coder-Pig的猪栏
12-26 18万+
小猪的数据结构辅助教程——2.7 线性表中的双向循环链表标签（空格分隔）： 数据结构本节学习路线图与学习要点学习要点： 1.了解引入双向循环链表的原因 2.熟悉双向循环链表的特点以及存储结构 3.掌握双向循环链表的一些基本操作的实现逻辑 4.掌握逆序输出双向循环链表元素逻辑 1.双向循环链表的引入2.双向循环链表的存储结构双向循环链表的特点： 上面也说了，空间换时间，比起循
数据结构----线性表之双向链表
weixin_57248528的博客
08-04 247
双向链表的介绍
【数据结构】带头双向循环链表
kdjjdjdjjejje128的博客
08-02 227
带头双向循环链表
双链表及其他链式结构：删除双链表中第i个结点
weixin_63381305的博客
10-18 659
题目中输入一个n，然后输入n个值，随后在输入需要删除的位置（注意双链表的打印的时候是向前向后打印，具体实例请参见测试样例），请补全DeleteElem(DulLinkList *head,int i)函数所缺失的部分来实现这个算法。
【开发细节】用C语言基础写学生管理系统（三）
秦宇BLOG
01-26 1047
GitHub：https://github.com/ITchujian/StudentManagementSystem_2022_C注：为方便分享本次开发的经历，我把分析过程以及代码书写过程，以文字、图片形式合计放于开发记录中，但是一些非常基础的行为动作我将不会讲解或者阐述。 当前位置： 可跳转：ADT——Abstract Data Type，意为，我的理解：请注意，我们所使用的是线性表的顺序存储结构，而非链式结构，这一点已经在1.1文章的代码中有所体现。 因此，对于学生管理系统的线性表ADT如下：创建（代
写给初学者的数据结构——初识链表（带头结点）（C++实现）
血柒柒柒柒柒柒柒
07-11 652
学习链表，这篇文章就够了。 1、准备 2、理解 3、操作 4、应用 5、参考资料 6、相关文章(Java和标准C实现) 全文一共3174字，准备、理解、操作大约需要40分钟的阅读时间，感谢遇见！
双链表（删除节点操作）
muyu_muyu的博客
12-10 5456
在双链表中删除第i个节点算法如下： 首先要会： 双链表的存储结构定义： typedef struct DLinkList{ int data; DLinkList * prior; DLinkList * next; }DLinkList; 思路: 假设删除双链表L中*p 节点 , 的 后继节点 (我们将用q表示 — q = p->next;) 1.首先我们还是先查找 i-1 个节点 2.然后判断该位置是否为空，是，则返回
数据结构-双向链表
辣条不爱辣的博客
10-03 286
单链表的结点中只有一个指示直接后继的指针域，由此，从某个结点出发只能顺指针往后寻查其他结点。若要寻查结点的直接前驱，则需从表头指针出发。为克服单链表这种单向性的缺点，可利用双向链表。 在双向链表中的结点中有两个指针域，其一指向直接后继，另一指向直接前驱。 定义的辅助宏： #define OK 1 #define ERROR 0 #define OVERFLOW -1 #define LIS...
向带头结点的双向链表中第i个位置之前插入元素e
茜茜公主的专栏
01-07 3579
哎呀！不写不知道，一写就出现了好多之前没有遇到的问题，看来以后就要多多练习编程了，这个简单的插入，写了我近一个小时，汗~~~~~~~~~~~~~~~ #include#include#includestruct DuNode{ char date; struct DuNode *prior; struct DuNode *next;}*head;struct DuNode *creat
学习笔记：数据结构、算法时间复杂度和空间复杂度、线性表的特点和表示方式
数据结构学习笔记.docx提供了关于数据结构的一些基本概念和知识点。 在学习数据结构时，我们首先需要了解算法的时间复杂度和空间复杂度。算法的时间复杂度是衡量算法执行时间随问题规模增长的量度。一般情况下，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值