您的位置：360文档中心› 3单链表的基本操作实现(菜单的建立)

3单链表的基本操作实现(菜单的建立)

合集下载

单链表的基本操作

单链表的基本操作

10）调用头插法的函数，分别输入10,20，分别回车：
11）调用尾插法的函数，分别输入30,40
12）查找单链表的第四个元素：
13）主函数中传入参数，删除单链表的第一个结点：
14）主函数传入参数，删除第0个未位置的元素，程序报错：
15）最后，输出单链表中的元素：
return 0;
}
6）编译，连接，运行源代码：
7）输入8，回车，并输入8个数，用空格分隔开，根据输出信息，可以看出，链表已经拆分为两个
五、实验总结
1.单链表采用的是数据+指针的表示形式，指针域总是指向下一个结
点（结构体）的地址，因此，在内存中的地址空间可以是不连续的，操作比顺序存储更加的方便
2.单链表使用时，需要用malloc函数申请地址空间，最后，删除元
素时，使用free函数释放空间。

数据结构-单链表基本操作实现（含全部代码）

数据结构-单链表基本操作实现（含全部代码）

数据结构-单链表基本操作实现（含全部代码）今天是单链表的实现，主要实现函数如下：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. 数据结构的基本概念。

- 数据、数据元素、数据项。

- 数据结构的定义（逻辑结构、存储结构、数据的运算）- 数据结构的三要素之间的关系。

2. 算法的基本概念。

- 算法的定义、特性（有穷性、确定性、可行性、输入、输出）- 算法的评价指标（时间复杂度、空间复杂度的计算方法）二、线性表。

1. 线性表的定义和基本操作。

- 线性表的逻辑结构特点（线性关系）- 线性表的基本操作（如初始化、插入、删除、查找等操作的定义）2. 顺序存储结构。

- 顺序表的定义（用数组实现线性表）- 顺序表的基本操作实现（插入、删除操作的时间复杂度分析）- 顺序表的优缺点。

3. 链式存储结构。

- 单链表的定义（结点结构，头指针、头结点的概念）- 单链表的基本操作实现（建立单链表、插入、删除、查找等操作的代码实现及时间复杂度分析）- 循环链表（与单链表的区别，操作特点）- 双向链表（结点结构，基本操作的实现及特点）三、栈和队列。

1. 栈。

- 栈的定义（后进先出的线性表）- 栈的基本操作（入栈、出栈、取栈顶元素等操作的定义）- 顺序栈的实现（存储结构，基本操作的代码实现）- 链栈的实现（与单链表的联系，基本操作的实现）- 栈的应用（表达式求值、函数调用栈等）2. 队列。

- 队列的定义（先进先出的线性表）- 队列的基本操作（入队、出队、取队头元素等操作的定义）- 顺序队列（存在的问题，如假溢出）- 循环队列的实现（存储结构，基本操作的代码实现，队空和队满的判断条件）- 链队列的实现（结点结构，基本操作的实现）- 队列的应用（如操作系统中的进程调度等）四、串。

1. 串的定义和基本操作。

- 串的概念（字符序列）- 串的基本操作（如连接、求子串、比较等操作的定义）2. 串的存储结构。

- 顺序存储结构（定长顺序存储和堆分配存储）- 链式存储结构（块链存储结构）3. 串的模式匹配算法。

- 简单的模式匹配算法（Brute - Force算法）的实现及时间复杂度分析。

算法与数据结构实验报告

算法与数据结构实验报告

2015-2016学年第二学期《算法与数据结构》课程实验报告专业软件工程学生姓名成晓伟班级软件141学号1410075094实验学时16实验教师徐秀芳信息工程学院实验一单链表的基本操作一、实验目的1.熟悉C语言上机环境，进一步掌握C语言的基本结构及特点。

2.掌握线性表的各种物理存储表示和C语言实现。

3.掌握单链表的各种主要操作的C语言实现。

4.通过实验理解线性表中的单链表存储表示与实现。

二、主要仪器及耗材普通计算机三、实验内容与要求1、用C语言编写一个单链表基本操作测试程序。

（1）初始化单链表（2）创建单链表（3）求单链表长度（4）输出单链表中每一个结点元素（5）指定位置插入某个元素（6）查找第i个结点元素的值（7）查找值为e 的结点，并返回该结点指针（8）删除第i个结点（9）销毁单链表2、实验要求（1）程序中用户可以选择上述基本操作。

程序启动后，在屏幕上可以菜单形式显示不同功能，当按下不同数字后完成指定的功能，按其他键，则显示错误后重新选择。

（2）要求用线性表的顺序存储结构，带头结点的单链表存储结构分别实现。

（3）主函数实现对基本操作功能的调用。

