单链表的定义初始化、CRUD （超详细、完整代码）

最新推荐文章于 2024-05-25 16:30:44 发布
最新推荐文章于 2024-05-25 16:30:44 发布
阅读量2.8k 收藏 12
点赞数 4
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60284144/article/details/130158392
版权

一、释意

二、基本操作

1.单链表定义（结构体定义）

2.使用头插法建立单链表（含头结点）

3.使用尾插法建立单链表

4.查找结点（按值查找）

5.查找节点（按序查找）

6.单链表插入（图例）

7.单链表按位序插入（带头结点 ，i表示元素位序）

8.单链表按位序插入（不带头结点 ，i表示元素位序）

9.给定指定节点的后插操作

10.指定节点的前插操作

11.删除结点操作

12.删除结点返回被删除结点的值（按位序删）

13.求单链表表长操作（含头结点）

三、完整代码

一、释意

        1.链表实质就是顺序表的链式表示。相比于顺序表有一些不同。顺序表是用一片地址连续的空间进行存储的 因此具有随机存储的特征（时间复杂度为O(1)），但是链表不同，链表不需要一片地址连续的空间 而是通过链（指针）来将所有元素串起来的。顺序表具有随机存储 但是插入、删除原素需要移动大量元素 而链表就是为了改善增删而定的 但是同时也失去了具有随机存取的特征，并且还需要有一个指针域（存储空间就增大了）。当访问某个元素时 只有通过链依次查找 具体看图例。

                                               

                                                            单链表的结点结构

其中data存放数据（a1...an）next存放下一个元素的地址

顺序表：                                                                         链表：        

        2.通常用头指针来标识一个单链表，头指针为NULL时表示此头指针指向的表示空表。并且通常每个链表都可以定义一个头结点（方便操作），头指针指向头结点。头结点当然也有数据域和指针域，但是头结点的数据域不存放元素 一般用于存放表长等信息，而头结点的指针域就存放第一个元素的地址。 如果所示：

引入头结点可以带来的优点：

1.由于第一个数据结点的位置被存放于头结点的指针域中，因此在链表的第一个位置上的操作和在表的其它位置上的操作一致，无需进行特殊处理

2.无论链表是否为空头指针总是指向头结点的非空指针（此时判定空表的方法是头结点指针是否为空）因此空表和非空表的处理也得到了统一

二、基本操作

1.单链表定义（结构体定义）

#include<stdio.h>
#include<stdlib.h>
typedef struct LNode{  
	int data;
	struct LNode *next;  
}LNode,*LinkList;

2.使用头插法建立单链表（含头结点）

时间复杂度为o(n)

//使用头插法建立单链表 （含头结点）
LinkList List_HeadInsert (LinkList &L){ //逆向建立单链表
	LNode *s;int x;
 	L=(LinkList)malloc(sizeof(LNode)); //创建头结点  ;
 	L->next=NULL;
 	scanf("%d",&x);						//输入第一个结点的值 
 	while(x!=9999){                      //输入9999表示结束 
		s=(LNode*)malloc(sizeof(LNode));
		s->data=x;
 		s->next=L->next;
 		L->next=s;
 		scanf("%d",&x);
 	}	
	return L;
}

        图例：采用头插法建立单链表是每次在头结点之后插入新的结点，因此读入数据的顺序与生成的链表中的元素顺序是相反的。但是它常用于链表逆置

 3.使用尾插法建立单链表

时间复杂度为o(n)

//使用尾插法建立单链表（含头结点） 
LinkList List_TailInsert (LinkList &L){ //逆向建立单链表
 	L=(LinkList)malloc(sizeof(LNode)); 	//创建头结点 ;
	LNode *s,*r=L;int x; 					//s指向新节点  r指向尾结点 
 	L->next=NULL;
 	scanf("%d",&x);						//输入第一个结点的值 
 	while(x!=9999){                      //输入9999表示结束 
		s=(LNode*)malloc(sizeof(LNode));
		s->data=x;
 		r->next=s;
 		r=s;
 		scanf("%d",&x);
 	}	
 	r->next=NULL;  						//尾结点置空 
	return L;
}

        图例：采用尾插法建立单链表可以保证生成链表的结点值顺序和输入顺序一致，但是必须开辟一个尾指针永远指向尾结点（方便插入）

 4.查找结点（按值查找）

