数据结构 单链表基本操作代码
单链表头插法代码

单链表头插法代码单链表是一种常见的数据结构,它由多个节点组成,每个节点包括两部分:一个数据存储区和一个指向下一个节点的指针。
插入操作是单链表的基本操作之一,在插入一个节点时,可以采用两种方法:头插法和尾插法。
在本篇文章中,我们将重点讲解单链表的头插法。
头插法是指在单链表的头节点之前插入一个新节点。
这种方法需要先创建一个新节点,并将其指针指向原头节点所指向的节点。
然后再将头节点的指针指向新节点。
相当于是在链表的头部插入新节点。
下面是头插法的代码实现:```struct node {int data;struct node *next;};void insert_node(struct node **head, int value) {struct node *new_node = (struct node*)malloc(sizeof(struct node));new_node->data = value;new_node->next = *head;*head = new_node;}```在上面的代码中,我们首先定义了一个节点结构体node,其中包含一个int类型的数据成员data和一个指向下一个节点的指针成员next。
然后,我们定义一个函数insert_node,这个函数的作用是向单链表中插入新的节点。
其中,head是指向链表头节点的指针,value 是要插入的节点的值。
在insert_node函数体中,我们首先通过malloc函数动态分配内存,创建一个新节点new_node。
然后,将新节点的data成员赋值为value,将新节点的next指针指向原head指针所指向的节点,最后将head指针指向新节点new_node。
这样,新节点就插入到链表的头部了。
总结一下,头插法是单链表中比较常用的一种插入节点的方式,通过这种方法,可以很方便地在链表头部插入新节点。
在实现的过程中需要注意,在创建新节点时要手动分配内存,否则会发生内存错误。
数据结构-单链表基本操作实现(含全部代码)