3、主要代码（1）初始化单链表LinkList *InitList(){ //创建一个空链表,初始化线性表LinkList *L;L=(LinkList *)malloc(sizeof(LinkList));L->next=NULL;return L;}（2）创建单链表//头插法void CreateListF(LinkList *L){LinkList *s;int i=1,a=0;while(1){printf("输入第%d个元素(0表示终止)",i++);scanf("%d",&a);if(a==0)break;s=(LinkList *)malloc(sizeof(LinkList));s->data=a;s->next=L->next;L->next=s;}}（3）求链表长度int ListLength(LinkList *L){ //求链表长度int n=0;LinkList *p=L;while(p->next!=NULL){p=p->next;n++;}return(n);}（4）在指定位置插入元素int InsertList(LinkList *L,int i,ElemType e){LinkList *p=L,*s;int j=0;while(p!=NULL&&j<i-1){p=p->next;j++;} //找出要插入的位置的前一个位置if(p==NULL){return 0;}else{s=(LinkList *)malloc(sizeof(LinkList));s->data=e;s->next=p->next;p->next=s;return 1;}}（5）输出链表void DispList(LinkList *L){ //输出链表LinkList *p=L->next;while(p!=NULL){printf("%d",p->data);p=p->next;}printf("\n");}（6）查找链表中指定元素int GetElem(LinkList *L,int i){ //查找链表中指定元素LinkList *p=L;int j=0;while(j<i&&p!=NULL){j++;p=p->next;}if(p==NULL){return 0;}else{return p->data;}}（7）查找值是e的结点并返回该指针LinkList *LocateElem(LinkList *L,ElemType e){ //查找值是e的结点并返回该指针int i=1;LinkList *p=L;while(p!=NULL)if(p->data==e) return p;}if(p==NULL){return NULL;}}（8）删除元素int ListDelete(LinkList *L,int i,ElemType *e){ //删除元素LinkList *p=L,*q;int j=0;while(p!=NULL&&j<i-1){p=p->next;j++;} //找到要删除元素地址的前一个地址if(p==NULL){ return 0;} //不能删除else{q=p->next;*e=q->data;p->next=q->next;free(q); //删除成功return 1;}}（9）销毁链表void DestroyList(LinkList *L){//销毁链表LinkList *pre=L,*p=L->next;while(p!=NULL){free(pre);pre=p;p=pre->next;}free(pre);}main函数：int main(){LinkList *L;ElemType e;int i;L=InitList();CreateListF(L);DispList(L);printf("输入要查找的元素位置:\n");scanf("%d",&i);e=GetElem(L,i);printf("%d\n",e);printf("单链表长度为:%d\n",ListLength(L));printf("输入要删除元素的位置:");scanf("%d",&i);if (i>ListLength(L)){printf("超出范围重新输入");scanf("%d",&i);}if(ListDelete(L,i,&e)==0){printf("未找到元素\n");}else DispList(L);printf("输入插入元素的位置和值:");scanf("%d%d",&i,&e);InsertList(L,i,e);DispList(L);return 0;}4、测试数据及测试结果输入：23 56 12 28 45输出：四、注意事项1、存储结构定义和基本操作尽可能用头文件实现。

单链表基本操作的实现

单链表基本操作的实现

单链表基本操作的实现单链表是一种常见的数据结构，它由多个节点组合而成，每个节点包含一个数据元素和一个指向下一个节点的指针。

通过指针，我们可以方便地在单链表中进行插入、删除和遍历等操作。

以下是关于单链表基本操作的实现。

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. 单链表的删除单链表的删除可以分为在链表头部删除、在链表尾部删除和在链表中间删除三种情况。

JAVA数据结构——单链表的操作

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. 编写一个程序，实现一个冒泡排序算法。

2. 实现一个选择排序算法。

3. 实现一个插入排序算法。

4. 编写一个函数，计算一个整数数组中的最大值和最小值。

5. 编写一个函数，实现二分查找算法。

6. 编写一个函数，实现快速排序算法。

7. 编写一个函数，判断一个整数是否为素数。

8. 编写一个函数，实现反转一个整数数组。

9. 编写一个函数，计算两个整数数组的交集。

10. 编写一个函数，判断一个字符串是否为回文。

二、数据结构11. 实现一个单链表的基本操作，包括插入、删除、查找。

12. 实现一个双向链表的基本操作，包括插入、删除、查找。

13. 实现一个栈的基本操作，包括压栈、出栈、查看栈顶元素。

14. 实现一个队列的基本操作，包括入队、出队、查看队首元素。

15. 实现一个二叉树的基本操作，包括插入、删除、查找。

16. 实现一个二叉搜索树的基本操作，包括插入、删除、查找。

17. 实现一个哈希表的基本操作，包括插入、删除、查找。

三、搜索与图论18. 编写一个程序，实现深度优先搜索（DFS）算法。

19. 编写一个程序，实现广度优先搜索（BFS）算法。

20. 编写一个程序，求解迷宫问题。

21. 编写一个程序，计算一个有向图的拓扑排序。

22. 编写一个程序，计算一个无向图的欧拉回路。

23. 编写一个程序，计算一个加权无向图的最小树（Prim算法）。

24. 编写一个程序，计算一个加权有向图的最短路径（Dijkstra算法）。

25. 编写一个程序，计算一个加权有向图的所有顶点对的最短路径（Floyd算法）。

四、动态规划26. 编写一个程序，实现背包问题。

27. 编写一个程序，计算最长公共子序列（LCS）。

28. 编写一个程序，计算最长递增子序列（LIS）。

29. 编写一个程序，实现编辑距离（Levenshtein距离）。

30. 编写一个程序，实现硬币找零问题。

31. 编写一个程序，实现矩阵链乘问题。

算法开发实训报告

算法开发实训报告

一、实训背景随着计算机科学和信息技术的发展，算法作为计算机程序的核心，其重要性日益凸显。

为了提高学生的算法设计、实现和分析能力，我们开展了算法开发实训课程。

本次实训旨在让学生通过实际项目开发，深入了解算法原理，提高算法应用能力。

二、实训目标1. 熟悉常用算法的基本原理和实现方法；2. 能够根据实际问题选择合适的算法；3. 掌握算法分析、调试和优化方法；4. 培养团队协作和沟通能力。

三、实训内容1. 实训项目：基于单链表的排序算法实现项目描述：设计一个单链表，并实现插入排序、归并排序和快速排序三种排序算法，对链表中的元素进行排序。

2. 实训步骤（1）设计单链表节点结构体，包含数据域和指针域；（2）实现单链表的创建、插入、删除和遍历等基本操作；（3）实现插入排序、归并排序和快速排序三种排序算法；（4）测试排序算法的性能，对比分析不同排序算法的优缺点；（5）编写测试用例，验证排序算法的正确性。

四、实训过程1. 单链表节点结构体设计```ctypedef struct Node {int data;struct Node next;} Node;```2. 单链表基本操作实现```c// 创建单链表Node createList() {Node head = (Node)malloc(sizeof(Node));if (head == NULL) {return NULL;}head->next = NULL;return head;}// 插入节点void insertNode(Node head, int data) {Node newNode = (Node)malloc(sizeof(Node)); if (newNode == NULL) {return;}newNode->data = data;newNode->next = head->next;head->next = newNode;// 删除节点void deleteNode(Node head, int data) {Node temp = head;Node prev = NULL;while (temp != NULL && temp->data != data) { prev = temp;temp = temp->next;}if (temp == NULL) {return;}prev->next = temp->next;free(temp);}// 遍历链表void traverseList(Node head) {Node temp = head->next;while (temp != NULL) {printf("%d ", temp->data);temp = temp->next;}printf("\n");```3. 排序算法实现（1）插入排序```cvoid insertionSort(Node head) {Node sorted = NULL;Node current = head->next;Node prev = NULL;Node temp = NULL;while (current != NULL) {temp = current->next;current->next = NULL;if (sorted == NULL || sorted->data >= current->data) {current->next = sorted;sorted = current;} else {prev = sorted;while (prev->next != NULL && prev->next->data < current->data) {prev = prev->next;}current->next = prev->next;prev->next = current;}current = temp;}head->next = sorted;}```（2）归并排序```cNode merge(Node left, Node right) {Node result = NULL;if (left == NULL)return right;else if (right == NULL)return left;if (left->data <= right->data) {result = left;result->next = merge(left->next, right); } else {result = right;result->next = merge(left, right->next); }return result;}void mergeSort(Node head) {if (head == NULL || head->next == NULL)return;Node slow = head;Node fast = head;Node temp = NULL;while (fast != NULL && fast->next != NULL) { temp = slow;slow = slow->next;fast = fast->next->next;}temp->next = NULL;Node left = mergeSort(head);Node right = mergeSort(slow);head = merge(left, right);}```（3）快速排序```cint partition(Node head, int low, int high) {int pivot = head->next->data;Node i = head;Node j = head->next->next;while (j != NULL) {if (j->data < pivot) {i = i->next;int t = i->data;i->data = j->data;j->data = t;}j = j->next;}int t = i->data;i->data = head->next->data;head->next->data = t;return i->data;}void quickSort(Node head, int low, int high) { if (low < high) {int pi = partition(head, low, high); quickSort(head, low, pi - 1);quickSort(head, pi + 1, high);}}```4. 测试与优化通过编写测试用例，验证排序算法的正确性。

数据结构课件单链表

数据结构课件单链表
删除节点
删除链表中的节点需要遍历至指定位置，时间复杂度为 O(n)。
查找节点
在链表中查找一个节点需要遍历整个链表，时间复杂度为 O(n)。
空间复杂度
空间占用
单链表的空间占用主要取决于链表中的 节点数，因此空间复杂度为O(n)。
VS
内存分配
每个节点需要分配内存空间存储数据和指 针，因此内存分配的空间复杂度也为O(n) 。
需要根据数据元素顺 序进行遍历的场景， 如排序算法等。
需要频繁插入、删除 操作的场景，如动态 规划、图算法等。
02
单链表的实现
创建单链表
定义节点结构体
首先需要定义一个节点结构体，包含 数据域和指针域两个部分，数据域用 于存储数据，指针域用于指向下一个 节点。
初始化头节点
创建一个头节点，并将其指针域指向 NULL，表示单链表的起始位置。
05
单链表常见问题与解决方 案
循环链表
总结词
循环链表是一种特殊类型的单链表，其中尾节点的指针指向头节点，形成一个闭环。
详细描述
在循环链表中，由于尾节点的指针指向头节点，因此遍历链表时需要特别注意，以避免无限循环。常见的解决方 法是在遍历时记录已经访问过的节点，避免重复访问。
链表中的重复元素
总结词
链表中可能存在重复元素的问题，这会影响数据处理的正确性。
详细描述
为了解决这个问题，可以在插入节点时检查新元素是否已存在于链表中。如果存在，则不进行插入操 作。另外，也可以使用哈希表等数据结构来快速查找重复元素。
链表的排序
总结词
对链表进行排序是常见的需求，但链表的排 序算法通常比数组的排序算法复杂。
合并单链表
总结词
将两个已排序的单链表合并为一个新的已排序的单链表。

单链表的操作实现实验报告

单链表的操作实现实验报告
实验内容：单链表的实现
题目来源：□√教材页题□√教师补充□自选题目
主要功能描述：链表的初始化、链表的创建（头部插入法、尾部插入法）、求表长、查找（按值查找、按序号查找）、插入、删除、输出、两个有序单链表的合并等。
设计分析：
初始化：为单链表申请头结点空间，将单链表设置为空；创建：（1）头部插入法：（a）初始化空表；（b）申请新结点并赋值；（c）插入新结点；（d）插入第i个元素。
break;
case'1':
puts("\n");
puts("*********************************************************");
puts("* 0---般创建1---头部插入法2---尾部插入法*");
puts("*********************************************************");
r->next=p;
r=p;
}
r->next=NULL;
return h;
}
/*头部插入*/
int CreatfromH(LinkList head)
{
LinkList p;
ElemType x;
puts("输入数据，输入-1000结束输入!");
while(1)
{
scanf("%d",&x);
if(x!=-1000)
while(p!=NULL)
{
printf("\n%d",p->data);
p=p->next;

单链表基本操作的实现

单链表基本操作的实现

单链表基本操作的实现
单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。

单链表的基本操作包括创建、插入、删除、查找和遍历等。

1. 创建单链表
创建单链表需要先定义一个节点结构体，包含数据元素和指向下一个节点的指针。

然后通过循环输入数据元素，创建节点并将它们连接起来，最后返回链表的头节点。

2. 插入节点
插入节点可以在链表的任意位置进行，需要先找到插入位置的前一个节点，然后创建新节点并将它的指针指向后面的节点，再将前一个节点的指针指向新节点即可。

3. 删除节点
删除节点也可以在链表的任意位置进行，需要先找到要删除的节点和它的前一个节点，然后将前一个节点的指针指向后面的节点，再释放要删除的节点的内存空间即可。

4. 查找节点
查找节点可以根据节点的数据元素进行，需要从链表的头节点开始
遍历，逐个比较节点的数据元素，直到找到目标节点或者遍历到链表的末尾。

5. 遍历链表
遍历链表可以按顺序输出链表中的所有节点的数据元素，需要从链表的头节点开始遍历，逐个输出节点的数据元素，直到遍历到链表的末尾。

以上就是单链表的基本操作，它们是实现其他高级数据结构和算法的基础。

在实际应用中，我们可以根据具体需求对单链表进行扩展和优化，例如添加头节点、尾节点、双向链表等，以满足不同的需求。

实验二：单链表基本运算实现

实验二：单链表基本运算实现
typedef struct node
{
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) 给定的数据元素存放在⼀维数组中，分别完成头插法和尾插法建⽴单链表3) 将数据元素从键盘依次输⼊，分别完成头插法和尾插法建⽴单链表4) 输出单链表的长度5) 实现按位查找和按值查找6) 实现插⼊和删除操作7) 实现遍历单链表操作#include <cstdio>#include <cstring>#include <cstdlib>//查找1.内容2.序号//插⼊//删除typedef struct student{int num;char name[10];}STU;typedef struct Node{STU data;struct Node * next;}Node;void denglu(Node *L);//登录函数void chazhao(Node *L);//查找函数void Printf(Node *L);//输出函数void CreateFromHead(Node *L);//头插法void CreateFormTail(Node *L);//尾插法void panduan(Node *L);//判断头插还是尾插void Get(Node *L);//按序号结点查找void Locate(Node *L);//按内容查找（值）void Inslist(Node *L);//插⼊void Dellist(Node *L);//删除void Dellist(Node *L)//删除{system("CLS");int n;printf("请输⼊要删除的结点\n");scanf("%d",&n);if(n<=0){printf("输⼊的数据不合法,请重新输⼊\n");Dellist(L);}Node *pre,*r;int k=0;pre=L;while(pre->next !=NULL&&k<n-1){pre=pre->next;k=k+1;}if(pre->next==NULL){printf("没有找到该结点,请重新输⼊\n");Dellist(L);}r=pre->next;pre->next=r->next;free(r);printf("删除成功!\n");denglu(L);}void Inslist(Node *L)//插⼊{system("CLS");int n;printf("请输⼊在第⼏个位置插⼊数据\n");scanf("%d",&n);printf("请输⼊插⼊的学号,姓名\n");int num1;char name1[10];scanf("%d %s",&num1,name1);Node *pre,*s;int k=0;if(n<=0){printf("输⼊的数据不合法,请重新输⼊\n");Inslist(L);}pre=L;while(pre!=NULL&&k<n-1){pre=pre->next;k=k+1;}if(pre==NULL){printf("⽆法找到该节点,请重新输⼊\n");Inslist(L);}s=(Node*)malloc(sizeof(Node));strcpy(s->data .name ,name1);s->data.num=num1;s->next =pre->next ;pre->next =s;printf("插⼊成功!\n");denglu(L);}void Locate(Node *L)//按内容查找（值）{system("CLS");int n;printf("请输⼊要查找的学号\n");scanf("%d",&n);Node *p;p=L->next;while(p!=NULL){if(p->data.num!=n){p=p->next;}elsebreak;}printf("你要查找的学号所对应的信息为%d %s\n",p->data.num,p->);denglu(L);}void Get(Node *L)//按序号结点查找{system("CLS");int n;printf("请输⼊你要查找的结点\n");scanf("%d",&n);if(n<=0){printf("输⼊的数据不合法,请重新输⼊\n");Get(L);}Node *p;p=L;int j=0;while((p->next!=NULL)&&(j<n)){p=p->next;j++;}if(n==j){printf("你要查找的结点的储存位置的数据为%d %s\n",p->data.num,p->); }denglu(L);}void Printf(Node *L){int q=0;Node *p=L->next;while(p!=NULL){q++;printf("%d %s\n",p->data.num,p->); p=p->next;}printf("单链表长度为%d\n",q);denglu(L);}void chazhao(Node *L){printf("1.按序号查找\n");printf("2.按内容查找\n");printf("3.返回主界⾯\n");int aa;scanf("%d",&aa);switch(aa){case 1:Get(L);case 2:Locate(L);case 3:denglu(L);break;default:printf("输⼊错误请重新输⼊\n");chazhao(L);}}void denglu(Node *L){int a;printf("请选择你要做什么\n");printf("1.查找\n");printf("2.插⼊\n");printf("3.删除\n");printf("4.打印现有的学⽣信息及单链表长度\n"); printf("5.退出\n");scanf("%d",&a);switch(a){case 1:chazhao(L);case 2:Inslist(L);case 3:Dellist(L);case 4:Printf(L);case 5:printf("谢谢使⽤\n");exit(0);default:printf("输⼊错误请重新输⼊\n");denglu(L);}}void CreateFromHead(Node *L)//头插法{Node *s;int n;//n为元素个数printf("请输⼊元素个数\n");scanf("%d",&n);printf("请输⼊学号姓名\n");for(int i=1;i<=n;i++){s=(Node *)malloc(sizeof(Node));scanf("%d %s",&s->data.num,s->); s->next=L->next;L->next=s;}}void CreateFormTail(Node *L)//尾插法{Node *s,*r;r=L;int n;//n为元素个数printf("请输⼊元素个数\n");scanf("%d",&n);printf("请输⼊学号姓名\n");for(int i=1;i<=n;i++){s=(Node *)malloc(sizeof(Node));scanf("%d %s",&s->data.num,s->);r->next=s;r=s;if(i==n){r->next=NULL;}}}Node *InitList(Node *L)//初始化单链表{L=(Node *)malloc(sizeof(Node));L->next=NULL;return L;}void panduan(Node *L){int q;printf("请选择⽤哪种⽅式建⽴链表\n");printf("1.头插法\n");printf("2.尾插法\n");scanf("%d",&q);switch(q){case (1):CreateFromHead(L);printf("输⼊成功！\n");break;case (2):CreateFormTail(L);printf("输⼊成功！\n");break;default:printf("输⼊错误请重新输⼊\n");panduan(L);}}int main(){Node *L=NULL;L=InitList(L);panduan(L);denglu(L);return 0;}ps.贴上来的代码空格有点⼩奇怪啊。

