头插法建立单链表 - 360文档中心

头插法和尾插法建立单链表

#include "stdio.h"#include "stdlib.h"typedef struct List{int data;struct List *next; //指针域}List;void HeadCreatList (List *L) //头插法建立链表{List *s;L->next=NULL;for (int i=0;i<10;i++){s=(struct List*)malloc(sizeof(struct List));s->data=i;s->next=L->next; //将L指向的地址赋值给S;L->next=s;}}void TailCreatList(List *L) //尾插法建立链表{List *s,*r;r=L;for (int i=0;i<10;i++){s=(struct List*)malloc(sizeof(struct List));s->data=i;r->next=s;r=s;}r->next=NULL;}void DisPlay(List *L){List *p=L->next;while(p!=NULL){printf ("%d ",p->data);p=p->next;}printf("\n");}int main (){List *L1,*L2;L1=(struct List*)malloc(sizeof(struct List));L2=(struct List*)malloc(sizeof(struct List)); HeadCreatList(L1);DisPlay(L1);TailCreatList(L2);DisPlay(L2);}//头插法创建链表#include <stdio.h>#include <stdlib.h>struct node{int data;struct node * next;};//建立只含头结点的空链表struct node * create_list(){struct node * head = NULL;head = (struct node *)malloc(sizeof(struct node));if (NULL == head){printf("memory out of use/n");return NULL;}head->next = NULL;head->data = 0;return head;}//头插法建立链表int insert_form_head(struct node * head, int num){struct node * head_t = head->next;struct node * new_node = NULL;new_node = (struct node *)malloc(sizeof(struct node));if (NULL == new_node){printf("memory out of use/n");return -1;}//将新结点插入到链表的最后new_node->data = num;new_node->next = head_t;head->next = new_node;return 0;}//打印链表int show_list(struct node * head){struct node * temp;temp = head->next;while(temp){printf("%d/n",temp->data);temp = temp->next;}return 0;}// 按值删除结点，头结点不被删除int delete_node(struct node *head, int data){//head_t 保存要删除结点的上一个结点struct node * head_t = head;struct node * temp = NULL;if (head == NULL){printf("delete node from empty list!/n");return -1;}//查找删除的结点的前一个结点//如果此处查找的是删除的结点，则需要另加一个指针保存删除结点的前一个指针while(NULL != head_t->next){if (data == head_t->next->data)break;head_t = head_t->next;}//如果要删除的结点不存在，直接返回if (NULL==head_t->next){printf("node not found/n");return -1;}//删除操作temp = head_t->next;head_t->next = head_t->next->next;free(temp);return 0;}void main(int argc, char* argv[]){struct node * head;head = create_list();if (NULL == head)printf("create_list error/n");insert_form_head(head,123);insert_form_head(head,456);show_list(head);printf("delete once!/n");delete_node(head,123);show_list(head);printf("delete second!/n");delete_node(head,456);show_list(head);delete_node(head,0);show_list(head);}/*//尾插法创建链表#include<stdio.h>#include<stdlib.h>struct Node{int data;struct Node * next;};//建立只含头结点的空链表struct Node * create_list(){struct Node * head = NULL;head = (struct Node *)malloc(sizeof(struct Node));if (NULL == head){printf("memory out of use/n");return NULL;}head->next = NULL;head->data = 0;return head;//尾插法建立链表int insert_form_tail(struct Node * head, int num){struct Node * temp = head;struct Node * new_node = NULL;new_node = (struct Node *)malloc(sizeof(struct Node));if (NULL == new_node){printf("memory out of use/n");return -1;}//寻找尾结点while (temp->next != NULL){temp = temp->next;}//将新结点插入到链表的最后new_node->data = num;new_node->next = NULL;temp->next = new_node;return 0;}//打印链表int show_list(struct Node * head){struct Node * temp;temp = head->next;while(temp){printf("%d/n",temp->data);temp = temp->next;}return 0;}void main(int argc, char* argv[]){struct Node * head;head = create_list();if (NULL == head)printf("create_list error/n");insert_form_tail(head,123);insert_form_tail(head,456);show_list(head);*/。

描述单链表的创建过程

描述单链表的创建过程
单链表是一种常用的线性数据结构，它由一系列节点组成，每个节点包含数据元素和一个指向下一个节点的指针。

创建单链表的过程可以分为以下几个步骤：
定义节点结构：首先，需要定义节点的结构。