数据结构-单链表基本操作实现(含全部代码)今天是单链表的实现,主要实现函数如下:InitList(LinkList &L) 参数:单链表L 功能:初始化时间复杂度 O(1)ListLength(LinkList L) 参数:单链表L 功能:获得单链表长度时间复杂度O(n)ListInsert(LinkList &L,int i,ElemType e) 参数:单链表L,位置i,元素e 功能:位置i后插时间复杂度O(n)[加⼊了查找]若已知指针p指向的后插 O(1)ListDelete(LinkList &L,int i) 参数:单链表L,位置i 功能:删除位置i元素时间复杂度O(n)[加⼊了查找]若已知p指针指向的删除最好是O(1),因为可以与后继结点交换数据域,然后删除后继结点。
最坏是O(n),即从头查找p之前的结点,然后删除p所指结点LocateElem(LinkList L,ElemType e) 参数:单链表L,元素e 功能:查找第⼀个等于e的元素,返回指针时间复杂度O(n)代码:/*Project: single linkeed list (数据结构单链表)Date: 2018/09/14Author: Frank YuInitList(LinkList &L) 参数:单链表L 功能:初始化时间复杂度 O(1)ListLength(LinkList L) 参数:单链表L 功能:获得单链表长度时间复杂度O(n)ListInsert(LinkList &L,int i,ElemType e) 参数:单链表L,位置i,元素e 功能:位置i后插时间复杂度O(n)[加⼊了查找]若已知指针p指向的后插 O(1)ListDelete(LinkList &L,int i) 参数:单链表L,位置i 功能:删除位置i元素时间复杂度O(n)[加⼊了查找]若已知p指针指向的删除最好是O(1),因为可以与后继结点交换数据域,然后删除后继结点。
数据结构实验报告实现单链表各种基本运算的算法

实验截图(1)void InitList(LinkNode *&L)//初始化线性表{L=(LinkNode *)malloc(sizeof(LinkNode)); //创建头结点L->next=NULL;//单链表置为空表}void DestroyList(LinkNode *&L)//销毁线性表{LinkNode *pre=L,*p=pre->next;实验截图(2)bool GetElem(LinkNode *L,int i,ElemType &e) //求线性表中第i个元素值{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L;//p指向头结点,j置为0(即头结点的序号为0) while (j<i && p!=NULL)//找第i个结点p{ j++;p=p->next;}if (p==NULL)//存在值为e的结点,返回其逻辑序号ireturn(i);}实验截图(3)bool ListInsert(LinkNode *&L,int i,ElemType e) //插入第i个元素{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L,*s;//p指向头结点,j置为0(即头结点的序号为0) while (j<i-1 && p!=NULL)//查找第i-1个结点p{ j++;p=p->next;}}实验截图(4)编写exp2-2.cpp程序包含有关代码//文件名:exp2-2.cpp#include "linklist.cpp"int main(){LinkNode *h;ElemType e;printf("单链表的基本运算如下:\n");printf(" (1)初始化单链表h\n");InitList(h);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");return 1;}实验截图(5)运行得到结果实验截图(6)。
单链表基本操作的实现

单链表基本操作的实现单链表是一种常见的数据结构,它由多个节点组合而成,每个节点包含一个数据元素和一个指向下一个节点的指针。
通过指针,我们可以方便地在单链表中进行插入、删除和遍历等操作。
以下是关于单链表基本操作的实现。
1. 单链表的创建单链表的创建需要定义一个空的头结点,它的作用是方便在链表的头部进行添加和删除节点操作。
一个空的头节点可以在链表初始化的过程中进行创建。
```typedef struct Node{int data;struct Node *next;}Node;Node *createList(){Node *head = (Node*)malloc(sizeof(Node)); //创建空的头节点head->next = NULL;return head; //返回头节点的地址}```2. 单链表的插入单链表的插入可以分为在链表头部插入、在链表尾部插入和在链表中间插入三种情况。
a. 在链表头部插入节点:```void insertAtHead(Node *head, int data){Node *node = (Node*)malloc(sizeof(Node));node->data = data;node->next = head->next;head->next = node;}```b. 在链表尾部插入节点:```void insertAtTail(Node *head, int data){Node *node = (Node*)malloc(sizeof(Node));node->data = data;node->next = NULL;Node *p = head;while(p->next != NULL){p = p->next;}p->next = node;}```c. 在链表中间插入节点:```void insertAtMid(Node *head, int data, int pos){ Node *node = (Node*)malloc(sizeof(Node)); node->data = data;node->next = NULL;Node *p = head;int count = 0;while(p->next != NULL && count < pos-1){ p = p->next;count++;}if(count == pos-1){node->next = p->next;p->next = node;}else{printf("插入位置错误!");}}```3. 单链表的删除单链表的删除可以分为在链表头部删除、在链表尾部删除和在链表中间删除三种情况。
数据结构经典代码(严蔚敏)

/* 线性表的顺序表示:类型和界面定义*//* 线性表的顺序表示:函数实现*//* 线性表的单链表表示:类型和界面函数定义*//* 线性表的单链表表示:函数实现*//* 线性表的顺序表示:类型和界面定义*//* 线性表的顺序表示:函数实现*//* 用顺序表解决josephus问题的算法*//* 用循环单链表解决josephus问题的算法*//*字符串的顺序表示*//* 字符串的链接表示 *//* 顺序栈表示:类型和界面函数声明 *//* 顺序栈表示:函数定义 *//* 栈链接表示:类型和界面函数声明 *//*栈链接表示:函数定义*//* 简化背包问题的递归算法*//* 简化背包问题的非递归算法*//* 迷宫问题的递归算法*//* 迷宫问题的非递归算法(栈实现)*//* 队列的顺序表示:类型和函数声明 *//* 队列的顺序表示:函数定义 *//*队列链接表示:类型和界面函数声明*//*队列链接表示:函数定义*//* 用队列解决农夫过河问题的算法*//* 树的长子-兄弟表示法*//* 树的父指针表示法*//* 树的子表表示法*//* 树的后根周游的递归算法*//* 树的先根周游的非递归算法*//* 树的中根周游的递归算法*//* 树的后根周游的递归算法*//* 树的广度优先周游算法*//* 二叉树的链接表示*//* 二叉树的顺序表示*//* 线索二叉树的定义,构造算法和中根周游算法*//* 二叉树前根周游的递归算法*//* 二叉树对称根周游的递归算法*//* 二叉树后根周游的递归算法*//* 二叉树后根周游的非递归算法*//* 本程序提供了用顺序表实现字典的存储表示定义*//* 本程序是用开地址法解决碰撞的散列表示方法,提供了字典的一些基本操作*//* 字典的二叉排序树实现,本程序实现了二叉排序树的基本操作的算法*/ /* 字典的AVL树实现*//* 本程序提供了用顺序表实现字典的情况下的顺序检索算法*//* 本程序提供了用顺序表实现字典的情况下的二分法检索算法*//* 本程序是用开地址法实现散列的检索算法*//* 二叉排序树的检索算法*//* AVL树的检索算法*//* 最佳二叉排序树是具有最佳检索效率的二叉排序树, 本程序提供了最佳二叉排序树的构造方法*//* 直接插入排序的算法源程序*//* 二分法插入排序的算法源程序*//* 表插入排序的算法源程序*//* shell排序的算法源程序 *//* 直接选择排序的算法源程序*//* 堆排序的算法源程序*//* 起泡排序的算法源程序*//* 快速排序的算法源程序*//* 基数排序的算法源程序*//* 二路归并排序算法的源程序*//* 用图邻接矩阵表示实现的一些基本运算*//* 用图邻接表表示实现的一些基本运算*//* 用邻接矩阵表示的图的广度优先周游算法*//* 用邻接表表示的图的广度优先周游算法*//* 用邻接矩阵表示的图的深度优先周游的递归算法*/ /* 用邻接矩阵表示的图的深度优先周游的非递归算法*/ /* 用邻接表表示的图的深度优先周游的非递归算法*/ /* 用邻接矩阵表示的图的Kruskal算法的源程序*//* 用邻接矩阵表示的图的prim算法的源程序*//* 用邻接矩阵表示的图的Dijkstra算法的源程序*//* 用邻接矩阵表示的图的Floyd算法的源程序*//* 用邻接表表示图的拓扑排序算法*//* 用邻接矩阵表示图的拓扑排序算法*//* 图的关键路径问题的算法*//* 背包问题的贪心法算法*//* 用动态规划法求组和数的算法*//* 用回溯法解决骑士周游问题的算法*//* 0/1背包问题的回溯法算法*//* 0/1背包问题的动态规划法算法*//* 0/1背包问题的分支定界法算法*//* 线性表的顺序表示:类型和界面定义*/#define TRUE 1#define FALSE 0#define SPECIAL -1/* 定义顺序表的大小。
JAVA数据结构——单链表的操作

