数据结构 单链表基本操作代码
单链表头插法代码
单链表头插法代码单链表是一种常见的数据结构，它由多个节点组成，每个节点包括两部分：一个数据存储区和一个指向下一个节点的指针。
插入操作是单链表的基本操作之一，在插入一个节点时，可以采用两种方法：头插法和尾插法。
在本篇文章中，我们将重点讲解单链表的头插法。
头插法是指在单链表的头节点之前插入一个新节点。
这种方法需要先创建一个新节点，并将其指针指向原头节点所指向的节点。
然后再将头节点的指针指向新节点。
相当于是在链表的头部插入新节点。
下面是头插法的代码实现：```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; } 运行及结果：
数据结构实验报告-实验一顺序表、单链表基本操作的实现
数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现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）掌握链表的概念，学会对链表进⾏操作。
c语言单链表程序代码
c语言单链表程序代码单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。
单链表的优点在于插入和删除操作的效率高，但是访问任意节点的效率较低。
下面是一个简单的单链表程序代码：```c#include <stdio.h>#include <stdlib.h>struct Node {int data;struct Node* next;};void insert(struct Node** head, int data) {struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));newNode->data = data;newNode->next = *head;*head = newNode;}void printList(struct Node* head) {while (head != NULL) {printf("%d ", head->data);head = head->next;}printf("\n");}int main() {struct Node* head = NULL;insert(&head, 1);insert(&head, 2);insert(&head, 3);printList(head);return 0;}```这个程序定义了一个结构体`Node`，包含一个整型数据`data`和一个指向下一个节点的指针`next`。
`insert`函数用于在链表头部插入一个新节点，`printList`函数用于打印整个链表。
在`main`函数中，我们创建了一个空链表`head`，然后插入了三个节点，最后打印整个链表。
这个程序虽然简单，但是涉及到了单链表的基本操作。
数据结构链表简单程序代码
display(L);
printf("\n");
insert(&L,2,6);//在第2个位置插入元素6
printf("在第2个位置插入6后的链表为:");//显示插入元素后的链表
display(L);
printf("\n");
q->next=L->next;// 在表头节点
L->next=q; // 后插入节点，且每次插入的都是后移后的节点
}
}
//链表长度函数
int length(Lnode L)
{
return L.len;
}
//插入元素函数
void insert(Lnode *L,int i,elemtype x)
}
creatlist(&L);//创建空链表
for(i=0;i<n;i++)//把元素放入链表
{
putlist(&L,a[i]);
}
printf("数入链表为:");//显示输入的链表
display(L);
printf("\n");
converse(&L);//逆置链表
{
j++;
if(j==i+1)break;//因为有头结点，所以是i+1
p=p->next;
}
return p->data;//返回第i个元素的值
}
//删除元素函数
数据结构课程设计-职工信息管理系统-单链表实现程序源代码
printf（”请你输入要查找的工号："）；
scanf（”％s"，findmess);
p=Locate(l,findmess,”num”）；
if(p）
｛
printf（”\t\t\t\t查找结果\n”)；
printstart（）; //打印横线
printc（)； //打印各学科标题
printe(p）； //打印p结点各个数据成员的值
printf（”\t＊ [7] 排序 [8］ 保存职工信息 ＊\n");
printf（”\t＊ ［9] 显示数据 ［0] 退出系统 ＊\n”）；
printf(”\t＊ ＊\n”);
printf（"\t**＊**＊*＊＊＊*＊＊＊＊＊*＊*＊＊＊＊*＊＊＊*＊**＊＊＊*＊*＊*＊＊*＊＊*＊*＊*＊＊＊＊＊＊*＊*＊＊＊***＊\n”）;
｝
void Wrong（）
｛
printf("\n=====>提示：输入错误！\n"）；
｝
void Nofind(）
｛
printf（"\n=====〉提示：没有找到该职工！\n”)；
｝
void printc（) /＊ 本函数用于输出中文 ＊/
{
printf（" 工号\t 姓名 性别 部门 职称 工资 总工资 平均工资\n");
Node ＊p，＊r; /*实现删除操作的临时的结构体指针变量＊/
char findmess[20］；
if(！l—〉next) //当list无后继结点时,提示和结束返回del（）
｛
printf（"\n=====>提示：没有记录可以删除！\n"）;
单链表的基本操作代码
单链表的基本操作代码单链表是一种常用的数据结构，它具有优秀的插入和删除性能，在数据存储和处理方面具有广泛的应用。
单链表的基本操作包含创建链表、插入节点、删除节点、查找节点等，下面是单链表的基本操作代码：1. 定义单链表结构体：typedef struct ListNode {int val;struct ListNode *next;} ListNode;2. 创建单链表：ListNode *createList(int arr[], int n) {ListNode *head = NULL, *tail = NULL, *p = NULL;for(int i = 0; i < n; i++) {p = (ListNode *)malloc(sizeof(ListNode));p->val = arr[i];p->next = NULL;if(head == NULL) {head = tail = p;} else {tail->next = p;tail = p;}}return head;}3. 插入节点：void insertNode(ListNode **head, int val, int pos) {ListNode *p = (ListNode *)malloc(sizeof(ListNode)); p->val = val;p->next = NULL;if(*head == NULL) {if(pos != 0) {printf("Invalid position\n");return;} else {*head = p;return;}}if(pos == 0) {p->next = *head;*head = p;} else {int i = 0;ListNode *q = *head;while(q != NULL && i < pos - 1) {q = q->next;i++;}if(q == NULL || i != pos - 1) {printf("Invalid position\n");return;}p->next = q->next;q->next = p;}}4. 删除节点：void deleteNode(ListNode **head, int pos) {if(*head == NULL) {printf("List is empty\n");return;}if(pos == 0) {ListNode *p = *head;*head = (*head)->next;free(p);} else {int i = 0;ListNode *p = *head, *q = NULL; while(p != NULL && i < pos) { q = p;p = p->next;i++;}if(p == NULL || i != pos) {printf("Invalid position\n");return;}q->next = p->next;free(p);}}5. 查找节点：ListNode *findNode(ListNode *head, int val) {ListNode *p = head;while(p != NULL) {if(p->val == val) {return p;}p = p->next;}return NULL;}单链表的基本操作是数据结构中最基础的部分，掌握好这些代码对于往后的学习和应用都会有很大的帮助。
数据结构 实验二：单链表的基本操作
数据结构实验二：单链表的基本操作数据结构实验二：单链表的基本操作实验二：单链表的基本操作一、【实验目的】1、理解和掌握单链表的类型定义方法和结点生成方法。
2、掌握建立单链表和显示单链表元素的算法。
3、掌握单链表的查找、插入和删除算法二、【实验内容】1、建立一个整形数的单链表，手动输入10个数，并从屏幕显示单链表元素列表。
2、从键盘输入一个数，查找在以上创建的单链表中是否存在该数;如果存在，显示它的位置;如果不存在，给出相应提示。
3、删除上述单链表中指定位置的元素。
以下就是程序部分代码，恳请调试并补足并使之恰当运转：１．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带回。
数据结构代码汇总
数据结构代码汇总数据结构代码汇总一、线性结构1.数组（Array）：●定义和初始化数组●插入、删除元素●查找元素●数组的遍历●数组排序算法（如冒泡排序、快速排序）2.链表（Linked List）：●单链表的定义和初始化●插入、删除节点●链表的遍历●双向链表的定义和初始化●插入、删除节点●双向链表的遍历●栈的定义和初始化●入栈、出栈操作●获取栈顶元素、判断栈是否为空●栈的应用（如括号匹配、逆波兰表达式求值）4.队列（Queue）：●队列的定义和初始化●入队、出队操作●获取队头元素、判断队列是否为空●队列的应用（如循环队列、优先级队列）二、非线性结构1.树（Tree）：●二叉树的定义和初始化●二叉树的遍历（前序、中序、后序）●二叉搜索树的实现和应用●平衡二叉树（AVL树）的实现和应用●哈夫曼树的实现和应用●图的存储结构（邻接矩阵、邻接表）●深度优先搜索（DFS）●广度优先搜索（BFS）●最小树算法（如Prim算法、Kruskal算法）●最短路径算法（如Dijkstra算法、Floyd算法）附件：本文档中所涉及的代码示例可以在附件中找到，包括各种数据结构的实现和相关算法。
法律名词及注释：1.数组：计算机科学中的一种数据结构，用于存储一系列相同类型的元素。
2.链表：一种动态数据结构，由一系列节点组成，每个节点包含一个数据元素和指向下一个节点的指针。
3.栈：一种特殊的线性数据结构，遵循先进后出（Last In First Out，LIFO）的原则。
4.队列：一种特殊的线性数据结构，遵循先进先出（First In First Out，FIFO）的原则。
5.二叉树：一种特殊的树形结构，每个节点最多有两个子节点。
6.图：由节点（顶点）和连接节点的边构成的数据结构，用于描述事物之间的关系。
数据结构实验报告 单链表基本操作
printf("查找不到该元素！\n");
printf("---------------------------------------------\n"); return 0; } 二： 1. 编写头文件及各个函数。这里函数有 CreateList_L() 创建函数，MergeList_L() 是排序函 2. 数。MergeList_L 函数不改变存储，只改变指针。PrintList_L() 用来打印结果。 写主函数。在主函数里输入元素个数，调用函数创建链表输入各个元素值。在调用函数
五、实验结果与讨论
一：
二：
-5-
六、总结
在查找元素的函数中如果按照下面的写法则会产生如下的结果：
于是必须改成 while(p&&(p->data!=e))
-6-
原因：先判断 p 是因为如果先判断 p->data 有可能此时 p 已指向空，p->data 没有值
七、思考与提高
1．如果上面实验内容 2 中合并的表内不允许有重复的数据该如何操作？ 2．如何将一个带头结点的单链表 La 分解成两个同样结构的单链表 Lb，Lc， 使得 Lb 中只含 La 表中奇数结点，Lc 中含有 La 表的偶数结点？
-3-
排序，改变指针。输出。 3. 完整代码如下： #include<stdio.h> #include<stdlib.h> #define TRUE 1 #define FALSE 0 #define ERROR 0 #define OK 1 typedef int Status; typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *next; }LNode,*Linklist; Status CreateList_L(Linklist &L,int n) { Linklist p,q; int i=0; L=(Linklist)malloc(sizeof(LNode)); L->next=NULL; p=L; printf("请输入%d 个元素：\n",n); for(i=0;i<n;i++) { q=(Linklist)malloc(sizeof(LNode)); scanf("%d",&q->data); q->next=p->next; } return OK; } void MergeList_L(Linklist &La, Linklist &Lb, Linklist &Lc) { Linklist pa, pb, pc; pa = La->next; pb = Lb->next; while (pa && pb) { if(pa->data <= pb->data) { pc->next = pa; else { pc->next = pb; Lc = pc = La; p->next=q; p=q;
单链表的实现及其基本操作
单链表的实现及其基本操作结点的引⼊链表是⼀种链式存储结构，链式存储结构的特点是⽤⼀组任意的存储单元存储数据元素。
为了能正确表⽰数据元素之间的线性关系，需引⼊结点概念。
⼀个结点表⽰链表中的⼀个数据元素，节点中除了储存数据元素的信息，还必须存放指向下⼀个节点的的指针（单、双链表的最后⼀个节点除外，它们存储的是⼀个空指针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、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 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);
}。