头歌数据结构线性表的操作及应用

最新推荐文章于 2024-05-10 20:54:59 发布
最新推荐文章于 2024-05-10 20:54:59 发布
阅读量847 收藏 16
点赞数 2
文章标签： 数据结构 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66349985/article/details/129183225
版权

头歌数据结构线性表的操作及应用

实现一个顺序存储的线性表

#include <stdio.h>
#include <stdlib.h>
#include "Seqlist.h"


SeqList* SL_Create(int maxlen)
// 创建一个顺序表
// 与SqLst_Free()配对
{
	SeqList* slist=(SeqList*)malloc(sizeof(SeqList));
	slist->data = (T*)malloc(sizeof(T)*maxlen);
	slist->max=maxlen;
	slist->len=0;
	return slist;
}

void SL_Free(SeqList* slist)
// 释放/删除 顺序表
// 与SqLst_Create()配对
{
	free(slist->data);
	free(slist);
}

void SL_MakeEmpty(SeqList* slist)
// 置为空表
{
	slist->len=0;
}

int SL_Length(SeqList* slist)
// 获取长度
{
	return slist->len;
}

bool SL_IsEmpty(SeqList* slist)
// 判断顺序表是否空
{
	return 0==slist->len;
}

bool SL_IsFull(SeqList* slist)
// 判断顺序表是否满
{
	return slist->len==slist->max;
}

T SL_GetAt(SeqList* slist, int i)
// 获取顺序表slist的第i号结点数据
// 返回第i号结点的值
{
	if(i<0||i>=slist->len) {
		printf("errot!\n");		
		SL_Free(slist);
		exit(0);
	}
	else 
		return slist->data[i];
}

void SL_SetAt(SeqList* slist, int i, T x)
// 设置第i号结点的值（对第i号结点的数据进行写）
{
	if(i<0||i>=slist->len) {
		printf("errot!\n");		
		SL_Free(slist);
		exit(0);
	}
	else 
		slist->data[i]=x;
}

bool SL_InsAt(SeqList* slist, int i, T x)
// 在顺序表的位置i插入结点x, 插入d[i]之前
// i的有效范围[0,plist->len]
{
     if (i<0 || i>slist->len || slist->len==slist->max)  
    {
        printf("errot!");
        return false;
    }
    for (int j=slist->len; j>=i+1; j--) 
    {
        slist->data[j]=slist->data[j-1];
    }
    slist->data[i]=x;
    slist->len++;
    return true;

    /********** End **********/
}


T SL_DelAt(SeqList* slist, int i)
// 删除顺序表plist的第i号结点
// i的有效范围应在[0,plist->len)内，否则会产生异常或错误。
// 返回被删除的数据元素的值。

{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int j;
   if (i<0 || i>=slist->len) 
   {
       printf(" error!\n");
   }
   T r=slist->data[i];
    for (j=i; j<slist->len-1; j++) 
    {
        slist->data[j] = slist->data[j+1];
    }
    slist->len--;
    return true;

 /********** End **********/
}

int SL_FindValue(SeqList* slist, T x)
// 在顺序表表中查找第一个值为x的结点，返回结点的编号
// 返回值大于等于0时表示找到值为x的结点的编号，-1表示没有找到
{
	int i=0;
	while(i<slist->len && slist->data[i]!=x) i++;
	if (i<slist->len) return i;
	else return -1;
}

int SL_DelValue(SeqList* slist, T x)
// 删除第一个值为x的结点,
// 存在值为x的结点则返回结点编号, 未找到返回－1
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
     int i;
     i=SL_FindValue(slist, x);
    if (i>=0) 
    {
    	SL_DelAt(slist, i);
    }
    return i;
    /********** End **********/
}

void SL_Print(SeqList* slist)
// 打印整个顺序表
{
	if (slist->len==0) {
		printf("The slist is empty.\n");		
		return;
	}

	//printf("The slist contains: ");
	for (int i=0; i<slist->len; i++) {
		printf("%d  ", slist->data[i]);
	}

	printf("\n");	
	
}

实现一个链接存储的线性表