每个节点通常包含数据元素和一个指向下一个节点的指针。

在许多编程语言中，可以使用结构体或类来定义节点。

例如，在C++中，可以定义一个结构体来表示节点：
cpp
struct Node {
int data; // 数据元素
Node* next; // 指向下一个节点的指针
};
创建第一个节点：创建一个头节点，它是单链表的第一个节点。

头节点通常用于存储指向第一个节点的指针，以及执行一些额外的操作，如插入和删除。

头节点可以静态创建或动态创建。

插入节点：在单链表中插入新的节点涉及到在链表中找到正确的位置并将新节点添加到该位置。

有两种常见的插入方法：在头部插入和在尾部插入。

在头部插入时，新节点成为链表的第一个节点；在尾部插入时，新节点成为链表的最后一个节点。

删除节点：从单链表中删除节点需要找到要删除的节点，并将其从链表中移除。

这通常涉及到更新被删除节点的上一个节点的指针，使其指向被删除节点的下一个节点。

c语言单链表头插法实现链表逆置

c语言单链表头插法实现链表逆置链表是一种常用的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。

在C语言中，我们可以使用单链表来实现各种操作，如插入、删除和查找等。

本文将介绍如何使用头插法实现链表的逆置。

首先，我们需要定义一个链表节点的结构体，包含数据和指向下一个节点的指针。

代码如下：```ctypedef struct Node {int data;struct Node* next;} Node;```接下来，我们需要实现链表的创建和逆置函数。

首先，创建一个空链表，并将头节点指针指向NULL。

代码如下：```cNode* createList() {Node* head = NULL;return head;}```然后，我们可以实现链表的插入函数，使用头插法将新节点插入到链表的头部。

代码如下：```cNode* insertNode(Node* head, int data) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = data;newNode->next = head;head = newNode;return head;}```接下来，我们可以实现链表的逆置函数，通过遍历链表，将每个节点插入到头部，从而实现链表的逆置。

代码如下：```cNode* reverseList(Node* head) {Node* newHead = NULL;Node* temp = NULL;while (head != NULL) {temp = head->next;head->next = newHead;newHead = head;head = temp;}return newHead;}```最后，我们可以编写主函数，测试链表的逆置功能。

代码如下：```cint main() {Node* head = createList();head = insertNode(head, 1);head = insertNode(head, 2);head = insertNode(head, 3);head = insertNode(head, 4);head = insertNode(head, 5);printf("原链表：");Node* temp = head;while (temp != NULL) {printf("%d ", temp->data);temp = temp->next;}printf("\n");head = reverseList(head);printf("逆置后的链表：");temp = head;while (temp != NULL) {printf("%d ", temp->data);temp = temp->next;}printf("\n");return 0;}```运行以上代码，输出结果如下：```原链表：5 4 3 2 1逆置后的链表：1 2 3 4 5```通过以上代码，我们成功地使用C语言的单链表头插法实现了链表的逆置。

《数据结构》-头插法建立单链表