链表的常见操作

链表的常见操作

链表的常见操作
链表是一种常见的数据结构，其存储元素的个数是不受限定的，当要添加更多元素时，存储的个数会随之增加。

链表的操作包括但不限于以下几种：
1. 创建：链表的创建包括初始化链表、分配内存空间等操作。

2. 插入：在链表的指定位置插入一个元素。

3. 删除：删除链表中的指定元素或删除链表的指定位置的元素。

4. 查找：查找链表中是否存在指定的元素，并返回该元素的位置或指针。

5. 修改：修改链表中指定位置的元素的值。

6. 遍历：按照某种顺序遍历链表，并对每个元素进行操作。

7. 排序：按照某种规则对链表中的元素进行排序。

8. 合并：将两个已排序的链表合并成一个新的已排序链表。

9. 反转：将链表中的元素顺序反转。

10. 判断：判断链表是否为空、是否为循环链表等。

以上是链表的一些常见操作，具体实现方式会因编程语言和具体需求而有所不同。

数据结构c语言版上机报告单链表

数据结构c语言版上机报告单链表

数据结构C语言版上机报告：单链表序在数据结构课程中，单链表是一个重要的概念，也是C语言中常用的数据结构之一。

本次报告将深入探讨单链表的基本概念、操作方法以及应用场景，帮助读者更深入地理解和掌握这一数据结构。