单链表的操作方法一:package ch02;(1)建立结点类Node.javapublic class Node {public Object data;//存放结点数据值public Node next;//存放后继结点//无参构造函数public Node(){ this(null,null);}//只有结点值的构造函数public Node(Object data){ this(data,null);}//带有节点值和后继结点的构造函数public Node(Object data,Node next){ this.data=data;this.next=next;}}(2)建立链表及操作LinkList.javapackage ch02;import java.util.Scanner;public class LinkList implements IList{public Node head;//单链表的头指针//构造函数初始化头结点public LinkList(){head=new Node();}//构造函数构造长度为n的单链表public LinkList(int n,boolean Order) throws Exception{ this();if(Order)create1(n); //头插法顺序建立单链表elsecreate2(n); //尾插法逆序建立单链表}//头插法顺序建立单链表public void create1(int n) throws Exception{Scanner sc=new Scanner(System.in);System.out.println("请输入结点的数据(头插法):”);for(int i=0;i<n;i++){insert(0,sc.next());}}//尾插法逆序建立单链表public void create2(int n) throws Exception{Scanner sc=new Scanner(System.in);System. out.println("请输入结点的数据(尾插法):");for(int i=0;i<n;i++){insert(length(),sc.next());}}//将链表置空public void clear(){head.data=null;head.next=null;}//判断链表是否为空public boolean isEmpty(){return head.next==null;}//返回链表长度public int length(){Node p=head.next;int length=0;while(p!=null){p=p.next;length++;//返回P不空长度length加1}return length;}//读取并返回第i个位置的数据元素public Object get(int i) throws Exception {Node p=head.next;int j;//从首结点开始向后查找,直到9指向第i个结点或者p为nullfor(j=0;j<i&&p!=null;j++){ p=p.next;}if(j>i||p==null)//i不合法时抛出异常throw new Exception("第"+i+”个数据元素不存在”);return p.data;}//插入乂作为第i个元素public void insert(int i, Object x) throws Exception{ Node p=head;int j=-1;//寻找第i个结点的前驱i-1while(p!=null&&j<i-1){p=p.next;j++;}if(j>i-l||p==null)//i不合法时抛出异常throw new Exception("插入位置不合法”);Node s=new Node(x);s.next=p.next;p.next=s;}//删除第i个元素public void remove(int i) throws Exception{ Node p=head;int j=-1;while(p!=null&&j<i-1){//寻找第i-1 个节点p=p.next;j++;}if(j>i-1||p.next==null)throw new Exception("删除位置不合法”);p.next=p.next.next;}//返回元素x首次出现的位序号public int indexOf(Object x) {Node p=head.next;int j=0;while(p!=null&&!p.data.equals(x)){p=p.next;j++;if(p!=null)return j;elsereturn -1;}public void display(){Node p=head.next;while(p!=null){if(p.next==null)System.out.print(p.data);elseSystem.out.print(p.data+"f );p=p.next;}}}(3)建立测试类Test.javappublic class test {public static void main(String[] args) throws Exception { // TODO Auto-generated method stubScanner sc=new Scanner(System.in);boolean or;int xz,xx;System.out.println("请选择插入的方法:0、头插法,1、尾插法");xz=sc.nextInt();if(xz!=0)or=true;elseor=false;System. out.println("请插入的结点的个数:”);xx=sc.nextInt();LinkList L=new LinkList(xx,or);System.out.println("建立的链表为:");L.display();System.out.println();System.out.println("链表的长度:"+L.length());System. out.println(”请输入查找的结点的数据:”);Object x=sc.next();int position=L.indexOf(x);System.out.println("结点的数据为:"+x+"的位置为:"+position); System. out.println("请输入删除的结点的位置:”);int sr=sc.nextInt();L.remove(sr);L.display();System.out.println();System.out.println("链表的长度:"+L.length()); }品P rob I em & J a vs d oc / Declaration Q Error Log 里Con sole-M、、■=:termin8ted> test [3] [Java Application] C U &ert\Ad im i n i st rat o r\Ap p Data\L o cs I请选择插入.的方法:0、头插法,lv星插法请插入的特点的个数:请愉入结点的颓据(尾插法):A B C E D F建立的旌表为;A+B T C+E T D+F链表的长度:6请输入查找的结点的数据:结点的数据为:E的位置为:3请输入删除的结点的位置,R+B T E+DW道表的长度:S方法二(引入get和set方法)Package sy;import java.util.Scanner;//单链表的结点类public class Node {private Object data; //存放结点值private Node next; //后继结点的引用public Node() { //无参数时的构造函数this(null, null);}public Node(Object data) { // 构造值为data 的结点this(data, null);}public Node(Object data, Node next) {//构造值为data 和next 的结点构造函数this.data = data;this.next = next;}public Object getData() { return data;}public void setData(Object data) {this.data = data;}public Node getNext() { return next;public void setNext(Node next) { this.next = next;}}//实现链表的基本操作类public class LinkList {Node head=new Node();//生成一个带头结点的空链表//根据输入的一系列整数,以0标志结束,用头插法建立单链表public void creat() throws Exception {Scanner sc = new Scanner(System.in); //构造用于输入的对象for (int x=sc.nextInt(); x!=0; x=sc.nextInt()) //输入若干个数据元素的值(以0结束) insert(0, x);//生成新结点,插入到表头}//返回带头结点的单链表中第i个结点的数据域的值。
数据结构实验报告实现单链表各种基本运算的算法
实验截图(1)void InitList(LinkNode *&L)//初始化线性表{L=(LinkNode *)malloc(sizeof(LinkNode)); //创建头结点L->next=NULL;//单链表置为空表}void DestroyList(LinkNode *&L)//销毁线性表{LinkNode *pre=L,*p=pre->next;实验截图(2)bool GetElem(LinkNode *L,int i,ElemType &e) //求线性表中第i个元素值{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L;//p指向头结点,j置为0(即头结点的序号为0) while (j<i && p!=NULL)//找第i个结点p{ j++;p=p->next;}if (p==NULL)//存在值为e的结点,返回其逻辑序号ireturn(i);}实验截图(3)bool ListInsert(LinkNode *&L,int i,ElemType e) //插入第i个元素{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L,*s;//p指向头结点,j置为0(即头结点的序号为0) while (j<i-1 && p!=NULL)//查找第i-1个结点p{ j++;p=p->next;}}实验截图(4)编写exp2-2.cpp程序包含有关代码//文件名:exp2-2.cpp#include "linklist.cpp"int main(){LinkNode *h;ElemType e;printf("单链表的基本运算如下:\n");printf(" (1)初始化单链表h\n");InitList(h);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");return 1;}实验截图(5)运行得到结果实验截图(6)。
《数据结构》实验3链表
三、源代码以及实验结果为
四、源代码以及实验结果为
五、源代码以及实验结果为
六、源代码以及实验结果为
七、附加题以及实验体会:
{
NODE *s; /*定义指向结点类型的指针*/
s=(NODE *)malloc(sizeof(NODE));
/*生成新结点*/
3
4
5
return 1;
}
/*删除P所指向的结点的后继结点*/
void DelLinkList(NODE *p)
{ NODE *q;
if(p->next!=0)
{ q=p->next; /* q指向p的后继结点*/
ch=getchar();
while(ch!='$')
{ p=(NODE *)malloc(sizeof(NODE));
p->data=ch;
1
2
ch=getchar();
}
return (head);
}
/*在链表的P指定结点之后插入值为x的结点*/
int InsLinkList(NODE *p, char x)
四、设有两个单链表A、B,其中元素递增有序,编写算法将A、B归并成一个按元素值递减(允许有相同值)有序的链表C,要求用A、B中的原结点形成,不能重新申请结点。
五、已知单链表表示的线性表中含有两类的数据元素(字母字符,数字字符)。试设计算法,按结点的值将单链表拆分成两个循环链表,分别只含有数字或字母。要求:利用原表中的结点空间作为这两个表的结点空间,头结点可另开辟空间。
附加题:如果换成循环单链表该如何实现?
即题目变成:已知单循环链表表示的线性表中含有两类的数据元素(字母字符,数字字符)。试设计算法,按结点的值将单链表拆分成两个循环链表,分别只含有数字或字母。
数据结构实验报告单链表
数据结构实验报告_单链表数据结构实验报告——单链表一、实验目的1.掌握单链表的基本概念和原理。
2.了解单链表在计算机科学中的应用。
3.掌握单链表的基本操作,如插入、删除、遍历等。
4.通过实验,加深对理论知识的理解,提高编程能力。
二、实验内容1.实验原理:单链表是一种线性数据结构,由一系列节点组成,每个节点包含数据域和指针域。
其中,指针域指向下一个节点,最后一个节点的指针域指向空。
单链表的主要操作包括插入、删除、遍历等。
2.实验步骤:(1)创建一个单链表。
(2)实现插入操作,即在链表的末尾插入一个新节点。
(3)实现删除操作,即删除链表中的一个指定节点。
(4)实现遍历操作,即输出链表中所有节点的数据。
3.实验代码:下面是使用Python语言实现的单链表及其基本操作的示例代码。
class Node:def __init__(self, data):self.data = dataself.next = Noneclass LinkedList:def __init__(self):self.head = Nonedef insert(self, data):new_node = Node(data)if self.head is None:self.head = new_nodeelse:current = self.headwhile current.next is not None:current = current.nextcurrent.next = new_nodedef delete(self, data):if self.head is None:returnif self.head.data == data:self.head = self.head.nextreturncurrent = self.headwhile current.next is not None and current.next.data != data:current = current.nextif current.next is None:returncurrent.next = current.next.nextdef traverse(self):current = self.headwhile current is not None:print(current.data)current = current.next4.实验结果:通过运行上述代码,我们可以看到单链表的基本操作得到了实现。
数据结构c++顺序表、单链表的基本操作,查找、排序代码
} return 0; }
实验三 查找
实验名称: 实验3 查找 实验目的:掌握顺序表和有序表的查找方法及算法实现;掌握二叉排序 树和哈希表的构造和查找方法。通过上机操作,理解如何科学地组织信 息存储,并选择高效的查找算法。 实验内容:(2选1)内容1: 基本查找算法;内容2: 哈希表设计。 实验要求:1)在C++系统中编程实现;2)选择合适的数据结构实现查 找算法;3)写出算法设计的基本原理或画出流程图;4)算法实现代码 简洁明了;关键语句要有注释;5)给出调试和测试结果;6)完成实验 报告。 实验步骤: (1)算法设计 a.构造哈希函数的方法很多,常用的有(1)直接定址法(2)数字分析法;(3) 平方取中法;(4)折叠法;( 5)除留余数法;(6)随机数法;本实验采用的是除 留余数法:取关键字被某个不大于哈希表表长m的数p除后所得余数为哈 希地址 (2)算法实现 hash hashlist[n]; void listname(){ char *f; int s0,r,i; NameList[0].py="baojie"; NameList[1].py="chengቤተ መጻሕፍቲ ባይዱoyang"; ……………………………… NameList[29].py="wurenke"; for(i=0;i<q;i++){s0=0;f=NameList[i].py; for(r=0;*(f+r)!='\0';r++) s0+=*(f+r);NameList[i].k=s0; }} void creathash(){int i;
v[k-1]=v[k]; nn=nn-1; return ; } int main() {sq_LList<double>s1(100); cout<<"第一次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.ins_sq_LList(0,1.5); s1.ins_sq_LList(1,2.5); s1.ins_sq_LList(4,3.5); cout<<"第二次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.del_sq_LList(0); s1.del_sq_LList(2); cout<<"第三次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); return 0; } 运行及结果:
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验一单链表
#include "stdio.h"
#include "stdlib.h"
typedef int ElemType;
typedef struct LNode
{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
void creatLNode(LinkList &head)
{
int i,n;
LNode *p;
head=(LNode*)malloc(sizeof(LNode));
head->next=NULL;
printf("请输入链表的元素个数:");
scanf("%d",&n);
for(i=n;i>0;i--)
{
p=(LNode*)malloc(sizeof(LNode));
printf("第%d个元素:",i);
scanf("%d",&p->data);
p->next=head->next;
head->next=p;
}
}
void InsertLNode(LinkList &L)
{
LNode *p=L;
int i,j=0,e;
printf("请输入你要插入的位置(超过链表长度的默认插在最后!):");
scanf("%d",&i);
printf("请输入你要插入的元素:");
scanf("%d",&e);
while (p->next&&j<i-1)
{
p=p->next;
++j;
}
LNode *s;
s=(LNode*)malloc(sizeof(LNode));
s->data=e;
s->next=p->next;
p->next=s;
}
int DeleteLNode(LinkList &L,int i,int &e) {
LNode *p;
p=L;
LNode *q;
int j=0;
while (p->next&&j<i-1)
{
p=p->next;
++j;
}
if(!(p->next)||j>i-1)
{
printf("删除位置不合理!\n");
return 0;
}
q=p->next;
p->next=q->next;
e=q->data;
free(q);
return e;
}
void DeleteCF(LinkList &L)
{
LNode *p,*s,*r;
p=L->next;
while(p!=NULL)
{
r=p;
s=r->next;
while(s!=NULL)
{
if(p->data==s->data)
{
r->next=s->next;
s=s->next;
}
else
{
r=r->next;
s=s->next;
}
}
p=p->next;
}
}
void display(LinkList &L)
{
LNode *p;
p=L->next;
while(p!=NULL)
{
printf("%d ",p->data);
p=p->next;
}
printf("\n");
}
void main()
{
printf("线性链表的基本操作\n");
LinkList L;
creatLNode(L);
printf("初始链表为:");
display(L);
InsertLNode(L);
printf("插入元素后的链表为:");
display(L);
int e=0;
e=DeleteLNode(L,2,e); //删除链表中的第二个元素printf("删除元素后的链表为:");
display(L);
printf("你删除的元素为:%d\n",e);
printf("\n\n\n");
printf("单链表重复元素的删除\n");
LinkList L1;
creatLNode(L1);
printf("初始链表为:");
display(L1);
DeleteCF(L1);
printf("删除重复元素后为:");
display(L1);
}。