#include <stdio.h>
#include <stdlib.h>
#include "LinkList.h"

// 1）
LinkList* LL_Create()
// 创建一个链接存储的线性表，初始为空表，返回llist指针。
{
    LinkList* llist=(LinkList*)malloc(sizeof(LinkList));
    llist->front=NULL;
    llist->rear=NULL;
    llist->pre=NULL;
    llist->curr=NULL;
    llist->position=0;
    llist->len=0;
    return llist;
}

// 2）	
void LL_Free(LinkList* llist)
// 释放链表的结点，然后释放llist所指向的结构。
{
    LinkNode* node=llist->front;
    LinkNode* nextnode;
    while(node){
        nextnode=node->next;
        free(node);
        node=nextnode;
    }
    free(llist);
}

// 3）	
void LL_MakeEmpty(LinkList* llist)
// 将当前线性表变为一个空表，因此需要释放所有结点。
{
    LinkNode* node=llist->front;
    LinkNode* nextnode;
    while(node){
        nextnode=node->next;
        free(node);
        node=nextnode;
    }
    llist->front=NULL;
    llist->rear=NULL;
    llist->pre=NULL;
    llist->curr=NULL;
    llist->position=0;
    llist->len=0;
}

// 4）	
int LL_Length(LinkList* llist)
// 返回线性表的当前长度。
{
    return llist->len;
}

// 5）	
bool LL_IsEmpty(LinkList* llist)
// 若当前线性表是空表，则返回true，否则返回TRUE。
{
    return llist->len==0;
}

// 6）  
bool LL_SetPosition(LinkList* llist, int i)
// 设置线性表的当前位置为i号位置。
// 设置成功，则返回true，否则返回false（线性表为空，或i不在有效的返回）
// 假设线性表当前长度为len，那么i的有效范围为[0,len]
{	
    int k;
    /* 若链表为空，则返回*/
    if (llist->len==0) return false;

    /*若位置越界*/
    if( i < 0 || i > llist->len)
    {	printf("LL_SetPosition(): position error");
        return false;
    }

    /* 寻找对应结点*/
    llist->curr = llist->front;
    llist->pre = NULL;
    llist->position = 0;
    for ( k = 0; k < i; k++)	{
        llist->position++;
        llist->pre = llist->curr;
        llist->curr = (llist->curr)->next;
    }
    
    /* 返回当前结点位置*/
    return true;
}

// 7)	
int LL_GetPosition(LinkList* llist)
// 获取线性表的当前位置结点的编号
{
    return llist->position;
}

// 8）	
bool LL_NextPosition(LinkList* llist)
// 设置线性表的当前位置的下一个位置为当前位置。
// 设置成功，则返回true，否则返回false（线性表为空，或当前位置为表尾）
{
    if (llist->position >= 0 && llist->position < llist->len)
    /* 若当前结点存在，则将其后继结点设置为当前结点*/
    {
        llist->position++;
        llist->pre = llist->curr;
        llist->curr = llist->curr->next;
        return true;
    }
    else 
        return false;
}

// 9）	
T LL_GetAt(LinkList* llist)
// 返回线性表的当前位置的数据元素的值。
{
    if(llist->curr==NULL)
    {
        printf("LL_GetAt(): Empty list, or End of the List.\n");
        LL_Free(llist);
        exit(1);
	}
    return llist->curr->data;
}

// 10）	
void LL_SetAt(LinkList* llist, T x)
// 将线性表的当前位置的数据元素的值修改为x。
{
    if(llist->curr==NULL)
    {
        printf("LL_SetAt(): Empty list, or End of the List.\n");
        LL_Free(llist);
        exit(1);
    }
    llist->curr->data=x;
}