一、概述1.1 单链表的定义单链表是一种线性表，它由一系列节点组成，每个节点包含两部分：数据域和指针域。

数据域用于存储数据元素，指针域用于指向下一个节点，通过指针将这些节点串联在一起，形成一个链表结构。

1.2 单链表的特点单链表具有以下特点：（1）动态性：单链表的长度可以动态地增加或减少，不需要预先分配固定大小的空间。

（2）插入和删除操作高效：在单链表中进行插入和删除操作时，只需要修改指针的指向，时间复杂度为O(1)。

（3）随机访问效率低：由于单链表采用链式存储结构，无法通过下标直接访问元素，需要从头节点开始依次遍历，时间复杂度为O(n)。

1.3 单链表的基本操作单链表的基本操作包括：创建、插入、删除、查找等。

这些操作是使用单链表时常常会涉及到的，下面将逐一介绍这些操作的具体实现方法和应用场景。

二、创建2.1 头插法和尾插法在C语言中，可以通过头插法和尾插法来创建单链表。

头插法是将新节点插入到链表的头部，尾插法是将新节点插入到链表的尾部，这两种方法各有优缺点，可以根据具体应用场景来选择。

2.2 应用场景头插法适合于链表的逆序建立，尾插法适合于链表的顺序建立。

三、插入3.1 在指定位置插入节点在单链表中，插入节点需要考虑两种情况：在链表头部插入和在链表中间插入。

