精华内容
下载资源
问答
  • ”链表“类型和结点类型的区别

    千次阅读 2017-01-13 09:20:04
    链表的结构:类型1:若干结点依次相连; 类型2:有头指针,指向链表中的第一个结点。初始情况下头指针为NULL; 类型3:有头结点。头结点是只有指针域的特殊结点,指针域存放指向第一个结点的指
    链表是结点的集合,0个或多个结点组成一个链表。
    节点的结构:数据域(记录数据),指针域(指向下一个结点)
    链表的结构:类型1:若干结点依次相连;
                         类型2:有头指针,指向链表中的第一个结点。初始情况下头指针为NULL;
                         类型3:有头结点。头结点是只有指针域的特殊结点,指针域存放指向第一个结点的指                 针。初始情况下链表只有头结点,头结点的指针域存放指向NULL的指针。头结点在某些情况下会使编程简单。
                         类型4:有头结点和尾结点。比类型3多一个尾结点。初始情况下链表只有头结点和尾结点,头结点指针指向尾结点,尾结点指针指向NULL。
    
    你给的例子是个栈的结构,相当于类型4,有头结点和尾结点的链表。头结点为base,尾结点为top。base和top的数据域(data)均为NULL。
    展开全文
  • 1、 会定义顺序栈和链栈的结点类型。 2、 掌握双向栈的结构特点及其在一维数组中的实现。 3、 掌握在双向栈中进行插入和删除元素的方法。 二、 实验要求 1、 定义栈的存储结构。 2、 编写程序实现双向栈的基本操作...
  • 2,带头结点单链表的定义及源代码
  • 设计程序实现二叉树结点类型定义和对二叉树的基本操作。该程序包括二叉树结构类型以及每一种操作的具体的函数定义和主函数。 1 按先序次序建立一个二叉树 2按(A:先序 B:中序 C:后序 )遍历输出二叉树的所有结点
  • 数据结构--结点数据类型的定义

    千次阅读 2019-12-02 16:19:33
    本篇主要讲述数据结构的基本知识(有关结点定义部分) 建议大家在学习数据结构之前先了解一下结构体和指针的基础知识再来学习数据结构 #include<stdio.h> typedef struct Node { int data;//数据域 ...

    本篇主要讲述数据结构的基本知识(有关结点定义部分)
    建议大家在学习数据结构之前先了解一下结构体和指针的基础知识再来学习数据结构

    #include<stdio.h>
    
    typedef struct Node
    {
    	int data;//数据域 
    	struct Node * pNext;//指针域指向和它本身一样的另外一个结构体,另外一个 
    	 							      节点  所以是struct Node 
    }NODE,*PNODE;	//NODE等价于struct Node,PNODE等价于struct Node*
    								//此时相当于造出了每个结点的数据类型 
    int main(void)
    {
    	return 0;
    }
    
    展开全文
  • typedef struct LNode // 结点类型(见图2.40) { ElemType data; LNode *next; }*Link,*Position; struct LinkList // 链表类型(见图2.41) { Link head,tail; // 分别指向线性链表中的头结点和最后一个结点 int len; ...
    // c2-5.h 带头结点的线性链表类型
    typedef struct LNode // 结点类型(见图2.40)
    {
    ElemType data;
    LNode *next;
    }*Link,*Position;
    struct LinkList // 链表类型(见图2.41)
    {
    Link head,tail; // 分别指向线性链表中的头结点和最后一个结点
    int len; // 指示线性链表中数据元素的个数
    };
    图242 是根据c2-5.h 定义的具有2

    个结点的线性链表的结构。


    // bo2-6.cpp 具有实用意义的线性链表(存储结构由c2-5.h定义)的24个基本操作
    void MakeNode(Link &p,ElemType e)
    { // 分配由p指向的值为e的结点。若分配失败,则退出
    	p=(Link)malloc(sizeof(LNode));
    	if(!p)
    		exit(ERROR);
    	p->data=e;
    }
    void FreeNode(Link &p)
    { // 释放p所指结点
    	free(p);
    	p=NULL;
    }
    void InitList(LinkList &L)
    { // 构造一个空的线性链表L(见图2.43)
    	Link p;
    	p=(Link)malloc(sizeof(LNode)); // 生成头结点
    	if(p)
    	{
    		p->next=NULL;
    		L.head=L.tail=p;
    		L.len=0;
    	}
    	else
    		exit(ERROR);
    }
    void ClearList(LinkList &L)
    { // 将线性链表L重置为空表,并释放原链表的结点空间
    	Link p,q;
    	if(L.head!=L.tail) // 不是空表
    	{
    		p=q=L.head->next;
    		L.head->next=NULL;
    		while(p!=L.tail)
    		{
    			p=q->next;
    			free(q);
    			q=p;
    		}
    		free(q);
    		L.tail=L.head;
    		L.len=0;
    	}
    }
    void DestroyList(LinkList &L)
    { // 销毁线性链表L,L不再存在(见图2.44)
    	ClearList(L); // 清空链表
    	FreeNode(L.head);
    	L.tail=NULL;
    	L.len=0;
    }
    void InsFirst(LinkList &L,Link h,Link s) // 形参增加L,因为需修改L
    { // h指向L的一个结点,把h当做头结点,将s所指结点插入在第一个结点之前
    	s->next=h->next;
    	h->next=s;
    	if(h==L.tail) // h指向尾结点
    		L.tail=h->next; // 修改尾指针
    	L.len++;
    }
    Status DelFirst(LinkList &L,Link h,Link &q) // 形参增加L,因为需修改L
    { // h指向L的一个结点,把h当做头结点,删除链表中的第一个结点并以q返回。
    	// 若链表为空(h指向尾结点),q=NULL,返回FALSE
    	q=h->next;
    	if(q) // 链表非空
    	{
    		h->next=q->next;
    		if(!h->next) // 删除尾结点
    			L.tail=h; // 修改尾指针
    		L.len--;
    		return OK;
    	}
    	else
    		return FALSE; // 链表空
    }
    void Append(LinkList &L,Link s)
    { // 将指针s(s->data为第一个数据元素)所指(彼此以指针相链,以NULL结尾)的
    	// 一串结点链接在线性链表L的最后一个结点之后,并改变链表L的尾指针指向新的尾结点
    	int i=1;
    	L.tail->next=s;
    	while(s->next)
    	{
    		s=s->next;
    		i++;
    	}
    	L.tail=s;
    	L.len+=i;
    }
    Position PriorPos(LinkList L,Link p)
    { // 已知p指向线性链表L中的一个结点,返回p所指结点的直接前驱的位置。若无前驱,则返回NULL
    	Link q;
    	q=L.head->next;
    	if(q==p) // 无前驱
    		return NULL;
    	else
    	{
    		while(q->next!=p) // q不是p的直接前驱
    			q=q->next;
    		return q;
    	}
    }
    Status Remove(LinkList &L,Link &q)
    { // 删除线性链表L中的尾结点并以q返回,改变链表L的尾指针指向新的尾结点
    	Link p=L.head;
    	if(L.len==0) // 空表
    	{
    		q=NULL;
    		return FALSE;
    	}
    	while(p->next!=L.tail)
    		p=p->next;
    	q=L.tail;
    	p->next=NULL;
    	L.tail=p;
    	L.len--;
    	return OK;
    }
    void InsBefore(LinkList &L,Link &p,Link s)
    { // 已知p指向线性链表L中的一个结点,将s所指结点插入在p所指结点之前,
    	// 并修改指针p指向新插入的结点
    	Link q;
    	q=PriorPos(L,p); // q是p的前驱
    	if(!q) // p无前驱
    		q=L.head;
    	s->next=p;
    	q->next=s;
    	p=s;
    	L.len++;
    }
    void InsAfter(LinkList &L,Link &p,Link s)
    { // 已知p指向线性链表L中的一个结点,将s所指结点插入在p所指结点之后,
    	// 并修改指针p指向新插入的结点
    	if(p==L.tail) // 修改尾指针
    		L.tail=s;
    	s->next=p->next;
    	p->next=s;
    	p=s;
    	L.len++;
    }
    void SetCurElem(Link p,ElemType e)
    { // 已知p指向线性链表中的一个结点,用e更新p所指结点中数据元素的值
    	p->data=e;
    }
    ElemType GetCurElem(Link p)
    { // 已知p指向线性链表中的一个结点,返回p所指结点中数据元素的值
    	return p->data;
    }
    Status ListEmpty(LinkList L)
    { // 若线性链表L为空表,则返回TRUE;否则返回FALSE
    	if(L.len)
    		return FALSE;
    	else
    		return TRUE;
    }
    int ListLength(LinkList L)
    { // 返回线性链表L中元素个数
    	return L.len;
    }
    Position GetHead(LinkList L)
    { // 返回线性链表L中头结点的位置
    	return L.head;
    }
    Position GetLast(LinkList L)
    { // 返回线性链表L中最后一个结点的位置
    	return L.tail;
    }
    Position NextPos(Link p)
    { // 已知p指向线性链表L中的一个结点,返回p所指结点的直接后继的位置。若无后继,则返回NULL
    	return p->next;
    }
    Status LocatePos(LinkList L,int i,Link &p)
    { // 返回p指示线性链表L中第i个结点的位置,并返回OK,i值不合法时返回ERROR。i=0为头结点
    	int j;
    	if(i<0||i>L.len)
    		return ERROR;
    	else
    	{
    		p=L.head;
    		for(j=1;j<=i;j++)
    			p=p->next;
    		return OK;
    	}
    }
    Position LocateElem(LinkList L,ElemType e,Status (*compare)(ElemType,ElemType))
    { // 返回线性链表L中第1个与e满足函数compare()判定关系的元素的位置,
    	// 若不存在这样的元素,则返回NULL
    	Link p=L.head;
    	do
    	p=p->next;
    	while(p&&!(compare(p->data,e))); // 没到表尾且没找到满足关系的元素
    	return p;
    }
    void ListTraverse(LinkList L,void(*visit)(ElemType))
    { // 依次对L的每个数据元素调用函数visit()
    	Link p=L.head->next;
    	int j;
    	for(j=1;j<=L.len;j++)
    	{
    		visit(p->data);
    		p=p->next;
    	}
    	printf("\n");
    }
    void OrderInsert(LinkList &L,ElemType e,int (*comp)(ElemType,ElemType))
    { // 已知L为有序线性链表,将元素e按非降序插入在L中。(用于一元多项式)
    	Link o,p,q;
    	q=L.head;
    	p=q->next;
    	while(p!=NULL&&comp(p->data,e)<0) // p不是表尾且元素值小于e
    	{
    		q=p;
    		p=p->next;
    	}
    	o=(Link)malloc(sizeof(LNode)); // 生成结点
    	o->data=e; // 赋值
    	q->next=o; // 插入
    	o->next=p;
    	L.len++; // 表长加1
    	if(!p) // 插在表尾
    		L.tail=o; // 修改尾结点
    }
    Status LocateElem(LinkList L,ElemType e,Position &q,int(*compare)(ElemType,ElemType))
    { // 若升序链表L中存在与e满足判定函数compare()取值为0的元素,则q指示L中
    	// 第一个值为e的结点的位置,并返回TRUE;否则q指示第一个与e满足判定函数
    	// compare()取值>0的元素的前驱的位置。并返回FALSE。(用于一元多项式)
    	Link p=L.head,pp;
    	do
    	{
    		pp=p;
    		p=p->next;
    	}while(p&&(compare(p->data,e)<0)); // 没到表尾且p->data.expn<e.expn
    	if(!p||compare(p->data,e)>0) // 到表尾或compare(p->data,e)>0
    	{
    		q=pp;
    		return FALSE;
    	}
    	else // 找到
    	{
    		q=p;
    		return TRUE;
    	}
    }


    // main2-6.cpp 检验bo2-6.cpp的主程序
    #include"c1.h"
    typedef int ElemType;
    #include"c2-5.h"
    #include"bo2-6.cpp"
    #include"func2-3.cpp" // 包括equal()、comp()、print()、print2()和print1()函数
    void main()
    {
    	Link p,h;
    	LinkList L;
    	Status i;
    	int j,k;
    	InitList(L); // 初始化空的线性表L
    	for(j=1;j<=2;j++)
    	{
    		MakeNode(p,j); // 生成由p指向、值为j的结点
    		InsFirst(L,L.tail,p); // 插在表尾
    	}
    	OrderInsert(L,0,comp); // 按升序插在有序表头
    	for(j=0;j<=3;j++)
    	{
    		i=LocateElem(L,j,p,comp);
    		if(i)
    			printf("链表中有值为%d的元素。\n",p->data);
    		else
    			printf("链表中没有值为%d的元素。\n",j);
    	}
    	printf("输出链表:");
    	ListTraverse(L,print); // 输出L
    	for(j=1;j<=4;j++)
    	{
    		printf("删除表头结点:");
    		DelFirst(L,L.head,p); // 删除L的首结点,并以p返回
    		if(p)
    			printf("%d\n",GetCurElem(p));
    		else
    			printf("表空,无法删除p=%u\n",p);
    	}
    	printf("L中结点个数=%d L是否空%d(1:空0:否)\n",ListLength(L),ListEmpty(L));
    	MakeNode(p,10);
    	p->next=NULL; // 尾结点
    	for(j=4;j>=1;j--)
    	{
    		MakeNode(h,j*2);
    		h->next=p;
    		p=h;
    	} // h指向一串5个结点,其值依次是2 4 6 8 10
    	Append(L,h); // 把结点h链接在线性链表L的最后一个结点之后
    	OrderInsert(L,12,comp); // 按升序插在有序表尾头
    	OrderInsert(L,7,comp); // 按升序插在有序表中间
    	printf("输出链表:");
    	ListTraverse(L,print); // 输出L
    	for(j=1;j<=2;j++)
    	{
    		p=LocateElem(L,j*5,equal);
    		if(p)
    			printf("L中存在值为%d的结点。\n",j*5);
    		else
    			printf("L中不存在值为%d的结点。\n",j*5);
    	}
    	for(j=1;j<=2;j++)
    	{
    		LocatePos(L,j,p); // p指向L的第j个结点
    		h=PriorPos(L,p); // h指向p的前驱
    		if(h)
    			printf("%d的前驱是%d。\n",p->data,h->data);
    		else
    			printf("%d没前驱。\n",p->data);
    	}
    	k=ListLength(L);
    	for(j=k-1;j<=k;j++)
    	{
    		LocatePos(L,j,p); // p指向L的第j个结点
    		h=NextPos(p); // h指向p的后继
    		if(h)
    			printf("%d的后继是%d。\n",p->data,h->data);
    		else
    			printf("%d没后继。\n",p->data);
    	}
    	printf("L中结点个数=%d L是否空%d(1:空0:否)\n",ListLength(L),ListEmpty(L));
    	p=GetLast(L); // p指向最后一个结点
    	SetCurElem(p,15); // 将最后一个结点的值变为15
    	printf("第1个元素为%d 最后1个元素为%d\n",GetCurElem(GetHead(L)->next),GetCurElem(p));
    	MakeNode(h,10);
    	InsBefore(L,p,h); // 将10插到尾结点之前,p指向新结点
    	p=p->next; // p恢复为尾结点
    	MakeNode(h,20);
    	InsAfter(L,p,h); // 将20插到尾结点之后
    	k=ListLength(L);
    	printf("依次删除表尾结点并输出其值:");
    	for(j=0;j<=k;j++)
    		if(!(i=Remove(L,p))) // 删除不成功
    			printf("删除不成功p=%u\n",p);
    		else
    			printf("%d ",p->data);
    		MakeNode(p,29); // 重建具有1个结点(29)的链表
    		InsFirst(L,L.head,p);
    		DestroyList(L); // 销毁线性链表L
    		printf("销毁线性链表L之后: L.head=%u L.tail=%u L.len=%d\n",L.head,L.tail,L.len);
    }
    

    代码运行结果如下:

    /*
    链表中有值为0的元素。
    链表中有值为1的元素。
    链表中有值为2的元素。
    链表中没有值为3的元素。
    输出链表:0 1 2
    删除表头结点:0
    删除表头结点:1
    删除表头结点:2
    删除表头结点:表空,无法删除p=0
    L中结点个数=0 L是否空1(1:空0:否)
    输出链表:2 4 6 7 8 10 12
    L中不存在值为5的结点。
    L中存在值为10的结点。
    2没前驱。
    4的前驱是2。
    10的后继是12。
    12没后继。
    L中结点个数=7 L是否空0(1:空0:否)
    第1个元素为2 最后1个元素为15
    依次删除表尾结点并输出其值:20 15 10 10 8 7 6 4 2 删除不成功p=0
    销毁线性链表L之后: L.head=0 L.tail=0 L.len=0
    Press any key to continue
    
    */


    展开全文
  • 在不能确定某一数据结构的每个结点是单一变量(包括基本类型或者自定义类型)的时候,也就是该结构结点内容可能会扩展的情况,不妨将结点内容定义为struct,即便现在struct内只有单一变量。方便后续的扩展,而不用...
    在不能确定某一数据结构的每个结点是单一变量(包括基本类型或者自定义类型)的时候,也就是该结构结点内容可能会扩展的情况,不妨将结点内容定义为struct,即便现在struct内只有单一变量。方便后续的扩展,而不用修改每一处结点相关的操作,当然如果最终只有单一变量的话会有结构的额外开销。
    展开全文
  • 假设树中每个结点的name域均不相同,该树采用孩子兄弟链存储结构,其结点类型定义如下: typedef struct node { char name[50]; //专业、班号或姓名 float score; //分数 struct node *child; //指向最左边...
  • 【数据结构】-链队列(带头结点)

    千次阅读 2020-08-01 17:44:40
    链队列-带头结点1.头文件及类型定义2.链队列类型定义3.函数声明4.基本操作4.1 初始化队列4.2 判空4.3 入队4.4 出队4.5 获取队头元素4.6 main函数5....typedef struct LinkNode { //链式队列的结点类型定义 ElemType d
  • 带头结点的单链表类的定义及实现1.cpp .........
  • 我在之前一篇博客《C语言实现单链表(不带头结点)的基本操作》中具体实现了不带头结点的单链表的11种操作:如计算链表长度、初始化、创建链表、清空链表等等。但是在实际使用中,带头结点的单链表往往比不带头结点...
  • 二叉树的类型定义与基本操作

    千次阅读 2020-10-29 20:25:45
    二叉树的类型定义与基本操作 树结构是一类重要的非线性数据结构,在客观世界中广泛存在。树在计算机领域中也得到了广泛的应用,尤以二叉树最为常用。本文重点讨论二叉树的基本操作。 1. 二叉树的类型定义 二叉树通常...
  • ①带头结点 //在第i个位置插入元素e(带头结点) typedef struct LNode{ Elemtype data; struct LNode *next; }LNode,*LinkList; bool ListInsert(LinkList &L,int i,Elemtype e){ if(i<1) return false;...
  • 广义表的储存结构和结点定义(Java语言描述)
  • 对于不带头结点的非空单链表 L,设计一个递归算法返回最大值结点的地址(假设这样的结点唯一)。 #include "LinkList.cpp" #include <bits/stdc++.h> LinkNode *Maxnode(LinkNode *L) { if(L->...
  • 数据结构------线性表

    2019-11-20 11:03:56
    某带头结点的非空单链表L中所有元素为非0整数,结点类型定义如下: typedef struct node { int data; struct node *next; } LinkNode; 设计一个尽可能高效的算法,将所有data值小于零的结点移到所有...
  • // 自定义类型 enum Status {SUCCESS, FAIL, UNDER_FLOW, OVER_FLOW,RANGE_ERROR, DUPLICATE_ERROR, NOT_PRESENT, ENTRY_INSERTED, ENTRY_FOUND, VISITED, UNVISITED}; // 宏定义 #define DEFAULT_SIZE 1000...
  • 《数据结构 1800题》

    热门讨论 2012-12-27 16:52:03
    (1)抽象数据类型及数据类型 (2)数据结构、逻辑结构、存储结构 (3)抽象数据类型【哈尔滨工业大学 2000 一、1(3分)】 (4)算法的时间复杂性 【河海大学 1998 一、2(3分)】 (5)算法【吉林工业大学 1999...
  • 关于单链表结构体定义结点时 LNode *LinkList的理解

    千次阅读 多人点赞 2020-12-24 20:54:00
    typedef struct LNode{ ElemType data; //数据域 struct LNode *next; //指针域 }LNode, *LinkList ...在表示一个单链表时,只需声明一个头指针L,指向单链表的第一个结点(也就是头结点) Lnode *L //声明一个指
  • 数据结构线性表课后习题(数据结构考试重点)

    千次阅读 多人点赞 2020-07-08 15:09:24
    1. 简述线性表两种存储结构各自的主要特点。 答:线性表的两种存储结构分别是顺序存储结构和链式存储结构。顺序存储结构的主 要特点如下: ① 数据元素中只有自身的数据域...① 数据结点中除自身的数据域,还有表示逻辑
  • Linklist *insert(Linklist *head,int value)//插入结点 { Linklist *p,*s; p=head; while(p->next!=NULL) // { if(p->next->data>value) { s =(Linklist *)malloc(sizeof(Linklist)); /*生成新的...
  • 数据结构试题及评分解析

    千次阅读 2020-03-07 18:46:51
    假设二叉树b采用二叉链存储结构,设计一个算法void findparent(BTNode *b,ElemType x,BTNode *&p)求指定值为x的结点(假设这样的结点是唯一的)的双亲结点地址p,提示,根结点的双亲为NULL,若在b中未找到值为x的...
  • 【单链表算法】设带头结点的非空单链表 L,设计一个算法删除 L 中奇数序号 的结点,即删除 L 中第 1、3、5…结点。 #include<stdio.h> #include<malloc.h> typedef struct node { int data; struct ...
  • 在单链表的基本操作中,我们在实现时,往往在第一个结点(含有有效数据)之前添加另外一个结点,也就是头结点。同时我们称指向头结点的指针为头指针。结构如下图所示: 头节点中的数据域可以存储链表长度等额外...
  • 10-设有两个长度为n的单链表(带头结点),结点类型相同,若以h1为头结点指针的链表是非循环的,以h2为头结点指针的链表是循环的,则(B)。 A、对于两个链表来说,删除开始结点的操作,其时间复杂度分别为O(1)和O...
  • 单链表(带头结点)的创建

    万次阅读 2018-03-10 16:05:32
    2.算法单链表结点的存储结构包含两部分:数据、下一结点指针。单链表的创建:输入n个数据e,若数据e不在单链表中,为数据e分配结点,并插入在单链表的尾部;若单链表中已有数据e,则不做任何操作。单链表的输出:...
  • 一、单链表抽象数据类型定义: #include&amp;amp;amp;lt;stdio.h&amp;amp;amp;gt; #include&amp;amp;amp;lt;stdlib.h&amp;amp;amp;gt; #include&amp;amp;amp;lt;time.h&amp;amp;amp;gt; ...
  • 算法:直接插入排序。...//r保持*p后继结点指针,以保证不断链 p->next=NULL;//构造只含一个数据结点的有序表 p=r; while(p!=NULL){ r=p->next; pre=L; while(pre->next!=NULL&am
  • 链表中定义结点在C/C++中的区别

    千次阅读 2017-12-25 22:24:06
    为了建立如图所示的存储结构(即每个结点含有2个域,data是数据域,next是指向结点的指针域),则在[]处应填写的选项是:B struct link { char data; []; }node; A、link next; B、struct link *next; C、link *...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 185,084
精华内容 74,033
关键字:

结点类型