时间复杂度为O（n）

        查找方式：从单链表中的第一个结点出发，通过while循环依次查找下一个结点的值是否是目标值，如果是则退出循环并且返回此节点的指针，如果不是继续查找。若未找到则返回NULL；

//按值查找
LNode *LocElement(LinkList &L,int value){
	LNode *p=L->next;
	while(p!=NULL&&p->data!=value){
		p=p->next;		            //未找到目标值的结点则一直往下找 
	}
	return p;						//找到了 返回此节点指针 
}

5.查找节点（按序查找）

时间复杂度为O（n）

        查找方式：从单链表中的第一个结点出发，通过while循环依次查找下一个结点知道找到第i个结点为止，找到了则退出循环并且返回此节点的指针，如果不是继续查找。若未找到则返NULL；

//按位序查找
LNode *GetElement(LinkList &L,int i){
	int j;   						//用于计数 
	if(i<1){
		return NULL;           		//判断i值是否合法 
	}
	LNode *p=L->next; 
	while(p!=NULL&&j<i){
		p=p->next;	
		j++;	            //未找到目标值的结点则一直往下找 
	}
	return p;						//找到了 返回此节点指针 
}

6.单链表插入（图例）

        插入结点操作是将值为value的元素插入到指定单链表的位序i处。算法先测试输入的新节点位序是否合法，如果合法则找到此位序的前一个结点进行后插。见图例，首先查到到序号为i-1的结点p，然后令新节点s的指针域指向p的后继节点，再令结点p的指针域指向新插入的结点s即可。

7.单链表按位序插入（带头结点 ，i表示元素位序）

时间复杂度为O（n）

//单链表插入（按位序插入 带头结点） i表示元素位序 
bool ListInsert(LinkList &L,int i,int e){
	if(i<1){  //判断输入i值是否合法 
		return false; 
	}
	LNode *p;  //用p来指向每个结点  L就是头结点 
	p=L;
	int j=0; 
	while(p!=NULL && j<i-1){  //循环找到第i-1个结点 
		p=p->next;
		j++;
	} 
	if(p==NULL){ //判断p指向的是否是空值 
		return false;
	}
	LNode *s=(LNode*)malloc(sizeof(LNode));  //创建要插入的结点 
	s->data=e;  //这里可以直接
	s->next=p->next;
	p->next=s;
	return true;
}

8.单链表按位序插入（不带头结点 ，i表示元素位序）

时间复杂度为O（n）

//单链表插入（按位序插入 不带头结点） i表示元素位序 不带头结点：L永远指向最后一个结点 
bool ListInsert_NoHeadLNode(LinkList &L,int i,int e){
	if(i<1){  //判断输入i值是否合法 
		return false; 
	}
	if(i==1){  //当是第一个结点时需要单独考虑 因为它无next  无法插入 
		LNode *s=(LNode*)malloc(sizeof(LNode));
		s->data=e;
		s->next=L;
		L=s; //头指针指向新节点 
	} 
	if(i>1){
		LNode *p; //让p指向第一个节点  让p去扫描 
		p=L; 
		int j=1;
		while(p!=NULL && j<i-1){ //找到第i-1个结点 循环次数和带头结点的不一样哦 少一次  
			p=p->next; 
			j++;
		}
		if(p==NULL){  //i值不合法 
			return false; 
		}
		LNode *s=(LNode*)malloc(sizeof(LNode));
		s->data=e;
		s->next=p->next;
		p->next=s;
	}
	return true;
}

9.给定指定节点的后插操作

时间复杂度为O（n）

//给定指定节点的后插操作
bool InsertNextNode(LNode *p,int e){
	if(p==NULL){
		return false;
	}
	LNode *s=(LNode*)malloc(sizeof(LNode));
	if(s==NULL) {  //内存分配失败 
		return false;
	}
	s->data=e; 
	s->next=p->next;
	p->next=s;
}

10.指定节点的前插操作

时间复杂度为O（n）

        这个算法很巧妙，其实质就是后插操作之后 再将两个结点的data值互换，即实现前插。（链表的作用是什么呢不就是存储数据吗？依靠存储数据而生 失去数据而亡）

//指定节点的前插操作 6  
bool InsertPriorNode(LNode *p,int e){
	if(p==NULL){
		return false;
	}
	LNode *s=(LNode*)malloc(sizeof(LNode));
	if(s==NULL){ //内存不足 
		return false;
	}
	s->next=p->next;
	p->next=s;
	s->data=p->data;
	p->data=e;
	return true;
}