通过对指针的操作，可以实现在指定位置插入节点的功能。

3.2 应用场景在实际应用中，经常会有需要在指定位置插入节点的情况，比如排序操作、合并两个有序链表等。

四、删除4.1 删除指定节点在单链表中，删除节点同样需要考虑两种情况：删除头节点和删除中间节点。

通过对指针的操作，可以实现删除指定节点的功能。

4.2 应用场景在实际应用中，经常会有需要删除指定节点的情况，比如删除链表中特定数值的节点等。

数据结构实验报告-实验一顺序表、单链表基本操作的实现

数据结构实验报告-实验一顺序表、单链表基本操作的实现

数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表（1）掌握线性表的基本运算。

（2）掌握顺序存储的概念，学会对顺序存储数据结构进⾏操作。

（3）加深对顺序存储数据结构的理解，逐步培养解决实际问题的编程能⼒。

l 实验内容1、顺序表1、编写线性表基本操作函数：（1）InitList(LIST *L,int ms)初始化线性表；（2）InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素；（3）DeleteList1(LIST *L,int item)删除指定元素值的线性表记录；（4）DeleteList2(LIST *L,int rc)删除指定位置的线性表记录；（5）FindList(LIST *L,int item)查找线性表的元素；（6）OutputList(LIST *L)输出线性表元素；2、调⽤上述函数实现下列操作：（1）初始化线性表；（2）调⽤插⼊函数建⽴⼀个线性表；（3）在线性表中寻找指定的元素；（4）在线性表中删除指定值的元素；（5）在线性表中删除指定位置的元素；（6）遍历并输出线性表；l 实验结果1、顺序表（1）流程图（2）程序运⾏主要结果截图（3）程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值；rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素，返回值>=0为元素的位置，返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录，返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值，输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置：");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为：");OutputList(&LL);}while(1){printf("请输⼊查找元素值，输⼊0结束查找操作：");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素，位置为：%d\n",r+1);}while(1){printf("请输⼊删除元素值，输⼊0结束查找操作：");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素，位置为：%d\n线性表为：",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置，输⼊0结束查找操作：");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为：");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表（1）掌握链表的概念，学会对链表进⾏操作。

