单链表完整程序
单链表的基本操作
10)调用头插法的函数,分别输入10,20,分别回车:
11)调用尾插法的函数,分别输入30,40
12)查找单链表的第四个元素:
13)主函数中传入参数,删除单链表的第一个结点:
14)主函数传入参数,删除第0个未位置的元素,程序报错:
15)最后,输出单链表中的元素:
return 0;
}
6)编译,连接,运行源代码:
7)输入8,回车,并输入8个数,用空格分隔开,根据输出信息,可以看出,链表已经拆分为两个
五、实验总结
1.单链表采用的是数据+指针的表示形式,指针域总是指向下一个结
点(结构体)的地址,因此,在内存中的地址空间可以是不连续的,操作比顺序存储更加的方便
2.单链表使用时,需要用malloc函数申请地址空间,最后,删除元
素时,使用free函数释放空间。
编写打印出一个单链表的所有元素的程序
编写打印出⼀个单链表的所有元素的程序//Building a linked list in C//The following program shows how a simple, linear linked list can be constructed in C, using dynamic memory allocation and pointers. #include "stdafx.h"#include<stdlib.h>#include<stdio.h>struct list_el {int val;struct list_el * next;};typedef struct list_el item;void main() {item * curr, * head;int i;head = NULL;for(i=1;i<=10;i++) {curr = (item *)malloc(sizeof(item));curr->val = i;curr->next = head;head = curr;}curr = head;while(curr){printf("%d\t", curr->val);curr = curr->next ;}getchar();}输出 10 9 8 7 6 5 4 3 2 1单链表的添加,删除,打印操作代码#include "stdafx.h"#include <stdio.h>#include <stdlib.h>typedef struct node{int data;struct node * next;}LLIST;LLIST *list_add(LLIST **p,int i);void list_remove(LLIST **p);LLIST **list_search(LLIST **n,int i);void list_print(LLIST *n);LLIST *list_add(LLIST **p,int i){if(p==NULL)return NULL;LLIST *n=(LLIST *)malloc(sizeof(LLIST));if(n==NULL)return NULL;n->next=*p;*p=n; //头指针移动到开始处n->data=i;return *p;}void list_remove(LLIST **p){if(p!=NULL&&*p!=NULL){LLIST *n=*p;*p=(*p)->next;free(n);}}LLIST **list_search(LLIST **n,int i){if(n==NULL)return NULL;while(*n!=NULL){if((*n)->data==i){return n;}n=&(*n)->next;return NULL;}}void list_print(LLIST *n){if(n==NULL){printf("list is empty\n");}while(n!=NULL){printf("print %p %p %d\n",n,n->next,n->data); n=n->next;}}int main(void){LLIST *n=NULL;list_add(&n,0);list_add(&n,1);list_add(&n,2);list_add(&n,3);list_add(&n,4);list_print(n);printf("------------------end-------------------\n");list_remove(&n);list_remove(&n->next);list_remove(list_search(&n,1));list_remove(&n->next);list_remove(&n);list_print(n);printf("------------------end-------------------\n");getchar();return0;}单链表的延伸操作:代码#include <stdio.h>#include <stdlib.h>#include <string.h>struct llist{char *str;struct llist *next;};int main(void){char line[1024];struct llist *head=NULL;struct llist *newa=NULL;int flag=0;while(fgets(line,1024,stdin)!=NULL){newa=(struct llist *)malloc(sizeof(struct llist));newa->next=head;head=newa;newa->str= strdup(line); //如果是line的话,所有的str都是最后⼀个输⼊的值 flag++;if(flag>10)break;}while(head!=NULL){printf("%s",head->str);head=head->next;}getchar();return0;}单链表的逆置操作代码#include <stdlib.h>#include <malloc.h>#define NULL 0#define OK 1typedef int ElemType;typedef int Status;//-----单链表的存储结构-----//typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;void CreastList_L(LinkList &L,int n){//创建带头结点的单链表LLNode *p,*q;int i;L=(LNode*)malloc(sizeof (LNode));L->next=NULL; //先建⽴⼀个带头结点的单链表p=L;for (i=1;i<=n;i++){q=(LNode*)malloc(sizeof(LNode)); //⽣成新结点 printf("Input the %dth data:",i);scanf("%d",&q->data); //输⼊元素值q->next=NULL;p->next=q;p=q;}}void ListInverse_L(LinkList &L){//单链表的就地逆置LNode *p,*q;p=L->next;L->next=NULL;while(p!=NULL){q=p->next; //没搞懂p->next=L->next;L->next=p;p=q;}}void PrintList(LinkList &L){//输出单链表LNode *p=L->next;while(p!=NULL){printf("%d",p->data);p=p->next;}}void main(){int n;LinkList La;printf("Input the list num:");scanf("%d",&n);CreastList_L(La,n);printf("Before Inverse the list is:");PrintList(La);ListInverse_L(La);printf("\nAfter Inverse the list is:");PrintList(La);printf("\n");getchar();}。
数据结构单链表实验报告
数据结构单链表实验报告实验目的:掌握单链表的基本操作,学会使用单链表实现各种算法。
实验内容:实现单链表的基本操作,包括创建、插入、删除、访问等。
利用单链表完成以下算法:- 单链表逆序- 查找单链表中的中间节点- 删除单链表中的倒数第K个节点- 合并两个有序单链表为一个有序单链表实验步骤:1. 创建单链表在创建单链表时,先定义一个结构体Node来表示链表中的节点,节点包括数据域和指针域,指针域指向下一个节点。
然后,用指针p指向链表的头节点,将头节点的指针域初始化为NULL。
2. 插入节点在单链表中插入节点的操作分为两种情况:- 在链表头插入节点- 在链表中间或尾部插入节点无论是哪种情况,先将新节点的指针域指向要插入的位置的下一个节点,再将要插入的位置的指针域指向新节点即可。
3. 删除节点删除链表节点的操作同样分为两种情况:- 删除头节点- 删除中间或尾部节点要删除头节点,先用一个指针将头节点指向的下一个节点保存起来,再将头节点释放掉。
要删除中间或尾部节点,先用一个指针指向要删除节点的前一个节点,然后将指向要删除节点的前一个节点的指针域指向要删除节点的下一个节点,最后将要删除的节点释放掉。
4. 单链表逆序单链表逆序可以使用三个指针来完成,分别为pre指针、cur指针和next指针。
首先将pre指针和cur指针指向NULL,然后循环遍历链表,将cur指针指向当前节点,将next指针指向当前节点的下一个节点,然后将当前节点的指针域指向pre指针,最后将pre指针和cur指针向前移动一个节点,继续进行循环。
5. 查找单链表中的中间节点查找单链表中的中间节点可以使用双指针法,将两个指针p1和p2都指向链表头,然后p1每次向前移动一个节点,而p2每次向前移动两个节点,当p2指向了链表尾部时,p1指向的节点即为中间节点。
6. 删除单链表中的倒数第K个节点删除单链表中的倒数第K个节点可以使用双指针法,在链表中定义两个指针p1和p2,p1指向链表头,p2指向第K个节点,然后p1和p2同时向前移动,直到p2指向链表尾部,此时p1指向的节点即为要删除的节点。
实现单链表的各种基本运算
实现单链表的各种基本运算一、实验目的了解单链表表的结构特点及有关概念,掌握单链表的各种基本操作算法思想及其实现。
二、实验内容编写一个程序,实现顺序表的各种基本运算:1、初始化单链表;2、单链表的插入;3、单链表的输出;4、求单链表的长度5、判断单链表是否为空;6、输出单链表的第i位置的元素;7、在单链表中查找一个给定元素在表中的位置;8、单链表的删除; 9、释放单链表三、算法思想与算法描述简图四、实验步骤与算法实现#include<stdio.h>#include<malloc.h>typedef char ElemType;typedef struct LNode//定义单链表{ ElemType data;struct LNode *next;}LinkList;void InitList(LinkList*&L){ L=(LinkList*)malloc(sizeof(LinkList));//创建头结点L->next=NULL;//头结点赋值为空}void DestroyList(LinkList*&L)//销毁单链表(释放单链表L占用的内存空间即逐一释放全部结点的空间){ LinkList*p=L,*q=p->next;while(q!=NULL){free(p);p=q;q=p->next;}free(p);}int ListEmpty(LinkList*L)//判线性表是否为空表ListEmpty(L){ return(L->next==NULL);}//若单链表L没有数据结点,则返回真,否则返回假。
int ListLength(LinkList*L)//求线性表的长度ListLength(L){ LinkList*p=L;int i=0;while(p->next!=NULL){i++;p=p->next;}return(i);//返回单链表L中数据结点的个数}void DispList(LinkList*L)//输出线性表DispList(L){LinkList*p=L->next;while (p!=NULL)//逐一扫描单链表L的每个数据结点,并显示各结点的data域值。
数据结构-单链表基本操作实现(含全部代码)
数据结构-单链表基本操作实现(含全部代码)今天是单链表的实现,主要实现函数如下: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),因为可以与后继结点交换数据域,然后删除后继结点。
PTA7-4单链表基本操作
PTA7-4单链表基本操作7-4 单链表基本操作请编写程序实现单链表插⼊、删除结点等基本算法。
给定⼀个单链表和⼀系列插⼊、删除结点的操作序列,输出实施上述操作后的链表。
单链表数据域值为整数。
输⼊格式:输⼊第1⾏为1个正整数n,表⽰当前单链表长度;第2⾏为n个空格间隔的整数,为该链表n个元素的数据域值。
第3⾏为1个正整数m,表⽰对该链表施加的操作数量;接下来m⾏,每⾏表⽰⼀个操作,为2个或3个整数,格式为0 k d或1 k。
0 k d表⽰在链表第k个结点后插⼊⼀个数据域值为d的结点,若k=0则表⽰表头插⼊。
1 k表⽰删除链表中第k个结点,此时k不能为0。
注:操作序列中若含有不合法的操作(如在长度为5的链表中删除第8个结点、删除第0个结点等),则忽略该操作。
n和m不超过100000。
输出格式:输出为⼀⾏整数,表⽰实施上述m个操作后的链表,每个整数后⼀个空格。
输⼊数据保证结果链表不空。
输⼊样例:51 2 3 4 550 2 80 9 60 0 71 01 6输出样例:7 1 2 8 3 5参照课本的实现#include<iostream>#include<iomanip>#include<stdlib.h>using namespace std;typedef int ElemType;typedef int Status;#define ERROR 0#define OK 1#define OVERFLOW 3typedef struct LNode{ElemType data;struct LNode *next;}LNode ,*LinkList;Status ListInsert(LinkList L,int i,ElemType e){int j=0;LinkList p=L,s;while(p&&j<i-1) // 寻找第i-1个结点{p=p->next;j++;}if(!p||j>i-1) // i⼩于1或者⼤于表长return ERROR;s=(LinkList)malloc(sizeof(LNode)); // ⽣成新结点s->data=e; // 插⼊L中s->next=p->next;p->next=s;return OK;}Status ListDelete(LinkList L,int i){int j=0;LinkList p=L,q;while(p->next&&j<i-1) // 寻找第i个结点,并令p指向其前趋{p=p->next;j++;}if(!p->next||j>i-1) // 删除位置不合理return ERROR;q=p->next; // 删除并释放结点p->next=q->next;free(q);return OK;}int main(){ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);LinkList L;L=(LinkList)malloc(sizeof(LNode)); // 产⽣头结点,并使L指向此头结点 if(!L) // 存储分配失败exit(OVERFLOW);L->next=NULL;int n=0,m=0;LinkList db=L,da;cin>>n;for(int i=0;i<n;i++){da=(LinkList)malloc(sizeof(LNode));cin>>da->data;da->next=NULL;db->next=da;db = da;}cin>>m;for(int i=0;i<m;i++){int o,x,y;cin>>o;if(o==0){cin>>x>>y;ListInsert(L,x+1,y);}else if(o==1){cin>>x;ListDelete(L,x);}else{exit(ERROR);}}LinkList p=L->next;while(p!=NULL){cout<<p->data<<" ";p = p->next;}return 0;}。
数据结构 单链表基本操作代码
数据结构单链表基本操作代码```一、单链表基本概念单链表是一种常见的线性存储结构,由一系列节点组成。
每个节点包括数据域和指针域,数据域存储具体的数据,指针域指向下一个节点。
二、单链表基本操作2.1 创建链表创建一个空链表,即没有任何节点。
可以选择初始化一个头节点,也可以直接初始化为空。
2.2 在链表头部插入节点在链表头部插入新节点。
将新节点的指针域指向原头节点,然后更新头节点指针,使其指向新节点。
2.3 在链表尾部插入节点在链表尾部插入新节点。
遍历链表找到尾节点,然后将尾节点的指针域指向新节点。
2.4 在指定位置插入节点在链表的指定位置插入新节点。
遍历链表找到指定位置的节点,然后将新节点的指针域指向下一个节点,再将指定位置的节点的指针域指向新节点。
2.5 删除链表头节点删除链表头节点,即将头节点的指针指向下一个节点,然后删除原头节点。
2.6 删除链表尾节点删除链表尾节点,即遍历链表找到尾节点的上一个节点,将其指针域置空,然后删除尾节点。
2.7 删除指定位置的节点删除链表的指定位置节点,即遍历链表找到指定位置节点的上一个节点,将其指针域指向下一个节点,然后删除指定位置节点。
2.8查找链表中是否存在某个元素遍历链表,逐个比较节点的数据域与目标元素,直到找到匹配或遍历到链表末尾。
2.9获取链表长度遍历链表,计数节点的个数,直到遍历到链表末尾。
三、附件暂无附件。
四、法律名词及注释本文档未涉及任何法律名词及其注释。
```。
单链表基本操作的实现
单链表基本操作的实现单链表是一种常见的数据结构,它由多个节点组合而成,每个节点包含一个数据元素和一个指向下一个节点的指针。
通过指针,我们可以方便地在单链表中进行插入、删除和遍历等操作。
以下是关于单链表基本操作的实现。
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. 单链表的删除单链表的删除可以分为在链表头部删除、在链表尾部删除和在链表中间删除三种情况。
单链表的基本操作
实验二:单链表的基本操作编写一个完整的程序,实现单链表的建立、插入、删除、输出等基本操作。
(1)建立一个带头结点的单链表。
(2)计算单链表的长度,然后输出单链表。
(3)查找值为x的直接前驱结点q。
(4)删除值为x的结点。
(5)把单向链表中元素逆置(不允许申请新的结点空间)。
(6)已知单链表中元素递增有序,请写出一个高效的算法,删除表中所有值大于mink且小于maxk的元素(若表中存在这样的元素),同时释放被删结点空间,并分析你的算法的时间复杂度(注意:mink和maxk是给定的两个参变量,他们的值可以和表中的元素相同,也可以不同)。
(7)同(6)的条件,试写一高效的算法,删除表中所有值相同的多余元素(使得操作后的线性表中所有元素的值均不相同),同时释放被删结点空间,并分析你的算法时间复杂度。
(8)利用(1)建立的链表,实现将其分解成两个链表,其中一个全部为奇数,另一个全部为偶数(尽量利用已知的存储空间)。
(9)在主函数中设计一个简单的菜单,分别测试上述算法。
# include <stdio.h># include <stdlib.h>typedef struct node{int data;struct node * next;}Lnode, * LinkList;int m=sizeof(Lnode);//建立新的链表void Bulid_List(LinkList root){int num;LinkList s,p;s=root->next;int n;printf("请输入新建链表的长度n数据:\n"); scanf("%d",&n);printf("请依次建立链表:");for(int i=0;i<n;i++){scanf("%d",&num);s->data=num;p=(LinkList)malloc(m);s->next=p;s=p;s->next=NULL;}printf("链表已建立!\n");}//对链表的输出,包括长度和元素void OutPut_list(LinkList root) {int len=0;LinkList s;s=root->next;if(s->next==NULL)printf("单链表无数据,请先新建单链表。
单链表的基本运算
建表结束*/ { c=getchar(); if(c!=’$’) { s=(Node*)malloc(sizeof(Node)); /*建立新结点 s*/ s->data=c; s->next=L->next; /*将 s 结点插入表头*/ L->next=s; } else flag=0;
3. 结果判断 如找到第 i 个结点,则返回结点 p;
如表查完未找到,则返回空。
【算法描述】
Node * Get (LinkList L, int i) / * 在带头结点的单链表 L 中查找第 i 个结点,若找到(1≤i≤n),则返回 该结点的存储位置; 否则返回 NULL * / { int j;
【算法描述】
int ListLength(LinkList L)
/*求带头结点的单链表 L 的长度*/
{ Node *p;
p=L->next;
j=0; /*用来存放单链表的长度*/
while(p!=NULL)
{
p=p->next;
j ++;
}
return j; /*j 为求得的单链表长度*/
} /* ListLength */
H
∧
s r
(a)初始化的空表
C1 ∧
(b)申请新结点并赋值
s 指向新申请的结点空间;
s->data:=C1
H
c1 ∧
r
(c)插入第一个结点
s
① r->next=s;
c1 H
实验二:单链表基本运算实现
{
int data; //存放表结点值
struct node *next; //存放表结点的直接后驱元素的地址
} ListNode,*LinkList;
//头插法创建初始链表
LinkList create_h(int size)
{
;//将工作指针p指向后一个结点
;//计数器累加
}
return i;
}
//打印链表中的现有元素
printList(LinkList head)
{
LinkList p;
;//将工作指针p指向第1个结点
{
p=(LinkList)malloc(sizeof(ListNode));//申请新结点的存储空间
scanf("%d",&p->data);//读入新结点的值到data域中
;//将新增结点插到头结点的后面
;//将新增结点插到头结点的后面
printf("————头插法建立链表(1)\n");
printf("————尾插法建立链表(2)\n");
printf("————按位查找元素(3)\n");
printf("————按值查找元素(4)\n");
printf("————插入元素(5)\n");
printf("————删除元素(6)\n");
printList(h);
break;
case 5:
printf("插入元素,请输入要插入元素的值:\n");
实验二 单链表基本操作
实验二单链表基本操作一实验目的1.学会定义单链表的结点类型,实现对单链表的一些基本操作和具体的函数定义,了解并掌握单链表的类定义以及成员函数的定义与调用。
2.掌握单链表基本操作及两个有序表归并、单链表逆置等操作的实现。
二实验要求1.预习C语言中结构体的定义与基本操作方法。
2.对单链表的每个基本操作用单独的函数实现。
3.编写完整程序完成下面的实验内容并上机运行。
4.整理并上交实验报告。
三实验内容1.编写程序完成单链表的下列基本操作:(1)初始化单链表La。
(2)在La中第i个元素之前插入一个新结点。
(3)删除La中的第i个元素结点。
(4)在La中查找某结点并返回其位置。
(5)打印输出La中的结点元素值。
2 .构造两个带有表头结点的有序单链表La、Lb,编写程序实现将La、Lb合并成一个有序单链表Lc。
合并思想是:程序需要3个指针:pa、pb、pc,其中pa,pb分别指向La表与Lb表中当前待比较插入的结点,pc 指向Lc表中当前最后一个结点。
依次扫描La和Lb中的元素,比较当前元素的值,将较小者链接到*pc 之后,如此重复直到La或Lb结束为止,再将另一个链表余下的内容链接到pc所指的结点之后。
3.构造一个单链表L,其头结点指针为head,编写程序实现将L逆置。
(即最后一个结点变成第一个结点,原来倒数第二个结点变成第二个结点,如此等等。
)四思考与提高1.如果上面实验内容2中合并的表内不允许有重复的数据该如何操作?2.如何将一个带头结点的单链表La分解成两个同样结构的单链表Lb,Lc,使得Lb中只含La表中奇数结点,Lc中含有La表的偶数结点?1.编写程序完成单链表的下列基本操作:(1)初始化单链表La。
(2)在La中第i个元素之前插入一个新结点。
(3)删除La中的第i个元素结点。
(4)在La中查找某结点并返回其位置。
(5)打印输出La中的结点元素值。
#include<stdio.h>#include<stdlib.h>#include <malloc.h>#define OK 1#define ERROR 0typedef int Status;typedef int ElemType;//定义存储结构typedef struct Lnode{int data; /*每个元素数据信息*/struct Lnode *next; /*存放后继元素的地址*/} LNode,*LinkList;int main(){void Create_L(LinkList &L,int n);void Print_L(LinkList L);Status ListInsert_L(LinkList &L,int i,ElemType e);Status ListDelete_L(LinkList &L,int i,ElemType &e);Status Find_L(LinkList L,int e);LinkList La;//创建单链表Laint n;printf("请输入链表La中的元素个数:\n");scanf("%d",&n);Create_L(La,n);//初始化单链表printf("现在La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("现在准备插入元素,请输入插入位置及所插入元素的值\n");int i,e;scanf("%d %d",&i,&e);ListInsert_L(La,i,e);printf("插入后La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("现在准备删除元素,请输入删除位置\n");scanf("%d",&i);ListDelete_L(La,i,e);printf("删除后La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("请输入所要查找元素的值:\n");scanf("%d",&e);Find_L(La,e);printf("所要查找元素的位置为:%d\n",Find_L(La,e)); }void Create_L(LinkList &L,int n){int j=1;L=(LinkList)malloc(sizeof(Lnode));L->next =NULL;//先建立一个带头结点的单链线性表L for(int i=n;i>0;--i){LinkList p=(LinkList)malloc(sizeof(Lnode));printf("请输入链表La中的第%d个元素:\n",j++);scanf("%d",&p->data);p->next=L->next;L->next =p;}//(逆序实现)/*LinkList q=L;for(int i=1;i<=n;i++){LinkList p=(LinkList)malloc (sizeof(Lnode));q->next=p;p->next=NULL;q=q->next ;printf("请输入链表La中的第%d个元素:\n",i);scanf("%d",&p->data);}//(正序实现)*/}//初始化单链表//输出单链表void Print_L(LinkList L){LinkList p;p=L->next;while(p){printf("%d ",p->data );p=p->next;}printf("\n");}//在单链表L的第i个位置前插入元素eStatus ListInsert_L(LinkList &L,int i,ElemType e) {LinkList p=L;int j=0;while(p&&j<i-1){p=p->next; ++j;}if(!p||j>i-1) return ERROR;LinkList s=(LinkList)malloc(sizeof(LNode));s->data=e; s->next=p->next;p->next=s;return OK;} //ListInsert_L//删除单链表L中第i个位置上的元素Status ListDelete_L(LinkList &L,int i,ElemType &e) {LinkList p=L;int j=0;while( p->next && j<i-1){p=p->next; ++j;}if(!p->next||j>i-1) return ERROR;LinkList q=p->next; p->next=q->next;e=q->data;free(q);return OK;}//LinkDelete_L/*查找元素并返回位置*/Status Find_L(LinkList L,int e){LinkList p=L->next;int j=1;while(p->data!=e&&p->next){p=p->next;j++;}if(p->data==e) return j;else{printf("无当前元素\n");return ERROR;}if(!p){printf("无当前元素\n");return ERROR;}}//定位2 .构造两个带有表头结点的有序单链表La、Lb,编写程序实现将La、Lb合并成一个有序单链表Lc。
c语言单链表程序代码
c语言单链表程序代码C语言单链表程序代码单链表是一种常见的数据结构,它由多个节点组成,每个节点包含一个数据域和一个指向下一个节点的指针。
以下是C语言实现单链表的程序代码:1. 定义节点结构体首先需要定义一个节点结构体,用来存储每个节点的数据和指针信息。
```typedef struct node {int data; // 数据域struct node *next; // 指向下一个节点的指针} Node;```2. 创建链表头节点创建一个头节点,它不存储任何数据,只是作为链表的起始点。
```Node *head = NULL;head = (Node*)malloc(sizeof(Node));head->next = NULL;```3. 插入新节点插入新节点时需要先创建一个新的节点,并将其插入到链表中合适的位置。
```Node *new_node = NULL;new_node = (Node*)malloc(sizeof(Node));new_node->data = new_data;// 找到插入位置Node *current = head;while (current->next != NULL && current->next->data < new_data) {current = current->next;}// 插入新节点new_node->next = current->next;current->next = new_node;```4. 删除指定数据的节点删除指定数据的节点时需要先找到该节点,并将其从链表中删除。
```// 找到要删除的节点Node *current = head;while (current->next != NULL && current->next->data != data) {current = current->next;}// 删除节点if (current->next != NULL) {Node *del_node = current->next;current->next = del_node->next;free(del_node);```5. 遍历链表遍历链表时需要从头节点开始,依次访问每个节点的数据。
用C#实现单链表(插入,在第i个前插,在第i个后插)
⽤C#实现单链表(插⼊,在第i个前插,在第i个后插)初学C#记录历程,记录⼼情。
在学习的过程中严重参考了前辈们在⽹上的分享,当然也不忘有⾃⼰的细微思想在⾥⾯,写在这⾥主要是对⾃⼰由不懂到能独⽴写下来的纪念。
如有冒犯,还请原谅。
在接⼝IList中增加:void Insert(T item, int i);//在i后插void InsertBefore(T item, int i);//在i前插节点类和链表类参考前篇。
在链表类LinkList⾥⾯直接增加⽅法。
在第i个数前⾯插⼊:View Code1///<summary>2///插⼊数据到链表(i前插)3///</summary>4///<param name="item">插⼊的结点的数据</param>5///<param name="i">在第i个位置前插⼊结点</param>67public void InsertBefore(T item, int i)//i前插8 {9 LinkNode<T> node = this.head;10 LinkNode<T> nodeTemp; //临时结点11 LinkNode<T> InsertNode = new LinkNode<T>(item, null); //创建⼀个要插⼊的结点12if (this.head == null && i == 1) //空链表时,插⼊13 {14this.head = InsertNode;15return;16 }17if (i < 1 || i > this.GetLength() || (this.head == null && i != 1)) //异常下的处理18 {19 Console.WriteLine("Error,the location you want to insert in is wrong");20return;21 }2223if(this.head!=null&&i==1) //在第⼀个结点前插⼊24 {2526this.head=InsertNode;27 InsertNode.Next =node;28return;29 }3031//下⾯代码才是主要的,在第i个位置前⾯插⼊32int j = 1;33while(node!=null&j<i-1) //寻找第i-1个结点. i>=234 {35 node = node.Next;36 j++;37 }38 nodeTemp = node.Next;39 node.Next = InsertNode;40 InsertNode.Next = nodeTemp;4142 }在第i个数后⾯插⼊:View Code1///<summary>2///插⼊数据到链表(i后插)3///</summary>4///<param name="item">要插⼊的元素</param>5///<param name="i">在第i个位置的后⾯插⼊新节点</param>6public void Insert(T item, int i)7 {8 LinkNode<T> node=this.head;9 LinkNode<T> nodeTemp; //临时结点10 LinkNode<T> insertNode=new LinkNode<T>(item,null); //创建⼀个要插⼊的结点1112if (this.head == null && i == 1) //空链表时,插⼊13 {14this.head = insertNode;15return;16 }1718if (i < 1 || i > this.GetLength()||(this.head==null&&i!=1)) //异常下的处理19 {20 Console.WriteLine("Error,the location you want to insert in is wrong"); 21return;22 }2324if (i == this.GetLength()) //如果是在末尾插⼊, i〉=125 {26while (node.Next != null)27 {28 node = node.Next;29 }30 node.Next = insertNode;31return;32 }3334//下⾯代码才是主要的,在第i个位置后插⼊35int j = 1;36while (node != null && j < i)//寻找第i个结点. i>=237 {38 node = node.Next;39 j++;40 }41 nodeTemp = node.Next;42 node.Next = insertNode;43 insertNode.Next = nodeTemp;4445 }验证插⼊是否正确:View Code1static void Main(string[] args)2 {3 LinkList<int> MyList = new LinkList<int>();4 LinkNode<int> node = new LinkNode<int>();5 LinkList<int>.AddPosition HeadInsert = LinkList<int>.AddPosition.Head;67//验证插⼊元素8 MyList.Add(6, HeadInsert);9 MyList.Add(7, HeadInsert);10 MyList.Add(8, HeadInsert);1112 MyList.Insert(99, 2);13 MyList.InsertBefore(999, 2);1415 node = MyList.Head;16 node = PrintData(node);1718 Console.ReadLine();19 }2021private static LinkNode<int> PrintData(LinkNode<int> node)22 {23while (node != null)24 {25 Console.WriteLine("The data of List are:{0}", node.Data);26 node = node.Next;27 }28return node;29 }。
数据结构 实验二:单链表的基本操作
数据结构实验二:单链表的基本操作数据结构实验二:单链表的基本操作实验二:单链表的基本操作一、【实验目的】1、理解和掌握单链表的类型定义方法和结点生成方法。
2、掌握建立单链表和显示单链表元素的算法。
3、掌握单链表的查找、插入和删除算法二、【实验内容】1、建立一个整形数的单链表,手动输入10个数,并从屏幕显示单链表元素列表。
2、从键盘输入一个数,查找在以上创建的单链表中是否存在该数;如果存在,显示它的位置;如果不存在,给出相应提示。
3、删除上述单链表中指定位置的元素。
以下就是程序部分代码,恳请调试并补足并使之恰当运转:1.linlist.htypedefstructnode{datatypedata;structnode*next;}slnode;voidlistinitiate(slnode**head)/*初始化*/{/*如果有内存空间,申请头结点空间并使头指针head指向头结点*/if((*head=(slnode*)malloc(sizeof(slnode)))==null)exit(1);(*head)->next=null;/*置链尾标记null*/}intlistlength(slnode*head){slnode*p=head;/*p指向首元结点*/intsize=0;/*size初始为0*/while(p->next!=null)/*循环计数*/{p=p->next;size++;}returnsize;}intlistinsert(slnode*head,inti,datatypex)/*在带头结点的单链表head的数据元素ai(0≤i≤size)结点前*//*填入一个存放数据元素x的结点*/{slnode*p,*q;intj;p=head;/*p指向首元结点*/j=-1;/*j起始为-1*/while(p->next!=null&&j<i-1)/*最终让指针p指向数据元素ai-1结点*/{p=p->next;j++;}if(j!=i-1){printf(\填入边线参数弄错!\return0;}/*生成新结点由指针q指示*/if((q=(slnode*)malloc(sizeof(slnode)))==null)exit(1);q->data=x;q->next=p->next;/*给指针q->next赋值*/p->next=q;/*给指针p->next重新赋值*/return1;}intlistdelete(slnode*head,inti,datatype*x)/*删除带头结点的单链表head的数据元素ai(0≤i≤size-1)结点*//*删除结点的数据元素域值由x带回。
单链表(头插法,尾插法创建,顺序输出链表,并返回链表长度)
单链表(头插法,尾插法创建,顺序输出链表,并返回链表长度)单链表(头插法,尾插法创建,顺序输出链表,并返回链表长度)代码如下:#include <stdio.h>#include <stdlib.h>#define LENG sizeof(struct node)//结点所占单元数struct node{ int data; struct node *next;};int main(){ struct node*create1();/*尾插法建⽴单链表*/ struct node*create2();//头插法建⽴单链表 int length(struct node*head);//返回单链表的长度,并输出各节点的值 struct node*head1,*head2; head1=create1(); head2=create2(); int leng1=length(head1); printf("\n"); printf("单链表1的长度为:%d",leng1); printf("\n"); int leng2=length(head2); printf("\n"); printf("单链表2的长度为:%d",leng2);return 0;}struct node *create1(){ struct node*head,*tail,*p; int e; head=(struct node *)malloc(LENG);//⽣成表头结点 tail=head; //尾指针只想表头 printf("please input a integer number:"); scanf("%d",&e); //输⼊第⼀个数 while(e!=0){ p=(struct node *)malloc(LENG);//⽣成新节点 p->data=e; tail->next=p; //新节点链接到表尾 tail=p; //尾指针指向新节点 printf("please input a integer number:"); scanf("%d",&e);}tail->next=NULL; //尾节点的next域置为空指针return head; //返回头指针}struct node *create2(){ struct node *head,*p; int e; head=(struct node*)malloc(LENG); head->next=NULL; printf("please input a integer number:"); scanf("%d",&e); while(e!=0){ p=(struct node *)malloc(LENG); p->data=e; p->next=head->next; head->next=p; printf("please input a integer number:"); scanf("%d",&e);}return head;};int length(struct node*head){int leng=0;struct node*p;p=head->next; //p指向⾸结点while(p!=NULL){printf("%d",p->data);printf(" ");leng++;p=p->next;}return leng;}运⾏结果:。
单链表的实现及其基本操作
单链表的实现及其基本操作结点的引⼊链表是⼀种链式存储结构,链式存储结构的特点是⽤⼀组任意的存储单元存储数据元素。
为了能正确表⽰数据元素之间的线性关系,需引⼊结点概念。
⼀个结点表⽰链表中的⼀个数据元素,节点中除了储存数据元素的信息,还必须存放指向下⼀个节点的的指针(单、双链表的最后⼀个节点除外,它们存储的是⼀个空指针NULL)结点的结构如下图所⽰:代码如下:1 typedef struct node{2int data;3struct node* pNext;4 }Node, *PNode;View Code注:这⾥假设结点中储存的是整型 (int) 的数据单链表由多个结点依次连接⽽成,我们不难想象出它结构:我们注意到:在第⼀个结点的前⾯多了⼀个头结点,这是为了处理空表的⽅便⽽引⼊的,它的指针指向链表的第⼀个结点,⽽它的data域不存放任何信息。
单链表的基本操作1.创建链表1 PNode createList()2 {3int len, value;45 PNode pHead = (PNode)(malloc(sizeof(Node)));6 PNode pTail = pHead;7 pTail->pNext = NULL;89 printf("请输⼊你要的节点个数:");10 scanf("%d", &len);11for(int i=1;i<=len;i++){12 printf("请输⼊第%d个节点的值:", i);13 scanf("%d", &value);1415 PNode pNew = (PNode)malloc(sizeof(Node));16 pNew->data = value;17 pTail->pNext = pNew;18 pTail = pNew;19 pTail->pNext = NULL;20 }2122return pHead;23 }View Code2.遍历链表void traverse(PNode pHead){printf("遍历结果为:\n");PNode pTra = pHead;while(pTra->pNext != NULL){printf("%d ", pTra->pNext->data);pTra = pTra->pNext;}printf("\n");}View Code3.判断链表是否为空1bool isEmpty(PNode pHead)2 {3if(pHead->pNext==NULL)4return true;5else6return false;7 }View Code4.链表长度1int length(PNode pHead)2 {3int len = 0;4while(pHead->pNext!=NULL){5 pHead = pHead->pNext;6 len++;7 }8return len;910 }View Code5.插⼊结点1bool insert(PNode pHead, int pos, int val)2 {3if(pos<1 || pos>length(pHead)){4return false;5 }else{6 PNode pInsert = pHead;7for(int i=1;i<pos;i++){8 pInsert = pInsert->pNext;9 }1011 PNode pNew = (PNode)malloc(sizeof(Node));12 pNew->data = val;13 pNew->pNext = pInsert->pNext;14 pInsert->pNext = pNew;1516return true;17 }1819 }View Code6.删除结点1bool del(PNode pHead, int pos)2 {3if(pos<1 || pos>length(pHead)){4return false;5 }else{6 PNode pDel = pHead;7for(int i=1;i<pos;i++){8 pDel = pDel->pNext;9 }1011if(pos==length(pHead)){12free(pDel->pNext);13 pDel->pNext = NULL;14 }else{15 PNode pNext = pDel->pNext->pNext;16free(pDel->pNext);17 pDel->pNext = pNext;18 }1920return true;2122 }232425 }View Code7.查找节点(1)按元素值查找1 PNode locate(PNode pHead, int value)2 {3 PNode p = pHead->pNext;4while(p&&p->data!=value){ //NULL 是 05 p = p->pNext;6 }7return p;8 }View Code(2)按序号查找1 PNode get(PNode pHead, int k)2 {3 PNode p = pHead;4for(int i=1;i<=k;i++){5 p = p->pNext;6 }7return p;89 }View Code完整代码1 #include<stdio.h>2 #include<stdlib.h>3 typedef struct node{4int data;5struct node* pNext;6 }Node, *PNode;78 PNode createList();9void traverse(PNode pHead);10bool isEmpty(PNode pHead);11int length(PNode pHead);12bool insert(PNode pHead, int pos, int val);13bool del(PNode pHead, int pos);14 PNode get(PNode pHead, int k); //按序号查找15 PNode locate(PNode pHead, int value);//按值查找 1617int main(void)18 {19//test2021return0;22 }2324 PNode createList()25 {26int len, value;2728 PNode pHead = (PNode)(malloc(sizeof(Node)));29 PNode pTail = pHead;30 pTail->pNext = NULL;3132 printf("请输⼊你要的节点个数:");33 scanf("%d", &len);34for(int i=1;i<=len;i++){35 printf("请输⼊第%d个节点的值:", i);36 scanf("%d", &value);3738 PNode pNew = (PNode)malloc(sizeof(Node));39 pNew->data = value;40 pTail->pNext = pNew;41 pTail = pNew;42 pTail->pNext = NULL;43 }4445return pHead;46 }474849void traverse(PNode pHead)50 {51 printf("遍历结果为:\n");52 PNode pTra = pHead;53while(pTra->pNext != NULL)54 {55 printf("%d ", pTra->pNext->data);56 pTra = pTra->pNext;57 }58 printf("\n");59 }6061bool isEmpty(PNode pHead)62 {63if(pHead->pNext==NULL)64return true;65else66return false;67 }6869int length(PNode pHead)70 {71int len = 0;72while(pHead->pNext!=NULL){73 pHead = pHead->pNext;74 len++;75 }76return len;7778 }7980bool insert(PNode pHead, int pos, int val)81 {82if(pos<1 || pos>length(pHead)){83return false;84 }else{85 PNode pInsert = pHead;86for(int i=1;i<pos;i++){87 pInsert = pInsert->pNext;88 }8990 PNode pNew = (PNode)malloc(sizeof(Node));91 pNew->data = val;92 pNew->pNext = pInsert->pNext;93 pInsert->pNext = pNew;9495return true;96 }9798 }99100bool del(PNode pHead, int pos)101 {102if(pos<1 || pos>length(pHead)){103return false;104 }else{105 PNode pDel = pHead;106for(int i=1;i<pos;i++){107 pDel = pDel->pNext;108 }109110if(pos==length(pHead)){111free(pDel->pNext);112 pDel->pNext = NULL;113 }else{114 PNode pNext = pDel->pNext->pNext;115free(pDel->pNext);116 pDel->pNext = pNext;117 }118119return true;120121 }122123124 }125126 PNode get(PNode pHead, int k)127 {128 PNode p = pHead;129for(int i=1;i<=k;i++){130 p = p->pNext;131 }132return p;133134 }135 PNode locate(PNode pHead, int value)136 {137 PNode p = pHead->pNext;138while(p&&p->data!=value){ //NULL 是 0 139 p = p->pNext;140 }141return p;142 }View Code。
单链表的 基本操作
单向链表单向链表的基本操作,创建一个由6个节点组成的单向链表,显示链表中每个节点的数据,并且做增加、删除、查找节点以及计算单链表的长度等处理。
➢需求分析:1.功能(1)用尾插法创建一带头结点的由6个节点组成的单向链表:从键盘读入一组整数,作为单链表中的元素,输入完第6个结点后结束;将创建好的单链表元素依次输出到屏幕上。
(2)显示链表中每个节点的数据(3)从键盘输入一个数,查找在以上创建的单链表中是否存在该数;如果存在,显示它的位置,即第几个元素;如果不存在,给出相应提示如“No found node!”。
(4)在上述的单链表中的指定位置插入指定数据,并输出单链表中所有数据.(5)删除上述单链表中指定位置的结点,并输出单链表中所有数据.(6)求单链表的长度并输出。
2.输入要求先输入单链表中结点个数n,再输入单链表中所有数据,在单链表中需查找的数据,需插入的数据元素的位置、值,要删除的数据元素的位置。
3。
测试数据单链表中所有数据:12,23,56,21,8,10在单链表中需查找的数据:56;24插入的数据元素的位置、值:1,28;7,28;0,28要删除的数据元素的位置:6➢概要设计:1.算法思想:由于在操作过程中要进行插入、删除等操作,为运算方便,选用带头结点的单链表作数据元素的存储结构。
对每个数据元素,由一个数据域和一个指针域组成,数据域放输入的数据值,指针域指向下一个结点。
2.数据结构:单链表结点类型:typedef struct Liistnode {int data;struct Listnode *next;} NODE;3.模块划分:a)用尾插法建立带头结点的单链表*CreateList函数;b)显示链表中每个结点的数据PrintList函数;c)从键盘输入一个数,查找单链表中是否存在该数FoundList函数;d)在单链表中指定位置插入指定数据并输出单链表中所有数据InsertList函数;e)删除单链表中指定位置的结点并输出单链表中所有数据DeleteList函数;f)计算单链表的长度并在屏幕上输出LengthList函数;g)主函数main(),功能是给出测试数据值,建立测试数据值的带头结点的单链表,调用PrintList函数、FoundList函数、InsertList函数、DeleteList函数、LengthList函数实现问题要求.四、实验要求1.用C完成算法设计和程序设计并上机调试通过。
单链表尾插法c语言
单链表尾插法c语言单链表是一种常见的数据结构,可用于实现各种算法和数据处理任务。
其中,尾插法是一种常用的单链表构建方法。
本文将介绍如何使用C语言实现单链表尾插法。
单链表尾插法的思路很简单,就是从链表头开始遍历链表,直到找到最后一个节点,然后将新节点插入到尾部。
具体实现步骤如下: 1. 定义一个Node结构体表示单链表的节点,包含两个成员变量:数据和指向下一个节点的指针。
typedef struct Node {int data;struct Node *next;} Node;2. 定义一个函数createNode用于创建单链表节点,并返回指向该节点的指针。
Node *createNode(int data) {Node *node = (Node*)malloc(sizeof(Node)); //动态分配节点空间node->data = data; //设置节点的数据node->next = NULL; //新节点的next指针为空return node; //返回指向新节点的指针}3. 定义一个函数listTailInsert用于实现单链表的尾插法。
该函数接收一个指向单链表头部的指针,以及一个要插入的数据。
函数会遍历链表,找到最后一个节点,然后将新节点插入到尾部。
void listTailInsert(Node *head, int data) {//创建新节点Node *newNode = createNode(data);//遍历链表,找到最后一个节点Node *p = head;while (p->next != NULL) {p = p->next;}//将新节点插入到尾部p->next = newNode;}4. 测试函数。
可以在主函数中新建一个单链表头节点,然后调用listTailInsert函数插入若干个节点,最后遍历输出整个链表。
int main() {//创建单链表头节点Node *head = createNode(-1);//插入节点listTailInsert(head, 1);listTailInsert(head, 2);listTailInsert(head, 3);//遍历输出链表Node *p = head->next;while (p != NULL) {printf('%d ', p->data);p = p->next;}return 0;}以上就是C语言实现单链表尾插法的完整代码。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
printf("请选择\n");
}
//(1)初始化建立一个空链表
LinkList * InitLinkList()
{
LinkList *A;
A=(LinkList *)malloc(sizeof(LinkList));
A->elem=-1;
printf("(5):单链表按值定位\n");
printf("(6):对单链表中任何相同的元素仅保留一个节点\n");
printf("(7):单链表在指定位置插入数据\n");
printf("(8):单链表指定位置删除元素\n");
printf("(9):求单链表的长度\n");
r->next=P;
r=P;
printf("请您输入要插入的元素\n");
scanf("%d",&elem);
}
if(elem==-1)
printf("你输入的元素 -1 不合法,现已推出添加节点\n");
return(Q);
}
//(4)单链表按号定位
header=A;
pre=Loc_Num(A,i-1);
if(pre!=NULL)
{
aim=pre->next;
pre->next=aim->next;
free(aim);
aim->next=NULL;
}
return(header);
}
//求单链表的长度
break;
case 2:L=LoadHeadLL();
break;
case 3:L=LoadTailLL();
break;
case 4:printf("您要定位第几个节点?\n");
scanf("%d",&i);
Loc=Loc_Num(L,i);
{
LinkList *pre,*newnode,*header;
header=A;
pre=Loc_Num(A,i-1);
if(pre!=NULL)
{
newnode=(LinkList *)malloc(sizeof(LinkList));
newnode->elem=value;
while(elem!=-1)
{
P=InitLinkList();
P->elem=elem;
P->next=Q->next;
Q->next=P;
printf("请您输入要插入的元素\n");
scanf("%d",&elem);
}
if(elem==-1)
LinkList *Cut(LinkList *A,int i);//(8)单链表指定位置删除元素
int Length(LinkList *A);//(9)求单链表的长度
void PrintLinkList(LinkList *A);//(10)单链表输出
void instruction();//菜单函数
int _tmain(int argc, _TCHAR* argv[])
{
LinkList *L,*Loc;
int i,j;
while(1)
{
instruction();
scanf("%d",&i);
switch(i)
{
case 1:L=InitLinkList();
return(P);
else
printf("未找到该元素\n");
return(0);
}
//(5)单链表按值定位
LinkList *Loc_Value(LinkList *A,int value)
{
LinkList *P;
P=A->next;
while(P!=NULL&&P->elem!=value)
T=P;//T的每个起点都是从P开始的
}
if(P==NULL)
printf("您的单链表为空链表,不存在重复节点\n");
return(header);
}
//(7)单链表在指定位置插入数据
LinkList *Insert(LinkList *A,int value,int i)
LinkList *Loc_Num(LinkList *A,int i)
{
int counter;
LinkList *P;
P=A->next;
for(counter=1;counter<i&&(P!=NULL);counter++)
{
P=P->next;
}
if(counter==i)
int Length(LinkList *A)
{
int counter;
LinkList *P;
P=A;
for(;P->next!=NULL;counter++)
{
P=P->next;
}//计数器在节点判断不为空后才可以自加1
return(counter);
}
r->elem=-1;
r->next=NULL;
Q=r;
printf("请您输入要插入的元素\n");
scanf("%d",&elem);
while(elem!=-1)
{
P=InitLinkList();
P->elem=elem;
P->next=NULL;
{
P->next;
}
return(P);//找不到就返回空指针
}
//(6)对单链表中任何相同的元素仅保留一个节点
LinkList *Delete(LinkList *A)
{
LinkList *P,*T,*pre,*header;//T用于探测新的节点用来与P比较
header=A;
}LinkList;
LinkList * InitLinkList();//(1)建立一个空链表
LinkList * LoadHeadLL();//(2)单链表头插入加载节点
LinkList * LoadTailLL();//(3)单链表尾部插入加载节点
LinkList *Loc_Num(LinkList *A,int i);//(4)单链表按号定位
scanf("%d",&i);
printf("您要插入的数据?\n");
scanf("%d",&j);
L=Insert(L,j,i);
break;
case 8:printf("您要选择几号?\n");
scanf("%d",&i);
L=Cut(L,i);
//单链表输出
void PrintLinkList(LinkList *A)
{
LinkList *Link;
int counter=0;
Link=A;
Link=Link->next;
while(Link!=NULL)
{
printf("%d ",Link->elem);
T=T->next;
}
if(T!=NULL)
{
pre->next=T->next;
free(T);
T=T->next;
}
}while(T!=NULL);//do while 语句当调价为真时继续执行循环
P=P->next;
++counter;
if(counter%5==0)
printf("\n");
Link=Link->next;
}
}
break;
case 5:printf("您要定位节点的值?\n");
scanf("%d",&i);
Loc=Loc_Num(L,i);
break;
case 6:L=Delete(L);
break;
case 7:printf("您要选择几号?\n");
return 0;
}
//菜单函数
void instruction()
{
printf("(1):建立一个空链表\n");
printf("(2):单链表头插入加载节点\n");
printf("(3):单链表尾部插入加载节点\n");
printf("(4):单链表按号定位\n");
break;
case 9:i=Length(L);
printf("单链表长度为: %d\n",i);