// 11）	
bool LL_InsAt(LinkList* llist, T x)
// 在线性表的当前位置之前插入数据元素x。当前位置指针指向新数据元素结点。
// 若插入失败，返回false，否则返回true。
{	
    LinkNode *newNode=(LinkNode*)malloc(sizeof(LinkNode));
    if (newNode==NULL) return false;

    newNode->data=x;

    if (llist->len==0){
        /* 在空表中插入*/
        newNode->next=NULL;
        llist->front = llist->rear = newNode;
	}
    //当前位置为表头
    else if (llist->pre==NULL)
    {
        /* 在表头结点处插入*/
        newNode->next = llist->front;
        llist->front = newNode;
    }
    else {  
        /* 在链表的中间位置或表尾后的位置插入*/
        newNode->next = llist->curr;
        llist->pre->next=newNode;
    }
    //插入在表尾后
    if (llist->pre==llist->rear)
        llist->rear=newNode;
    /* 增加链表的大小*/
    llist->len++;
    /* 新插入的结点为当前结点*/
    llist->curr = newNode;
    return true;
}

// 12）	
bool LL_InsAfter(LinkList* llist, T x)
// 在线性表的当前位置之后插入数据元素x。空表允许插入。当前位置指针将指向新结点。
// 若插入失败，返回false，否则返回true。
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
       LinkNode *newNode=(LinkNode*)malloc(sizeof(LinkNode));
       if(newNode==NULL) return false;
       newNode->data=x;
       if(llist->len==0)
       {
        newNode->next=NULL;
        llist->front = llist->rear = newNode;
        llist->len ++;
       }
       else if (llist->curr == llist->rear || llist->curr ==NULL) 
         {
               newNode->next = NULL;
               llist->rear->next=newNode;
               llist->pre=llist->rear;
          llist->rear=newNode;
           llist->position=llist->len;
           llist->len ++;

         }
       else 
       {
           newNode->next = llist->curr->next;
         llist->curr->next=newNode;
        llist->pre=llist->curr;
        llist->position ++;
        llist->len ++;
       }
        llist->curr = newNode;
        return true;
    /********** End **********/
}

// 13）	
bool LL_DelAt(LinkList* llist)
// 删除线性表的当前位置的数据元素结点。
// 若删除失败（为空表，或当前位置为尾结点之后），则返回false，否则返回true。
{	
    LinkNode *oldNode;
    /* 若表为空或已到表尾之后，则给出错误提示并返回*/
    if (llist->curr==NULL)
    {	
        printf("LL_DelAt(): delete a node that does not exist.\n");
        return false;
    }
    oldNode=llist->curr;
    /* 删除的是表头结点*/
    if (llist->pre==NULL)
    {	
        llist->front = oldNode->next;
    }
    /* 删除的是表中或表尾结点*/
    else if(llist->curr!=NULL){
        llist->pre->next = oldNode->next;
    }
    if (oldNode == llist->rear)	{
        /* 删除的是表尾结点，则修改表尾指针和当前结点位置值*/
        llist->rear = llist->pre;
    }

    /* 后继结点作为新的当前结点*/
    llist->curr = oldNode->next;

    /* 释放原当前结点*/
    free(oldNode);

    /* 链表大小减*/
    llist->len --;
    return true;
}

// 14）	
bool LL_DelAfter(LinkList* llist)
// 删除线性表的当前位置的后面那个数据元素。
// 若删除失败（为空表，或当前位置时表尾），则返回false，否则返回true。
{
    LinkNode *oldNode;
    /* 若表为空或已到表尾，则给出错误提示并返回*/
    if (llist->curr==NULL || llist->curr== llist->rear)
    {
        printf("LL_DelAfter():  delete a node that does not exist.\n");
        return false;
    }
    /* 保存被删除结点的指针并从链表中删除该结点*/
    oldNode = llist->curr->next;
    llist->curr->next=oldNode->next;
    
    if (oldNode == llist->rear)
        /* 删除的是表尾结点*/
        llist->rear = llist->curr;
    /* 释放被删除结点*/
    free(oldNode);
    /* 链表大小减*/
    llist->len --;
    return true;
}

// 15）	
int LL_FindValue(LinkList* llist, T x)
// 找到线性表中第一个值为x的数据元素的编号。
// 返回值-1表示没有找到，返回值>=0表示编号。
{
    LinkNode* p=llist->front;
    int idx=0;
    while(p!=NULL && p->data!=x) {
        idx++;
        p = p->next;
    }
    if (idx>=llist->len) return -1;
    else return idx;
}