11.删除结点操作

时间复杂度为O（n）

        删除结点操作就是将链表中位序为i的结点删除。同单链表的插入相同有含头结点和不含头结点的，这里按带头结点的展开。也同单链表的插入一样 需要先找到位序为i-1的结点 对它进行施法图例：

        其实质就是将i-1元素的指针域直接指向i+1的元素就把位序为i的元素删掉了。但是为了不浪费存储空间也需要用一个指针指向被删元素并将它free（释放）掉

12.删除结点返回被删除结点的值（按位序删）

时间复杂度为O（n）

//按位序删除（带头节点）
bool ListDelete(LinkList &L,int i,int &e){
	if(i<1){
		return false;
	}
	int j=0; 
	LNode *p;				      //用来指向被删除元素的前一个
	while(p!=NULL && j<i-1){
		p=p->next;
		j++;
	}
	if(p==NULL){
		return false;
	}	
	if(p->next==NULL){
		return false;
	}
	e=p->next->data;   			  //取到被删元素的值 
	LNode *deletedNode;		      //用来指向被删除元素 因为需要free()
	deletedNode=p->next;
	p->next=deletedNode->next;
	free(deletedNode);
	return true;
}

        同指定结点的前插操作一样，删除结点p的操作可以用删除p的后继结点操作实现。实质就是将后继结点的值赋予自身 然后删除后继结点。

13.求单链表表长操作（含头结点）

时间复杂度为O（n）

求表长操作就是计算单链表中的结点数（表长不含头结点！！！）从第一个结点开始顺序遍历每个结点。设置一个计数器 访问完一个结点（若此结点不空）计数器自增

//求表长操作（带头结点)
int ListLength(LinkList &L){
	int i=0,j;     			//i是计数器 j用于循环 
	LNode *p=L->next;        //p指向第一个结点 (头结点不算入表长)
	while(p!=NULL){
		i++;
		p=p->next;
	}
	return i;
}

三、完整代码

#include<stdio.h>
#include<stdlib.h>
typedef struct LNode{  //struct相当于java里的对象 使用typedef后struct LNode 类型可表示为LNode类型 
	int data;
	struct LNode *next;  //指针类型是 LNode 指向下一个整体 
}LNode,*LinkList; //LinkList类型等价于 LNode*类型； 使用不同的代表不同含义 创建结点用LNode 

//使用头插法建立单链表 （含头结点）
LinkList List_HeadInsert (LinkList &L){ //逆向建立单链表
	LNode *s;int x;
 	L=(LinkList)malloc(sizeof(LNode)); //创建头结点  ;
 	L->next=NULL;
 	scanf("%d",&x);						//输入第一个结点的值 
 	while(x!=9999){                      //输入9999表示结束 
		s=(LNode*)malloc(sizeof(LNode));
		s->data=x;
 		s->next=L->next;
 		L->next=s;
 		scanf("%d",&x);
 	}	
	return L;
}

//使用尾插法建立单链表（含头结点） 
LinkList List_TailInsert (LinkList &L){ //逆向建立单链表
 	L=(LinkList)malloc(sizeof(LNode)); 	//创建头结点 ;
	LNode *s,*r=L;int x; 					//s指向新节点  r指向尾结点 
 	L->next=NULL;
 	printf("依次输入结点值 输入9999表示结束");
 	scanf("%d",&x);						//输入第一个结点的值 
 	while(x!=9999){                      //输入9999表示结束 
		s=(LNode*)malloc(sizeof(LNode));
		s->data=x;
 		r->next=s;
 		r=s;
 		scanf("%d",&x);
 	}	
 	r->next=NULL;  						//尾结点置空 
	return L;
}

//按值查找
LNode *LocElement(LinkList &L,int value){
	LNode *p=L->next;
	while(p!=NULL&&p->data!=value){
		p=p->next;		            //未找到目标值的结点则一直往下找 
	}
	return p;						//找到了 返回此节点指针 
} 

//按位序查找
LNode *GetElement(LinkList &L,int i){
	int j;   						//用于计数 
	if(i<1){
		return NULL;           		//判断i值是否合法 
	}
	LNode *p=L->next; 
	while(p!=NULL&&j<i){
		p=p->next;	
		j++;	            //未找到目标值的结点则一直往下找 
	}
	return p;						//找到了 返回此节点指针 
} 