LinkList head;
ListNode *s;
head=NULL;
printf("请输入链表各结点的数据(字符型):\n");
while((ch=getchar())!='\n')
{
s=(ListNode *)malloc(sizeof(ListNode ));
if(s==NULL)
{
printf("申请存储空间失败!");return head;
2020
数据结构
Data structure
头插法建立单链表
讲授：XXX
0.5 头插法建立单链表
要假三设求、线：性链表表中的结插点入的数据类型是字符型，逐个输入这些字符，并以换行符‘\n’作为输入结束的条
件，使用头插法动态地建立单链表（不带头结点）。
算法思路：
从一个空表开始，重复读入数据，生成新结点，将读入数据存放在新结点的数据域中，然后将新结点插入到当前链表的表头上，直到读入换行符'\n'为止。
图2-6 新结点前插
图2-7 头指针指向新结点
重复进行第②步到第⑥步，便可建立一个含有多个结点的不带头结点的单链表，如图2-8。
head s
d
c
b
a^
图2-8 头插法建单链表
04
0.5
05
头插法建立单链表
具体算法：
LinkList CreatListF(void)
{//头插法建立单链表
DataType ch;
算法步骤：
①将头指针head置为
②读取字符ch，判断ch与'\n'是否不相
NULL，转向②。如图2-3。等，若是转向③，否则，返回head。

单链表的头插法和尾插法c语言实现

单链表的头插法和尾插法c语⾔实现/*单链表的头插法和尾插法c语⾔实现*/#include <stdio.h>#include <stdlib.h>#include <string.h>#define SIZE 100/*简单的定义⼀个链表节点的数据单元*/typedef struct student_t{int num;char name[SIZE];struct student_t* pNext;}studentList, *pStudentList;/*定义⼀个全局的静态的链表头节点指针*/static pStudentList g_pstStudentList = NULL;/*创建⼀个学⽣信息的链表节点*/pStudentList createaOneStudentListNode(){pStudentList pNewNode = NULL;pNewNode = (pStudentList)malloc(sizeof(studentList));return pNewNode;}/*在链表头插⼊数据节点*/int addOneStudentToListHead(int num, char* name){pStudentList pNewNode = NULL;int result = 0;if ((num < 0) || (name == NULL)){result = -1;printf("error inoput parameter!\n");return result;}pNewNode = createaOneStudentListNode();pNewNode->num = num;memcpy(pNewNode->name, name, strlen(name));pNewNode->pNext = g_pstStudentList;g_pstStudentList = pNewNode;return result;}/*在链表尾部插⼊数据节点*/int addOneStudentToListTail(int num, char* name){pStudentList pTempHead = NULL;pStudentList pTailNode = NULL;pStudentList pNewNode = NULL;int result = 0;if ((num < 0) || (name == NULL)){result = -1;printf("error input parameter!\n");return result;}pTempHead = g_pstStudentList;while(pTempHead){if (pTempHead->pNext == NULL){pTailNode = pTempHead;}pTempHead = pTempHead->pNext;}pNewNode = createaOneStudentListNode();pNewNode->num = num;memcpy(pNewNode->name, name, strlen(name));pNewNode->pNext = NULL;pTailNode->pNext = pNewNode;return result;}/*输出整个链表中的学号信息，检查插⼊的是否正确，插⼊时没有考虑是否有相同学号*/ void printList(){pStudentList pTempHead = NULL;pTempHead = g_pstStudentList;while(pTempHead){printf("studnet num = %d\n", pTempHead->num);pTempHead = pTempHead->pNext;}}/*释放整个链表的资源*/void freeList(){pStudentList pTempHead = NULL;pStudentList pFree = NULL;int i = 0;pTempHead = g_pstStudentList;pFree = g_pstStudentList;while(pTempHead){pFree = pTempHead;printf("free studnet num = %d\n", pTempHead->num);pTempHead = pTempHead->pNext;if (pFree != NULL){printf("i = %d\n", i);/*测试是否正确释放资源*/free(pFree);}++i;}}int main(){/*构建头节点*/char* cName = "allan";g_pstStudentList = createaOneStudentListNode();g_pstStudentList->num = 0;memcpy(g_pstStudentList->name, cName, strlen(cName));g_pstStudentList->pNext = NULL;/*使⽤尾插法插⼊数据*/char* cName1 = "allan1";addOneStudentToListTail(1,cName1);/*使⽤尾插法插⼊数据*/char* cName2 = "allan2";addOneStudentToListTail(2,cName2);/*使⽤头插法插⼊数据*/char* cName3 = "allan3";addOneStudentToListHead(3,cName3);/*输出当前链表中存储的学号，没有考虑学号的唯⼀性，假设输⼊的都是不同数字*/ printList();/*使⽤完资源后进⾏释放资源，防⽌内存泄漏*/freeList();return 0;}使⽤VS2008运⾏结果如下图所⽰：。

单链表的创建算法

当一个序列中只含有指向它的后继结点的链接时，就称该链表为单链表。

单链表的创建算法如下：
创建一个结点，并为结点的数据部分赋予一个初始值。

创建一个指向下一个结点的指针，并将其初始化为NULL。

将新创建的结点插入到链表的头部或尾部。

重复步骤2和3，直到所有需要插入的结点都已插入链表。

在单链表中，最后一个结点的指针域被定义为空指针(NULL)，以标识链表的结束。

此外，单链表可以有带头结点和不带头结点之分，具体根据实际需求选择。

单链表之头部插入节点

单链表之头部插入节点
朱ቤተ መጻሕፍቲ ባይዱ鹏
1、单链表的算法之从头部插入节点 1.1、链表头部插入思路解析
在分析链表的算法的时候一定要注意心里有数，先搞清楚完成这个算法需要哪几步，每步做什么，然后再去思考每步的代码实现是什么，否则就会只看到指针指来指去，很快就晕头转向了。
头插入节点的两个重要步骤：（1）新节点的 pNext 指向原来的第一个节点的首地址，即新节点和原来的第一个节点相连。（2）头结点的 pNext 指向新节点的首地址，即头结点和新节点相连。经过这两步新节点就插入了头结点和原来的第一个节点之间，成为新的第一个节点。这两个步骤简单来讲就是先连接尾巴，后连接头部。
1.2、箭头非指向（1）先回顾一下如何访问结构体当中的成员？没错，有符号“.”和符号“->” 两种方式，这两种方式的区别这里就不在重复，理解这一点对与链表的学习有
很大的帮助。（2）注意写代码过程中的箭头符号，和指针的指向是没有关系的，它们是两码事，很容易搞混。在现实生活中用->表示指向是常识，但是在 C 语言中->是用指针的方式来访问结构体当中的某个成员。换句话说链表中节点的连接过程和程序中的->没有关系；链表中的节点是通过指针的指向来连接的，编程中表现为给指针变量赋值，实质是把后一个节点的首地址赋值给前一个节点的 pNext 元素。请记住，箭头非指向，否则对链表的理解会造成不小的困扰。
伪代码： insert_head() {
第 1 步：新节点的 pNext 指向原来的第一个节点第 2 步：头节点的 pNext 指向新节点的地址 } 具体代码实现： void insert_head(struct node *pH, struct node *new) { new->pNext = pH->pNext; pH->pNext = new; } 请思考一下第一步和第二步的顺序可不可以交换一下？如果我们先执行第二步，将头结点的 pNext 指针指向了新节点的首地址，当我们想要执行第一步的时候就会发现原来的第一个有效节点的地址已经丢失了，第一步自然也就做不下去了，所以这两步的顺序还是要注意一下的。

链表-头插法

1、请采用从链表头部插入的方式重新设计上述例子程序中的create( )函数（函数的功能和函数头都不变）：每次插入的新节点都插入在链表的头部（即head指针指向刚插入的节点，刚插入节点的next指针指向原先head指针所指向的节点）。

#include<stdlib.h> /*包含malloc()的头文件*/#include<stdio.h>struct node /*链表节点的结构*/{int num;struct node * next;};struct node * create(struct node * head) /*返回新创建的链表的首指针*/ {int n;struct node * p1,* p2;p1=NULL;p2=NULL;while(1){scanf("%d",&n);if(n<0)break;p1=(node *)malloc(sizeof(node));p1->num=n;p2=p1;p1->next=head;head=p2;}return head; /*返回链表的头指针*/}void print(struct node * head) /*输出以head为头的链表各节点的值*/ {struct node * temp;temp=head; /*取得链表的头指针*/while(temp!=NULL) /*只要是非空表*/{printf("%d ",temp->num); /*输出链表节点的值*/temp=temp->next; /*跟踪链表增长*/}}void main(){struct node * head; /*定义头指针*/head=NULL; /*建一个空表*/head=create(head); /*创建单链表*/print(head); /*打印单链表*/}2、以下代码是从键盘上输入n个整数，将这些整数按从小到大的顺序依次保存到一个链表中，请仔细阅读代码并写出其是如何将一个节点按从小到大的顺序插入到链表中的。

广义表的单链表示

广义表的单链表示是一种数据结构，它采用链式存取方式，利用结点的方式表示数据。

在这一数据结构中，每个结点由一个元素和一个指向其他结点的指针组成。

单链表的创建有两种方法，分别是头插入法和尾插入法。

头插入法的效果是使得整个链表的元素逆序，而尾插入法则能够保证结点次序与输入数据保持一致。

我们以一个简单的例子来说明如何进行广义表的单链表示。

假设我们有一个名为"A,B"的广义表，表示元素为"A"和"B"的两个元素组成的集合。

这个广义表可以转换成一个单链表来进行存储。

首先，我们可以创建两个空结点，分别表示"A"和"B"的元素，并且在每个结点上设置一个指向下一个结点的指针。

例如，我们可以将第一个结点设置为指向第二个结点的指针，而将第二个结点设置为指向空的指针。

然后，我们可以使用尾插入法将"A"和"B"这两个元素依次插入到链表的尾部。

这就需要我们不断地使用递归的方法，将当前结点插入到链表的尾部。

在每一次递归中，我们都需要递增一个指针来指向当前结点的下一个结点。

当我们完成整个插入操作后，整个链表的结构将类似于一个无穷的链表，其中"A"和"B"分别在链表的首尾两个位置。

值得注意的是，由于广义表的元素可能是多元组或者无穷集，因此单链表的长度和深度也可能是无限的。

这就需要我们在实现单链表的操作时，需要进行一些特殊的处理。

例如，我们可以使用栈或者树等数据结构来管理结点的插入和删除操作。

总之，广义表的单链表示是一种非常实用的数据结构，它能够有效地表示和管理无穷集和多元组等复杂数据。

通过采用单链表的结构，我们能够方便地进行元素的插入、删除、查找等操作，并在需要时进行递归处理。

c语言单链表头插法

在C语言中，单链表是一种常见的数据结构，用于存储一系列动态分配的数据。

头插法是一种在单链表中插入节点的方法，它将新节点插入到链表的开头。

下面是使用头插法创建单链表的基本示例：#include <stdio.h>#include <stdlib.h>// 定义单链表节点结构struct Node {int data;struct Node* next;};// 头插法插入节点struct Node* insertNode(struct Node* head,int newData){struct Node* newNode =(struct Node*)malloc(sizeof(struct Node));/ / 创建新节点if(newNode == NULL){printf("内存分配失败\n");exit(1);}newNode->data = newData;// 设置新节点数据newNode->next = head;// 新节点指向当前头节点head = newNode;// 更新头节点return head;// 返回新的头节点}// 打印链表void printList(struct Node* head){struct Node* current = head;while(current != NULL){printf("%d ", current->data);current = current->next;}printf("\n");}// 示例int main(){struct Node* head = NULL;// 初始化链表头节点// 插入节点head = insertNode(head,3);head = insertNode(head,5);head = insertNode(head,7);// 打印链表printf("链表内容: ");printList(head);return0;}在这个示例中，我们首先定义了一个Node结构体来表示单链表的节点。

数据结构___头插法和尾插法建立链表（各分有无头结点）

实验一链表的建立及基本操作方法实现一、【实验目的】1、理解和掌握单链表的类型定义方法和结点生成方法。

2、掌握利用头插法和尾插法建立单链表和显示单链表元素的算法。

3、掌握单链表的查找（按序号）算法。

4、掌握单链表的插入、删除算法。

二、【实验内容】1、利用头插法和尾插法建立一个无头结点单链表，并从屏幕显示单链表元素列表。

2、利用头插法和尾插法建立一个有头结点单链表，并从屏幕显示单链表元素列表。

3、将测试数据结果用截图的方式粘贴在程序代码后面。

重点和难点：尾插法和头插法建立单链表的区别。

建立带头结点和无头结点单链表的区别。

带头结点和无头结点单链表元素显示方法的区别三、【算法思想】1) 利用头插法和尾插法建立一个无头结点单链表链表无头结点，则在创建链表时，初始化链表指针L=NULL。

当用头插法插入元素时，首先要判断头指针是否为空，若为空，则直接将新结点赋给L,新结点next指向空，即L=p,p->next=NULL，若表中已经有元素了，则将新结点的next指向首结点，然后将新结点赋给L即（p->next=L,L=p）。

当用尾插法插入元素时，首先设置一个尾指针tailPointer以便随时指向最后一个结点，初始化tailPointer和头指针一样即tailPointer=L。

插入元素时，首先判断链表是否为空，若为空，则直接将新结点赋给L即L=p，若不为空，else将最后一个元素的next指向新结点即tailPointer->next=p，然后跳出这个if,else语句，将新结点next指向空，并且将tailPointer指向新结点即p->next=NULL,tailPointer=p。

2) 利用头插法和尾插法建立一个有头结点单链表链表有头结点，则在创建链表时，初始化链表指针L->next = NULL。

与无头结点区别在于，判断链表为空是根据L->next是否为空。

用头插法插入元素时，要判断链表是否为空，若为空则将新结点next指向空，作为表尾，若不为空，则直接插入，将新结点next指向头结点next的指向，再将头结点next指向新结点即p->next=L->next,L->next=p。

单链表的插入算法

单链表的插入算法单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和指向下一个节点的指针。

在单链表中，插入操作是一种常见的操作，它允许在指定位置插入一个新的节点。

本文将介绍单链表的插入算法，并给出示例代码。

一、插入算法的思路单链表的插入算法主要包括以下几个步骤：1. 创建一个新的节点，将待插入的数据赋值给该节点的数据域。

2. 找到插入位置的前一个节点，即待插入节点的前驱节点。

3. 将前驱节点的指针域指向新节点，新节点的指针域指向原来前驱节点的下一个节点。

4. 插入完成。

二、插入算法的实现代码下面是一个使用C语言实现的单链表插入算法的示例代码：```#include <stdio.h>#include <stdlib.h>// 定义单链表的节点结构struct Node {int data;struct Node* next;};// 插入节点的函数void insertNode(struct Node* head, int position, int value) {// 创建新节点struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));newNode->data = value;// 找到插入位置的前一个节点struct Node* temp = head;for (int i = 0; i < position - 1; i++) {if (temp == NULL) {printf("插入位置无效\n");return;}temp = temp->next;}// 插入新节点newNode->next = temp->next;temp->next = newNode;}// 打印链表的函数void printList(struct Node* head) {struct Node* temp = head;while (temp != NULL) {printf("%d ", temp->data);temp = temp->next;}printf("\n");}int main() {// 创建头节点struct Node* head = (struct Node*)malloc(sizeof(struct Node));head->next = NULL;// 插入节点insertNode(head, 0, 1);insertNode(head, 1, 3);insertNode(head, 1, 2);insertNode(head, 3, 4);// 打印链表printList(head->next);return 0;}```三、插入算法的示例运行结果上述代码中，我们插入了四个节点，分别是1、2、3、4。

数据结构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 应用场景在实际应用中，经常会有需要删除指定节点的情况，比如删除链表中特定数值的节点等。

数据结构头插法和尾插法建立链表（各分有无头结点）

实验一链表的建立‎及基本操作‎方法实现一、【实验目的】1、理解和掌握‎单链表的类‎型定义方法‎和结点生成‎方法。

2、掌握利用头‎插法和尾插‎法建立单链‎表和显示单‎链表元素的‎算法。

3、掌握单链表‎的查找（按序号）算法。

4、掌握单链表‎的插入、删除算法。

二、【实验内容】1、利用头插法‎和尾插法建‎立一个无头‎结点单链表‎，并从屏幕显‎示单链表元‎素列表。

2、利用头插法‎和尾插法建‎立一个有头‎结点单链表‎，并从屏幕显‎示单链表元‎素列表。

3、将测试数据‎结果用截图‎的方式粘贴‎在程序代码‎后面。

重点和难点‎：尾插法和头‎插法建立单‎链表的区别‎。

建立带头结‎点和无头结‎点单链表的‎区别。

带头结点和‎无头结点单‎链表元素显‎示方法的区‎别三、【算法思想】1) 利用头插法‎和尾插法建‎立一个无头‎结点单链表‎链表无头结‎点，则在创建链‎表时，初始化链表‎指针L=NULL。