// 16）	
int LL_DelValue(LinkList* llist, T x)
// 删除第一个值为x的数据元素，返回该数据元素的编号。如果不存在值为x的数据元素，则返回-1.
{
    int idx=LL_FindValue(llist, x);
    if (idx<0) return -1;
    LL_SetPosition(llist, idx);
    LL_DelAt(llist);
    return idx;
}

// 17）	
void LL_Print(LinkList* llist)
// 打印整个线性表。
{
    LinkNode* node=llist->front;
    while (node) {
        printf("%d ", node->data);
        node=node->next;
    }
    printf("\n");
}

就地归并两个有序表

#include<stdio.h>
#include<malloc.h> 
typedef  struct list {  
    int data;  
    struct list * next;   
}list;  

struct list * L=NULL;//头
struct list * head=NULL;//首
struct list * p=NULL;  

struct list * L1=NULL;
struct list * head1=NULL;
struct list * p1=NULL; 

struct list * L2=NULL;
struct list * q=NULL; 
struct list * q1=NULL;
int main(){
    int i=0,length;
    printf("请输入链表的长度\n");
    scanf("%d",&length); 
    head=(struct list *)malloc(sizeof(struct  list)); 
    L=head;
    printf("请依次输入链表的内容\n");
    for(i;i<length;i++){
        p = (struct list *)malloc(sizeof(struct  list));
        scanf("%d",&p->data);
        p->next=NULL;
        head->next=p;
        head=p;
    }
    int i1=0,length1;
    printf("请输入链表的长度\n");
    scanf("%d",&length1);
     
    head1=(struct list *)malloc(sizeof(struct  list)); 
    L1=head1;
    printf("请依次输入链表的内容\n");
    for(i1;i1<length1;i1++){
        p1= (struct list *)malloc(sizeof(struct  list));
        scanf("%d",&p1->data);
        p1->next=NULL;
        head1->next=p1;
        head1=p1;
    }
    L2=(struct list *)malloc(sizeof(struct  list));
    q=L2;
    p=L->next;
    p1=L1->next;
    while(p&&p1){   
      if(p->data<p1->data){
        L2->next=p;
        L2=p;
        p=p->next;
    }else if(p->data==p1->data){
        L2->next=p;
        L2=p;
        p=p->next;
        q1=p1->next;//备用相同元素的下一个地址指向 
        free(p1);
        p1=q1;
        
    }else if(p->data>p1->data){
        L2->next=p1;
        L2=p1;
        p1=p1->next;
    }       
    }
   L2->next=p?p:p1;
   free(L1);
   printf("合并后链表的内容\n");
    p=q->next;
    while(p){
    printf("%d ",p->data);
    p=p->next;
    }
    
}

约瑟夫环问题

#include<stdio.h>
#include<stdlib.h>

typedef struct
{
	int number;
	int cipher;
}DataType;

typedef struct node
{
	DataType data;
	struct node *next;
}SCLNode;

void SCLLInitiate(SCLNode **head)
{
	if((*head=(SCLNode*)malloc(sizeof(SCLNode)))==NULL)
		exit(1);
	(*head)->next=*head;
}

int SCLLInsert(SCLNode *head,int i,DataType x)
{
	SCLNode *p,*q;
	int j;
	p=head->next;
	j=1;
	while(p!=head&&j<i-1)
	{
		p=p->next;
		j++;
	}
	if(j!=i-1&&i!=1)
	{
		printf("插入位置参数错!");
		return 0;
	}
	if((q=(SCLNode*)malloc(sizeof(SCLNode)))==NULL)
		exit(1);
	q->data=x;
	q->next=p->next;
	p->next=q;
	return 1;
}

int SCLLDelete(SCLNode *head,int i,DataType *x)
{
	SCLNode *p,*q;
	int j;
	p=head;
	j=0;
	while(p->next!=head&&j<i-1)
	{
		p=p->next;
		j++;
	}
	if(j!=i-1)
	{
		printf("删除位置参数错!");
		return 0;
	}
	q=p->next;
	p->next=p->next->next;
	*x=q->data;
	free(q);
	return 1; 
}