//单链表插入（按位序插入 带头结点） i表示元素位序 
bool ListInsert(LinkList &L,int i,int e){
	if(i<1){  //判断输入i值是否合法 
		return false; 
	}
	LNode *p;  //用p来指向每个结点  L就是头结点 
	p=L;
	int j=0; 
	while(p!=NULL && j<i-1){  //循环找到第i-1个结点 
		p=p->next;
		j++;
	} 
	if(p==NULL){ //判断p指向的是否是空值 
		return false;
	}
	LNode *s=(LNode*)malloc(sizeof(LNode));  //创建要插入的结点 
	s->data=e;  //这里可以直接
	s->next=p->next;
	p->next=s;
	return true;
}

//单链表插入（按位序插入 不带头结点） i表示元素位序 不带头结点：L永远指向最后一个结点 
bool ListInsert_NoHeadLNode(LinkList &L,int i,int e){
	if(i<1){  //判断输入i值是否合法 
		return false; 
	}
	if(i==1){  //当是第一个结点时需要单独考虑 因为它无next  无法插入 
		LNode *s=(LNode*)malloc(sizeof(LNode));
		s->data=e;
		s->next=L;
		L=s; //头指针指向新节点 
	} 
	if(i>1){
		LNode *p; //让p指向第一个节点  让p去扫描 
		p=L; 
		int j=1;
		while(p!=NULL && j<i-1){ //找到第i-1个结点 循环次数和带头结点的不一样哦 少一次  
			p=p->next; 
			j++;
		}
		if(p==NULL){  //i值不合法 
			return false; 
		}
		LNode *s=(LNode*)malloc(sizeof(LNode));
		s->data=e;
		s->next=p->next;
		p->next=s;
	}
	return true;
}

//给定指定节点的后插操作
bool InsertNextNode(LNode *p,int e){
	if(p==NULL){
		return false;
	}
	LNode *s=(LNode*)malloc(sizeof(LNode));
	if(s==NULL) {  //内存分配失败 
		return false;
	}
	s->data=e; 
	s->next=p->next;
	p->next=s;
}

//指定节点的前插操作 6  
bool InsertPriorNode(LNode *p,int e){
	if(p==NULL){
		return false;
	}
	LNode *s=(LNode*)malloc(sizeof(LNode));
	if(s==NULL){ //内存不足 
		return false;
	}
	s->next=p->next;
	p->next=s;
	s->data=p->data;
	p->data=e;
	return true;
}

//按位序删除（带头节点）
bool ListDelete(LinkList &L,int i,int &e){
	if(i<1){
		return false;
	}
	int j=0; 
	LNode *p=L;				      //用来指向被删除元素的前一个
	while(p!=NULL && j<i-1){
		p=p->next;
		j++;
	}
	if(p==NULL){
		return false;
	}	
	if(p->next==NULL){
		return false;
	}
	e=p->next->data;   			  //取到被删元素的值 
	LNode *deletedNode;		      //用来指向被删除元素 因为需要free()
	deletedNode=p->next;
	p->next=deletedNode->next;
	free(deletedNode);
	return true;
} 

//求表长操作（带头结点)
int ListLength(LinkList &L){
	int i=0,j;     			//i是计数器 j用于循环 
	LNode *p=L->next;        //p指向第一个结点 (头结点不算入表长)
	while(p!=NULL){
		i++;
		p=p->next;
	}
	return i;
} 

//打印链表(带头结点)
void PrintList(LinkList &L){
	int i;
	int j=ListLength(L);
	LNode *p=L->next;
	for(i=0;i<j;i++){
		printf("%d\n",p->data);
		p=p->next;
	}
}

//test 
int main(){
	int e;
	LinkList L;
	List_TailInsert(L);   //输入9999表示结束
	int j=ListLength(L);
	bool k=ListDelete(L,3,e);
	PrintList(L);
	printf("%d\n",j);
	printf("%d\n",e);
}

 