当用头插法‎插入元素时‎，首先要判断‎头指针是否‎为空，若为空，则直接将新‎结点赋给L‎,新结点ne‎x t指向空‎，即L=p,p->next=NULL，若表中已经‎有元素了，则将新结点‎的n ext‎指向首结点‎，然后将新结‎点赋给L即‎（p->next=L,L=p）。

当用尾插法‎插入元素时‎，首先设置一‎个尾指针t‎a i lPo‎i nter‎以便随时指‎向最后一个‎结点，初始化ta‎i lPoi‎n ter和‎头指针一样‎即tail‎P oint‎e r=L。

插入元素时‎，首先判断链‎表是否为空‎，若为空，则直接将新‎结点赋给L‎即L=p，若不为空，else将‎最后一个元‎素的nex‎t指向新结‎点即tai ‎l Poin‎t er->next=p，然后跳出这‎个i f,else语‎句，将新结点n‎e xt指向‎空，并且将ta‎i lPoi‎n ter指‎向新结点即‎p->next=NULL,tailP‎oi nte‎r=p。

链表的各种插入法

linklist createlistr1( ){ char ch; linklist head=(linklist)malloc(sizeof(listnode)); listnode *p，*r；，； r=head; while((ch=getchar( ))!=‵\n′{ ‵ p=(listnode*)malloc(sizeof(listnode)); p–>data=ch; p–>next=p; r=p; } r–>next=NULL; return(head); }
2、尾插法建表、头插法建立链表虽然算法简单，头插法建立链表虽然算法简单，但生成的链表中结点的次序和输入的顺序相反。若希望二者次序一致，结点的次序和输入的顺序相反。若希望二者次序一致，可采用尾插法建表。可采用尾插法建表。该方法是将新结点插入到当前链表的表尾上，为此必须增加一个尾指针，的表尾上，为此必须增加一个尾指针r，使其始终指向当前链表的尾结点。当前链表的尾结点。
linklist creater( ) { char ch; linklist head; //(， *head;) ， r=NULL; listnode *p，*r; ， head=NULL;
while((ch=getchar( )!=‵\n′){ ‵ p=(listnode *)malloc(sizeof(listnode)); p–>data=ch; if(head=NULL) else r=p; } if (r!=NULL) return(head); } r–>next=NULL; r–>next=p; head=p;
如果我们在链表的开始结点之前附加一个结点，如果我们在链表的开始结点之前附加一个结点，并称它头结点，那么会带来以下两个优点：为头结点，那么会带来以下两个优点： a、由于开始结点的位置被存放在头结点的指针域中，所以在链表的第一个位置上的操作就和在表的其它位置上的操作一致，无需进行特殊处理；位置上的操作一致，无需进行特殊处理； b、无论链表是否为空，其头指针是指向头结点在无论链表是否为空，的非空指针（空表中头结点的指针域为空），），因此空表的非空指针（空表中头结点的指针域为空），因此空表和非空表的处理也就统一了。和非空表的处理也就统一了。

带结点与不带结点用头插法和尾插法创建单链表

带结点与不带结点⽤头插法和尾插法创建单链表⼀、采⽤带有头结点的头插法逆向建⽴单链表Linklist List_HeadInsert1(LinkList &L) //采⽤带有头结点的头插法逆向建⽴单链表{LNode *s; //声明⼀个临时结点int x;L=(LinkList)malloc(sizeof(LNode)); //创建头结点L->next=NULL; //初始为空链表scanf("%d",&x); //输⼊结点的值while(x!=9999){s=(LNode*)malloc(sizeof(LNode)); //创建新结点s->data=x;s->next=L->next; //将新结点插⼊表中，L为头指针L->next=s;scanf("%d",&x);}return L;}⼆、采⽤不带有头结点的头插法逆向建⽴单链表Linklist List_HeadInsert2(LinkList &L) //采⽤不带有头结点的头插法逆向建⽴单链表{LNode *s; //声明⼀个临时结点int x;L=NULL;scanf("%d",&x); //输⼊结点的值while(x!=9999){s=(LNode*)malloc(sizeof(LNode)); //创建新结点s->data=x;if(L==NULL) // 若第⼀次创建节点，则将该点设置为头节点{L=s;s->next=NULL;}else{ // 若不是第⼀次创建节点，则直接将新节点接到链表头s->next=L;L=s;}scanf("%d",&x);}return L;}三、采⽤带有头结点的尾插法正向建⽴单链表Linklist List_TailInsert1(LinkList &L) //采⽤带有头结点的尾插法正向建⽴单链表{LNode *s,*r; //s为临时结点，r为表尾指针int x;L=(LinkList)malloc(sizeof(LNode)); //创建头结点L->next=NULL; //初始为空链表r=L;scanf("%d",&x); //输⼊结点的值while(x!=9999){s=(LNode*)malloc(sizeof(LNode)); //创建新结点s->data=x;r->next=s;r=s; //r指向新的表尾结点scanf("%d",&x);}r->next=NULL; //尾结点指针为空return L;}四、⽤不带有头结点的尾插法正向建⽴单链表Linklist List_TailInsert2(LinkList &L) //采⽤不带有头结点的尾插法正向建⽴单链表{LNode *s,*r; //s为临时结点，r为表尾指针int x;L=NULL;r=L;scanf("%d",&x); //输⼊结点的值while(x!=9999){s=(LNode*)malloc(sizeof(LNode)); //创建新结点s->data=x;if(L==NULL) // 创建链表的第⼀个节点{L=s;r=s;s->next=NULL;}else{r->next=s;r=s;}scanf("%d",&x);}r->next=NULL; //尾结点指针为空return L;}。

学习随记一——用C语言实现单链表的头插法和尾插法

学习随记⼀——⽤C语⾔实现单链表的头插法和尾插法## ⽤c语⾔实现单链表的头插法和尾插法1. 创建结点结构体——第⼀部分是数据域----存储数据——第⼆部分是指针域----连接结点例：```ctypedef struct Listnode{int data; //数据域struct Listnode* next; //指针域}ListNode;```2. 封装创建链表的函数```cListNode* createlist1(){ //头插法实现链表创建int i; //存储数据ListNode *head,*p; //头指针和⼯作指针head=NULL; //链表开始为空printf("请开始输⼊数据，结束输⼊输⼊-1值即可\n");scanf("%d",&i);while(i!=-1){p=(ListNode*)malloc(sizeof(ListNode)); //创建新结点p->data=i; //将值赋给新结点的数据域中p->next=head; //头插法⽣成的第⼀个结点是链表的最后⼀个结点head=p; //头指针指向新⽣成的结点scanf("%d",&i);}return head;}``````cListNode* createlist2(){ //尾插法实现int i; //存储数据ListNode *head,*p,*r; //因为要保留头指针的位置⽅便操作所以要⼀个中间指针phead=NULL;printf("请开始输⼊数据，输⼊-1结束\n");scanf("%d",&i);while(i!=-1){r=(ListNode*)malloc(sizeof(ListNode)); //为新结点申请空间r->data=i; //将数据存⼊数据域中if(head==NULL){ //这步操作主要是为了保留头指针地址head=r;}else{p->next=r; //连接结点}p=r;scanf("%d",&i);}if(p!=NULL) p->next=NULL; //防⽌野指针return head;}```1. 主函数```cint main(void){ListNode *p,*q;int choice;printf("请选择⽤头插法创建单链表还是尾插法创建单链表，头插法选1，尾插法选2\n");scanf("%d",&choice);getchar();if(choice==1){q=CreateList1(); //头插法创建单链表}else if(choice==2){q=CreateList2(); //尾插法创建单链表}else{printf("输⼊错误，程序终⽌\n");exit(-1);}while(q){printf("%c",q->data); //输出单链表结点数据p=q->next; //p为q的后继点free(q); //释放q结点所占内存q=p;}printf("\n");return 0;}```。

线性表知识点总结

线性表知识点总结定义：线性表是具有相同数据类型的n（n≥0）个数据元素的有限序列。

其中n为表长。

当n=0时线性表是⼀个空表特点：线性表中第⼀个元素称为表头元素；最后⼀个元素称为表尾元素。

除第⼀个元素外，每个元素有且仅有⼀个直接前驱。

线性表的顺序存储⼜称为顺序表。

它是⽤⼀组地址连续的存储单元（⽐如C语⾔⾥⾯的数组），依次存储线性表中的数据元素，从⽽使得逻辑上相邻的两个元素在物理位置上也相邻。

建⽴顺序表的三个属性:1.存储空间的起始位置（数组名data）2.顺序表最⼤存储容量（MaxSize）3.顺序表当前的长度（length）其实数组还可以动态分配空间，存储数组的空间是在程序执⾏过程中通过动态存储分配语句分配总结：1.顺序表最主要的特点是随机访问（C语⾔中基于数组），即通过⾸地址和元素序号可以在O(1)的时间内找到指定的元素。

2.顺序表的存储密度⾼，每个结点只存储数据元素。

⽆需给表中元素花费空间建⽴它们之间的逻辑关系（因为物理位置相邻特性决定）1.插⼊算法思路：1.判断i的值是否正确1 2 3 4 5 6#define Maxsize 50 //定义线性表的最⼤长度typedef int Elemtype // 假定表中的元素类型是整型typedef struct{Elemtype data [maxsize]; // 顺序表中的元素int lengh; // 顺序表的类型定义}Sqlist;1234567891011121314 typedef int Elemtype // 假定表中的元素类型是整型typedef struct{Elemtype *data; // 指⽰动态分配数组的指针int Maxsize,lengh; // 数组的最⼤容量和当前个数}Sqlist;//C语⾔的动态分配语句为#define InitSize 100SeqList L;L.data = (ElemType*)malloc(sizeof(ElemType)*InitSize);/*注意:动态分配并不是链式存储，同样还属于顺序存储结构，只是分配的空间⼤⼩可以在运⾏时决定*/2.判断表长是否超过数组长度3.从后向前到第i个位置，分别将这些元素都向后移动⼀位4.将该元素插⼊位置i 并修改表长代码分析：最好情况：在表尾插⼊（即i=n+1），元素后移语句将不执⾏，时间复杂度为O(1)。