单链表操作实验报告

单链表操作实验报告

线性表一、实验目的1. 了解线性表的逻辑结构特征，以及这种特性在计算机内的两种存储结构。

2. 掌握线性表的顺序存储结构的定义及其C语言实现。

3. 掌握线性表的链式村粗结构——单链表的定义及其C语言实现。

4. 掌握线性表在顺序存储结构即顺序表中的各种基本操作。

5. 掌握线性表在链式存储结构——单链表中的各种基本操作。

二、实验要求1. 认真阅读和掌握本实验的程序。

2. 上机运行本程序。

)3. 保存和打印出程序的运行结果，并结合程序进行分析。

4. 按照对顺序表和单链表的操作需要，重新改写主程序并运行，打印出文件清单和运行结果三、实验内容请编写C程序，利用链式存储方式来实现线性表的创建、插入、删除和查找等操作。

具体地说，就是要根据键盘输入的数据建立一个单链表，并输出该单链表；然后根据屏幕菜单的选择，可以进行数据的插入或删除，并在插入或删除数据后，再输出单链表；然后在屏幕菜单中选择0，即可结束程序的运行。

四、解题思路本实验要求分别写出在带头结点的单链表中第i（从1开始计数）个位置之后插入元素、创建带头结点的单链表中删除第i个位置的元素、顺序输出单链表的内容等的算法。

五、程序清单#include<>#include<>#include<>typedef int ElemType;~typedef struct LNode{ ElemType data;struct LNode *next;}LNode;LNode *L;LNode *creat_L();void out_L(LNode *L);void insert_L(LNode *L,int i,ElemType e);ElemType delete_L(LNode *L,int i);int locat_L(LNode *L,ElemType e);$void main(){ int i,k,loc;ElemType e,x;char ch;do{ printf("\n");printf("\n 1.建立单链表");printf("\n 2.插入元素");printf("\n 3.删除元素");printf("\n 4.查找元素");printf("\n 0.结束程序运行");.printf("\n======================================");printf("\n 请输入您的选择（1，2，3，4，0）");scanf("%d",&k);switch(k){ case 1:{ L=creat_L();out_L(L);}break;case 2:{ printf("\n请输入插入位置：");scanf("%d",&i);printf("\n请输入要插入元素的值：");scanf("%d",&e);&insert_L(L,i,e);out_L(L);}break;case 3:{ printf("\n请输入要删除元素的位置：");scanf("%d",&i);x=delete_L(L,i);out_L(L);if(x!=-1){printf("\n删除的元素为：%d\n",x);printf("删除%d后的单链表为：\n",x);out_L(L);|}else printf("\n要删除的元素不存在！");}break;case 4:{ printf("\n请输入要查找的元素值：");scanf("%d",&e);loc=locat_L(L,e);if(loc==-1) printf("\n为找到指定元素！"); else printf("\n已找到，元素位置是%d",loc);}break;}printf("\n----------------");)}while(k>=1&&k<5);printf("\n 按回车键，返回...\n");ch=getchar();}LNode *creat_L(){ LNode *h,*p,*s; ElemType x;h=(LNode *)malloc(sizeof(LNode));h->next=NULL;p=h;printf("\n请输入第一个数据元素：");,scanf("%d",&x);while(x!=-999){ s=(LNode *)malloc (sizeof(LNode));s->data=x; s->next=NULL;p->next=s; p=s;printf("请输入下一个数据：（输入-999表示结束。