想要上岸的小李
关注
  • 4
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
【数据结构】链表
qq_35065724的博客
11-01 2222
链表，数据结构
单链表的初始化
Lianuuu的博客
10-05 1万+
1. 链表的节点 链表存储的数据元素，其物理存储位置是随机的，并通过指针表示数据之间逻辑关系 链表中每个数据的存储都由以下两部分组成： 数据元素本身，其所在的区域称为数据域； 指向直接后继元素的指针，所在的区域称为指针域； 链表节点结构如图所示： 链表实际存储的是一个一个的节点，真正的数据元素包含在这些节点中 链表中每个节点的具体实现，需要使用 C 语言中的结构体，具体实现代码为： typedef struct Link { char elem; //代表数据域 struct L
数据结构-单链表
最新发布
W2814595682的博客
05-25 420
单链表的基本操作
数据结构-1.单链表的初始化
chengxuyuanzq的博客
09-03 5541
单链表是最基础的数据结构，由于之前专业课听得一脸懵，所以现在重新学习数据结构。学好单链表也是为了之后的学习打基础。
链表的初始化、取值、查找、插入、删除
m0_68002095的博客
03-13 3886
以上代码中，定义了一个`ListNode`结构体，其中`val`表示节点的值，`next`表示指向下一个节点的指针。在`getVal`函数中，使用循环遍历链表中的节点，如果找到了第`i`个节点，则返回其值。以上代码中，定义了一个`ListNode`结构体，其中`val`表示节点的值，`next`表示指向下一个节点的指针。以上代码中，定义了一个`ListNode`结构体，其中`val`表示节点的值，`next`表示指向下一个节点的指针。缺点是访问节点的时间复杂度为 O(n)，其中 n 表示链表的长度。
C语言单链表实现初始化、创建、增、删、查等基本操作（详细）
热门推荐
莫浅子的博客
08-31 2万+
一、单链表的定义及初始化 1、定义 2、初始化 1)不带头结点的单链表 2)带头节的单链表 二、单链表插入和删除 1)插入 1、按位序插入（带头结点） 2、按位插入（不带头结点） 3、指定结点的后插操作 4、指定结点的前插操作 2）删除 1、按位序删除（带头结点） 2、指定结点删除 3、指定最后结点的删除 三、查找 1）按位查找 2）按值查找 四、建立 1）头插法 2）尾插法 六、补充求单链表长度 ...
cpp代码-单链表的CRUD
07-14
本项目主要探讨了如何使用C++语言实现单链表的创建(Create)、读取(Retrieve)、更新(Update)和删除(Delete)操作，即CRUD操作。下面我们将详细讲解这些知识点。 首先，我们需要理解单链表的基本概念。单链表是由一...
cpp代码-循环单链表CRUD
07-14
创建循环单链表涉及定义节点结构，初始化头节点，以及添加节点。在`main.cpp`中，我们可能会看到类似以下的代码： ```cpp struct Node { int data; Node* next; }; Node* createNode(int value) { Node* new...
一：线性表:链表的初始化操作及应用
@76135327的博客
11-17 6180
内容节点结构InitList(*L):初始化一个线性表ListEmpty(L):判断是否为空表ClearList(*L):清空线性表GetElem(L,i,*e):将表中的第i个元素，返回给eLocateElem(L,e)：查找表中是否有与e相等元素ListInsert(L,i,e):在线性表的第i个位置插入元素eListDelete(*L,i,*e):删除线性表中的第i个元素，并将值返回给eListLength(L): 返回线性表元素的个数头插法插入元素尾插法求两个线性表La和Lb的并集求两个线性表La和
[数据结构与算法] 线性表之单链表初始化详解
淋曦的进击手记
08-21 2442
根据数据的存储结构，数据结构可分为数组和链表。数组：连续的内存空间。链表：离散的内存空间。链表通过指针将一组离散的内存块串联在一起。每个内存块称为链表的节点，每个节点包含数据域和指针域。单链表通过任意的存储单元存储线性表中的数据元素，每个节点由数据域和指针域两部分组成，如下图，其中data为数据域，存放数据元素，next为指针域，存放其直接后继节点的地址。链表，一定要保证尾节点的指针置空。每一个节点要至少被一个指针指向。
链表初始化、插入、遍历功能实现----2021-08-17
Enoch-dj
08-30 2577
单向链表： 在前几讲中，我们对动态数组进行了讲解，在讲解链表之前我觉得还是需要清楚的知道动态数组和链表之间的区别和联系，为之后对链表的操作打好基础。 首先，动态数组是在堆区开发的一个连续可拓展的内存区域，链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。至于链表内部的组成结构我们后面再进行讲解。所以这里有必要先对这两者之间进行优点和缺点的比较。 动态数组的优点： 无需为线性表中的逻辑关系增加额外的空间。 可以快速的获取表中合法位置的元素。 动态数组的缺
单链表初始化保姆级讲解
weixin_61488314的博客
10-20 1768
链表的学习是数据结构中的重中之重,一定要把这里彻底搞懂,后面的只是自然就是一通百通 首先我们在学习单链表的时候之前,要对指针有一定的了解,链表与线性表最大的不同就在于,线性表的每一个数据存储的地址是连续的的,而链表每一个节点的地址是随机分配的。 下面我们来逐一讲解一下每一步的操作： 1.所需要的头文件和自定义 #include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR 0 typedef int ElemT
单链表的基本操作
m0_51697147的博客
11-12 1126
链表的存储结构在逻辑上、概念上的连续结构，但在实际的物理存储上是非连续、非顺序的。 它的存储单元以结点为单位，每一个结点由数据域和指针域两个域组成。数据域存储数据元素信息data，指针域存储直接后继存储位置next。 整个链表的存取必须从头指针开始进行，头指针指链表中第一个结点（即第一个数据元素的存储映像，也称首元结点）的存储位置。同时，由于最后一个数据元素没有直接后继，则单链表中最后一个结点的指针为空（null）。 头指针有两种情况： （1）为了方便处理，在单链表的第一个结点（首元结点）之前附
单链表的十三个基本操作（全）
兔子王
10-03 5190
有关单链表的十三个基本操作，包括了 1、初始化单链表 2、插入 3、删除 4、查找 5、逆置 6、排序 7、删除指定数 8、指定交换顺序 9、求单链表长度 10、修改 11、最大值 12、按序插入 13、删除重复值
数据结构——单链表
2301_77179941的博客
05-04 3572
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) +指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 ​
单链表
u014520406的博客
06-29 1850
单链表，顾名思义是线性表的链式存储结构，是用一组任意的存储单元存储线性表的数据元素（这个存储单元可以是连续的，也可以是不连续的）。单链表的单位是节点，每个节点包括两个域，其中存储数据元素信息的域称为数据域；存储直接后继存储位置的域称为指针域，指针域中存储的信息叫做指针。如图： 节点的指针域存储的是指向下一个元素的地址，因此我们可以将链表画成用箭头相链接的节点的序列，节点之间的箭头表示指针。如
链表的初始化与使用
weixin_47211735的博客
03-11 632
/(10)删除单链表h的第n个元素，延用第（6）的n////(2)依次采用尾插法插入元素：a,b,c,d,e////(8)在第m个元素位置上插入f元素，m由用户输入////(6)输出单链表h的第n个元素，n由用户输入////(5)判断单链表h是否为空，输出判断结果////(4)输出单链表h的长度////(7)输出元素a的位置////(1)初始化单链表h////(11)输出单链表h////(12)释放单链表h////(3)输出单链表h////(9)输出单链表h//
链表的初始化【C语言】
少年一贯快马扬帆，道阻且长不转弯； 要盛大，要绚烂，要哗然； 要用理想的泰坦尼克，去撞现实的冰川； 要当烧赤壁的风，而非借鉴草船； 要为了一片海，就肯翻万山。
07-20 4265
/*By yangbocsu 线性表之链表 2021.07.20*/ #include <stdio.h> #include <stdlib.h> /*预定义常量和类型*/ /*函数结果状态码*/ #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -
avue-crud初始化列表
09-06
在使用 Avue-Crud 进行列表初始化时，你可以按照以下步骤操作： 1. 首先，在你的组件中引入 `avue-crud` 组件： ```javascript import AvueCrud from 'avue-plugin-crud' ``` 2. 在 `data` 属性中定义 `crudOptions` 对象，该对象包含了 Avue-Crud 的配置项。你可以根据自己的需求进行配置。其中，`columns` 属性定义了表格的列信息，`formOptions` 属性定义了表单的选项。 ```javascript data() { return { crudOptions: { columns: [ { label: '姓名', prop: 'name' }, { label: '年龄', prop: 'age' }, // 其他列... ], formOptions: { // 表单选项配置... } } } } ``` 3. 在模板中使用 `avue-crud` 组件，并绑定 `crudOptions` 对象作为属性传递给组件。 ```html <template> <avue-crud :options="crudOptions"></avue-crud> </template> ``` 通过以上步骤，你就可以使用 Avue-Crud 初始化列表了。记得根据实际需求进行相应的配置。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

想要上岸的小李

劳作不易，请勿白嫖

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值