int SCLLGet(SCLNode *head,int i,DataType *x)
{
	SCLNode *p;
	int l;
	p=head;
	l=0;
	while(p->next!=head&&l<i)
	{
		p=p->next;
		l++;
	}
	if(l!=i)
	{
		printf("取元素位置参数错!");
		return 0;
	}
	*x=p->data;
	return 1;
}

int SCLLNotEmpty(SCLNode *head)//判断函数
{
	if(head->next==head)
		return 0;
	else
		return 1;
}

void SCLLDeleteAfter(SCLNode *p)//删除函数
{
	SCLNode *q=p->next;
	p->next=p->next->next;
	free(q);// 释放q
}

void JesephRing(SCLNode *head,int m)//删除已经选出来的人
{
	SCLNode *pre,*curr;
	int i;
	pre=head;
	curr=head->next;
	while(SCLLNotEmpty(head)==1)
	{
		for(i=1;i<m;i++)
		{
			pre=curr;
			curr=curr->next;
			if(curr==head)
			{
				pre=curr;
				curr=curr->next;
			}
		}
		printf("%d ",curr->data.number);
		m=curr->data.cipher;
		curr=curr->next;
		if(curr==head)
			curr=curr->next;
		SCLLDeleteAfter(pre);
	}
}

int main()
{
	DataType test[7]={{1,3},{2,1},{3,7},{4,2},{5,4},{6,8},{7,4}};
	int N=7,M=20,i;
	SCLNode *head;
	SCLLInitiate(&head);
	for(i=1;i<=N;i++)
		SCLLInsert(head,i,test[i-1]);
	JesephRing(head,M);
	return 0;
}
m0_66349985
关注
  • 2
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
头歌 顺序表，链表，循环队列的基本操作和应用答案。
05-03
头歌数据结构的题目： 顺序表的基本操作和应用 链表的基本操作和应用， 循环队列的应用 同时还有一些附加题，n皇后和钓鱼
数据结构学习--线性表及其应用--链表
06-25
本程序的主要目的在于帮助同学熟练掌握线性表的基本操作在链式存储结构上的实现， 链表的优点是“按需分配”，且增删方便，缺点是不能随机访问。在实际当中，有许多应用 是频繁变动，但并不要求随机访问，在这样的情况下，链表就大有用武之地。通过本实验， 对链表基本操作及其组合应用的演练，加深对链表存储方法及其基本操作的理解，为以后进 一步学习更复杂的数据结构打下基础。
C++数据结构实验一：线性表的应用
03-29
1．熟练掌握线性表的基本运算。 2．掌握顺序表和单链表结构上的插入和删除算法。 3．了解循环链表、双(循环)链表的结构特点和在其上施加的插入、删除等操作。 4. 掌握线性表的逻辑结构特点、顺序存储结构、链式存储结构、顺序表的结构体类型定义、单链表的结构体类型定义、在两种存储结构上的各种基本操作的实现算法。
数据结构学习--线性表及其应用--顺序表
06-25
在众多数据结构当中，线性表是最简单、也是最基本的一个。线性表按存储结构分，可 分为顺序表和链表，它们各有特色。本程序主要目的在于帮助同学熟练掌握线性表的基本 操作在顺序存储结构上的实现，顺序表的优点是可以实现随机存取，用数组对其进行定义， 主要操作时针对数组下标的运算。本实验相对比较简单，通过本实验，对顺序表基本操作及 其组合应用的演练，加深对线性表顺序存储方法及其基本操作的理解，为以后进一步学习更 复杂的数据结构打下基础。
头歌实践教学平台数据结构与算法：02线性表
weixin_62173019的博客
09-05 6067
针对02线性表在头歌平台练习过程中的完成代码，关卡数目较多，每题思路单独在每一关中解释。如有其他需求请留言。
头歌：实现顺序表中数据的查找功能
m0_73147943的博客
03-23 6605
头歌实践教学平台数据结构的 1数据结构-顺序表及其应用的答案
实现一个链式存储的线性表
konnisan的博客
11-05 4930
实现一个链式存储的线性表任务描述相关知识编程要求测试说明代码实现 任务描述 本关任务：完成一个链接存储的线性表的小程序。 相关知识 线性表的存储也可以采用链接存储方式来实现。链接存储方式包括单链表、双链表和循环链表等形式。 下面描述了一种基于单链表的线性表实现方案： 为了讨论简单，假设数据元素的类型为整型： typedef int T; 在链表中，每个数据元素为一个链表结点，结点的具体定义为： struct LinkNode { T data; LinkNode* next; }; 如
【数据结构与算法】之线性表的应用和操作
╰つ栺尖篴夢ゞ
07-21 924
数据结构概念 数据结构：是相互之间存在一种或多种特定关系的数据元素的集合。 数据结构的逻辑结构：数据对象中数据元素之间的相互关系，分为线性结构、树形结构、图形结构以及集合结构。 数据结构的物理结构：数据的逻辑结构在计算机中的存储形式，分为顺序存储和链式存储（不连续存储）。 算法：解决特定问题求解步骤的描述，在计算机中表现为指令的有限序列，并且每条指令表示一个或多个操作。 算法五个基本特性：输入、输出、有穷性、确定性和可行性。 算法时间复杂度O(n)：常数阶、线性阶、平方阶、对数阶、立方阶、nlogn阶、指
数据结构与算法 - 线性表(完整代码)
JKR10000的博客
03-27 5421
样例输入: 3 //输入一个数a，后面将输入a个数据元素 8 9 3 //a个数据元素，依次插入尾结点后。形成单链表结点序列：8,9,3 3 //输入一个数b，后面将再输入b个数据元素 10 89 22 //b个数据元素，依次插入0号结点后。形成单链表结点序列：8,22,89,10,9,3 89 //删除一个值为89的结点 1 //删除1号结点 样例输出: 8 10 9 3 #inc...
【数据结构与算法】 - 线性表详解 - (带头结点)单链表详细实现思路及代码
wkd_007的博客
03-25 2056
文章显示简单介绍了线性表，顺序存储结构、链式存储结构，然后详细地介绍了怎样一步步地实现一个单链表，从链表初始化、插入、删除、查询、销毁等操作详细附图介绍。
头歌数据结构循环队列及链队列的基本操作
05-18
头歌数据结构循环队列及链队列的基本操作 第1关循环队列的基本操作 第2关链队列的基本操作 稳过 栈是一种后进先出的数据结构，而在实际问题中还经常使用一种“先进先出”的数据结构。队列就是从日常生活中的排队...
头歌数据结构单链表的基本操作
05-18
头歌数据结构单链表的基本操作 第1关单链表的插入操作 第2关单链表的删除操作 第3关单链表的按照序号查找值操作 第4关单链表的按照值查找结点位序的操作 第5关单链表的逆置操作 第6关两个有序单链表的合并操作 稳过 ...
#头歌 数据结构 线性表
千浔的博客
12-30 1016
线性表的链式存储结构称为线性链表，如图1所示，线性链表将存储空间划分成若干的小块，每块占用若干个字节，这些小块称为存储结点。将其中的存储结点分为两个部分，一部分用于存储数据元素的值，称为数据域；另一部分用于存储元素之间的前后件关系，即存放下一个元素在存储序号（存储地址），指向后件结点。在线性链表中用一个专门的指针 HEAD 指向线性链表中第一个数据元素的结点（即存放第一个元素的地址）。线性表中最后一个元素没有后件，因此，线性链表中的最后一个结点的指针域为空（用 NULL 或0表示），表示链终结。
数据结构与算法-头歌【1】顺序线性表--课上练
m0_61804419的博客
12-23 6447
为了实现线性表插入操作，你需要实现判断线性表是否为满的判断函数，另外你需要根据提示，在右侧编辑器补充代码，完成操作insertP_seq，insertPre_seq，insertPost_seq三个插入函数，以及遍历输出线性表数据元素的操作printList_seq。具体说明见操作注释。（2）此处假设线性表中的元素用于表示集合，不考虑线性表中元素的位置，移除线性表中的所有重复元素；本关任务： （1）在顺序表L中删除下标pos处的数据元素 （2）在顺序表L中删除与参数x值相同的数据元素。
头歌.c++线性表实训
GreenyWang的博客
06-14 613
其实就是一个main函数，三个函数：dellist删结点，printlist打印表，你要写的就是inserttail插入末尾元素。按链的顺序遍历每一个点，是要删除的数据就删除，然后合并前后的点，不是则跳过。本实训拿到之后可能会懵逼，因为它的main函数没了，其实是放在文件夹里。第四关查找，可以用递归函数（树形结构是这样的），也可以函数内递归更简洁。线性表，顺序表，链表是三个不同概念，只不过重复的部分很多。第七关长度，每遍历一个点深度加一，最后返回就行，接下来是测评时执行的，包含了main函数。
【数据结构】头歌实践教学平台·顺序表
m0_73860301的博客
10-17 923
顺序表的插入运算是指在表的第i (1≤i≤n+1)个位置，插入一个新元素e，使长度为n的线性表 ( a 1，…，a i−1，x，a i+1，…，a i−1，a i，a i+1，…，a n)，变成长度为n-1的线性表( a 1，…顺序表的就地逆置，只需让顺序表中的数据元素头尾依次交换即可，即交换第一个元素和最后一个元素，第二个和倒数第二个，依此类推，这种方法的空间复杂度为O(1)。顺序表L已存在，先判断i值是否合法，如果合法，将顺序表L中第i个数据元素的值赋给e，e要带出函数体，类型声明为引用。
数据结构与算法 - 线性表
Junds0的博客
07-25 754
本关任务实现step1/Seqlist.cpp中的SL_InsAt、SL_DelAt和SL_DelValue三个操作函数，以实现线性表中数据的插入、删除与查找等功能。本关任务完成一个链接存储的线性表的小程序。
数据结构头歌——顺序线性表——课上练
Sherry_liangtang的博客
11-16 833
数据结构头歌——顺序线性表——课上练
数据结构（python）之小杨笔记一
最新发布
m0_74811962的博客
05-10 352
数据结构：数据结构是计算机科学中研究数据组织、管理和存储方式的一门重要领域。（5.）树：一种非线性的数据结构，由节点和边组成，每个节点最多有一个夫节点和多个子节点。（2.）链表：由一系列节点组成的数据结构，每个结构包含数据和指向下一个节点的指针。（3.）图的算法：用于解决图结构中的各种问题的算法，如最短路径，最小生成树。的数据结构，只能在队列的前端进行删除操作，在队列的后端进行插入操作。（6.）图：一种包含节点和边的数据结构，用于表示对象之间的关系。（1.）堆：一种特殊的树形数据结构，用于实现。
数据结构 线性表 csdn
01-11
数据结构是计算机科学中重要的概念，而线性表是其中一个常见的数据结构。CSDN作为一个知名的技术平台，提供了丰富的关于数据结构和线性表的学习资源。 首先，数据结构是一种组织和存储数据的方式。线性表是一种简单而常用的数据结构，它由多个数据元素按照一定的顺序组成。线性表中的数据元素之间存在一对一的关系，即每个元素只有一个直接前驱和一个直接后继。 在CSDN上，我们可以找到大量关于数据结构和线性表的教程、文章和博客。这些资源不仅仅介绍了线性表的基本概念和特点，还提供了各种不同类型线性表的实现方式和应用场景。通过学习这些内容，我们可以深入理解线性表的原理和操作，并掌握如何在实际编程中有效地应用线性表。 另外，CSDN上还提供了很多与线性表相关的代码示例和项目案例。这些示例可以帮助我们更好地理解线性表的具体实现过程，在实际编程中有一定的参考价值。此外，我们还可以通过CSDN上的技术论坛或者博客互动，与其他技术人员交流经验，共同解决在线性表实现过程中遇到的问题。 总而言之，CSDN作为一个知名的技术平台，对于学习数据结构中的线性表具有重要的参考价值。通过CSDN上提供的学习资源、代码示例和讨论互动，我们可以更好地理解线性表的概念和实现方式，并能够在实际编程中灵活地应用线性表。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值