单链表操作实验报告

单链表操作实验报告

单链表基本操作报告姓名：张航学号：201100814205辅导老师：高艳霞实验日期：2012.09.27实现单链表的各种基本运算一、实验目的1、帮助读者复习C++语言程序设计中的知识。

2、熟悉线性表的逻辑结构。

3、熟悉线性表的基本运算在两种存储结构上的实现，其中以熟悉链表的操作为侧重点。

二、实验内容单链表的基本操作实现带头结点的单链表的建立、求长度，取元素、修改元素、插入、删除等单链表的基本操作。

三、实验步骤1.程序源码#include<stdio.h>#include<stdlib.h>#define LEN sizeof(linklist)#define NULL 0typedef struct nodeint data; /*结点的数据域*/struct node *next; /*结点的指针域*/}linklist;linklist *Linkcreat() /*建立单链表函数*/{int x;linklist *head,*p,*rear;printf("\t你选择的是尾插法建立链表功能：\n");head=(struct node*)malloc(LEN);head->data=-999; /* rear=head; / printf("\t请输入一组正整数以0结束输入：\n\t");scanf("%d",&x);while(x!=0){p=(struct node*)malloc(LEN); /*生成一个新结点*/p->data=x;rear->next=p; /*新结点插入到表尾*rear之后*/rear=p;scanf("%d",&x);}rear->next=NULL;printf("\t建立链表成功！\n");return(head);}void Linksearch(linklist *head) /*查找单链表结点函数*/ {int x;int i=0;linklist *p;printf("\t你选择的是查找功能：\n");printf("\t请输入要查找节点的值：");scanf("%d",&x);p=head;while((p->next!=NULL)&&(p->data!=x)){p=p->next;i++;}if(p->data==x){printf("\t查找成功！\n");printf("\t输出查找的数据所在位置为:%d\n",i);}else printf("\t查找结点不存在！\n");}linklist *Linkinsert(linklist *head) /*单链表结点插入函数*/ {int x,i,j=1;linklist *s,*q;printf("\t你选择的是尾插法插入功能：\n");printf("\t请输入要插入的位置：");scanf("%d",&i);printf("\t请输入要插入的数据：");scanf("%d",&x);s=(struct node*)malloc(LEN); /*建立插入数据的结点*/s->data=x;for(q=head;(q!=NULL)&&(j<=i-1);j++)q=q->next; /*指针后移指向下一个结点*/ if(q!=NULL){printf("\t插入成功！\n");s->next=q->next;q->next=s;}else printf("\t插入失败！\n");return(head);}linklist *Linkdelete(linklist *head) /*删除单链表结点函数*/ {linklist *p,*q;int i,j=1;printf("\t输入要删除的位置："); /*输入删除的位置*/scanf("%d",&i);p=head;while((p->next!=NULL)&&(j<i){p=p->next;j++;}if(p->next!=NULL) /*若该结点存在删除该结点*/ {q=p->next;printf("\t删除成功！\n");printf("\t删除的数据为：");printf("%d\n",q->data); /*输出删除结点数据*/p->next=q->next;free(q); /*释放删除结点空间q*/ }else printf("\t删除失败！");return(head);}void Linkprint(linklist *head) /*输出单链表函数*/{linklist *p;p=head;if(p==NULL)printf("\t输出失败！\n");printf("\t输出链表为：");while(p->next!=NULL){p=p->next;printf("%3d",p->data);}printf("\n");}int Select() /*菜单显示函数*/ {int k;printf(" -------------------------------\n");printf("\t1.建立单链表\n");printf("\t2.查找单链表\n");printf("\t3.插入结点\n");printf("\t4.删除结点\n");printf("\t5.输出单链表\n");printf("\t6.退出\n");do{printf("\t请输入选择的功能：");scanf("%d",&k); /*输入选择的功能*/ printf(" -------------------------------\n");}while((k<1)||(k>6));return(k);}void main() /*主函数*/{int n;linklist *head;while(1){n=Select(); /*输入选择功能*/switch(n){case 1:head=Linkcreat();Linkprint(head);break; /*建立单链表函数*/case 2:Linksearch(head);break; /*建立单链表函数*/case 3:head=Linkinsert(head);Linkprint(head);break; /*单链表结点插入函数*/ case 4:head=Linkdelete(head);Linkprint(head);break; /*删除单链表结点函数*/ case 5:Linkprint(head);break; /*输出单链表函数*/case 6:exit(0);}}2.运行程序}四、实验总结（结果分析和体会）通过本次实验我对链表有了更深的了解，对链表的插删操作、遍历、查找等基本上掌握了。

数据结构单链表实验报告

数据结构单链表实验报告

数据结构单链表实验报告实验目的：本实验的目的是通过实现单链表数据结构，加深对数据结构的理解，并掌握单链表的基本操作和算法。

实验内容：1、单链表的定义单链表由若干个节点组成，每个节点包含数据域和指针域，数据域存储具体数据，指针域指向下一个节点。

单链表的头指针指向链表的第一个节点。

2、单链表的基本操作2.1 初始化链表初始化链表时，将头指针置空，表示链表为空。

2.2 插入节点插入节点可以分为头插法和尾插法。

- 头插法：将新节点插入链表头部，新节点的指针域指向原头节点，头指针指向新节点。

- 尾插法：将新节点插入链表尾部，新节点的指针域置空，原尾节点的指针域指向新节点。

2.3 删除节点删除节点可以分为按位置删除和按值删除两种方式。

- 按位置删除：给定要删除节点的位置，修改前一节点的指针域即可。

- 按值删除：给定要删除节点的值，遍历链表找到对应节点，修改前一节点的指针域即可。

2.4 遍历链表遍历链表即按顺序访问链表的每个节点，并输出节点的数据。

2.5 查找节点查找节点可以分为按位置查找和按值查找两种方式。

- 按位置查找：给定节点的位置，通过遍历链表找到对应节点。

- 按值查找：给定节点的值，通过遍历链表找到第一个匹配的节点。

实验步骤：1、根据实验目的，定义单链表的结构体和基本操作函数。

2、实现初始化链表的函数，将头指针置空。

3、实现头插法或尾插法插入节点的函数。

4、实现按位置删除节点的函数。

5、实现按值删除节点的函数。

6、实现遍历链表的函数，输出节点的数据。

7、实现按位置查找节点的函数。

8、实现按值查找节点的函数。

9、设计实验样例，测试单链表的各种操作。

实验结果与分析：通过测试实验样例，我们可以验证单链表的各种操作是否正确。

如果出现异常情况，可通过调试找出问题所在，并进行修改。

单链表的操作时间复杂度与操作的位置有关，对于查找操作，时间复杂度为O(n)；对于插入和删除操作，时间复杂度也为O(n)。

附件：1、单链表的定义和基本操作的源代码文件。

单链表的实现及其基本操作

单链表的实现及其基本操作

单链表的实现及其基本操作结点的引⼊链表是⼀种链式存储结构，链式存储结构的特点是⽤⼀组任意的存储单元存储数据元素。

为了能正确表⽰数据元素之间的线性关系，需引⼊结点概念。

⼀个结点表⽰链表中的⼀个数据元素，节点中除了储存数据元素的信息，还必须存放指向下⼀个节点的的指针（单、双链表的最后⼀个节点除外，它们存储的是⼀个空指针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。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
L->next=NULL;
}
void CreateList(LinkList &L)
{
int n;
cout<<"请输入结点的个数：";
cin>>n;
for(int i=1;i<=n;i++)
{
LinkList P;
P=new LNode;
cin>>P->data;
P->next=L->next;
L->next=P;
{
cout<<"\n\t\t1:单链表建立(头插法)\n";
cout<<"\n\t\t2:单链表建立(尾插法)\n";
cout<<"\n\t\t3:单链表输出\n";
cout<<"\n\t\t4:单链表查找(按结点找)\n";
cout<<"\n\t\t5:单链表查找(按元素找)\n";
cout<<"\n\t\t6:单链表插入\n";
S->next=P->next;
P->next=S;
}
}
void DeleteList(LinkList &L,int i)
{
LinkList P,q;
P=getelem(L,i-1);
if(P->next!=NULL)
{
q=P->next;
P->next=q->next;
delete(q);
}
}
void main()
cout<<"\n\t\t7:单链表删除\n";
cout<<"\n\t\t0:退出程序";
LinkList L;
InitList(L);
cout<<"\n\t\t请选择功能:\n";
int flag=1;
while(flag)
{
int choice;
cin>>choice;
switch(choice)
while(P&&P->data!=e)
P=P->next;
return P;
}
void InsertList(LinkList L,int i,elemtype x)
{
LinkList P;
P=getelem(L,i);
if(P!=NULL)
{
LinkList S;
S=new LNode;
S->data=x;
#include <iostream.h>
typedef int elemtype;
typedef struct node
{
elemtype data;
struct node *next;
}LNode,*LinkList;
void InitList(LinkList &L)
{
L=new LNode;
{
LinkList P=L->next;
int j=1;
while(P&&j<i)
{
P=P->next;
j++;
eturn NULL;
}
LinkList Locateelem(LinkList L,elemtype e)
{
LinkList P=L->next;
cout<<"\n找到第"<<i<<"个结点元素为:"<<P->data;
else
cout<<"\n没有找到该结点";
break;
case 5:
cout<<"\n请输入查找的元素：";
elemtype e;
cin>>e;
P=Locateelem(L,e);
if(P)
cout<<"\n元素"<<e<<"所在结点地址为："<<P;
r->next=NULL;
}
void OutList(LinkList L)
{
LinkList P;
cout<<"\n输出单链表为：";
P=L->next;
while(P!=NULL)
{
cout<<P->data<<'\t';
P=P->next;
}
}
LinkList getelem(LinkList L,int i)
else
cout<<"\n没有找到该元素";
break;
case 6:
cout<<"\n请输入插入的位置和元素：";
elemtype x;
cin>>i>>x;
InsertList(L,i,x);
break;
case 7:
cout<<"\n请输入删除的位置：";
cin>>i;
DeleteList(L,i);
}
}
void CreateList_H(LinkList &L)
{
int n;
cout<<"请输入结点的个数：";
cin>>n;
LinkList r=L;
for(int i=1;i<=n;i++)
{
LinkList P;
P=new LNode;
cin>>P->data;
r->next=P;
r=P;
}
{
case 1:
CreateList(L);
break;
case 2:
CreateList_H(L);
break;
case 3:
OutList(L);
break;
case 4:
cout<<"\n请输入查找的结点：";
int i;
LinkList P;
cin>>i;
P=getelem(L,i);
if(P)
break;
case 0:flag=0;
}
}
}
相关文档
最新文档