《数据结构》-头插法建立单链表
头插法和尾插法建立单链表
#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);*/。
链表的各种插入法
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); }
如果我们在链表的开始结点之前附加一个结点， 如果我们在链表的开始结点之前附加一个结点，并称它 头结点，那么会带来以下两个优点： 为头结点，那么会带来以下两个优点： a、由于开始结点的位置被存放在头结点的指针域 中，所以在链表的第一个位置上的操作就和在表的其它 位置上的操作一致，无需进行特殊处理； 位置上的操作一致，无需进行特殊处理； b、无论链表是否为空，其头指针是指向头结点在 无论链表是否为空， 的非空指针（空表中头结点的指针域为空）， ），因此空表 的非空指针（空表中头结点的指针域为空），因此空表 和非空表的处理也就统一了。 和非空表的处理也就统一了。
linklist creater( ) { char ch; linklist head; //(， *head;) ， r=NULL; listnode *p，*r; ， head=r( )!=‵\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;
数据结构课程设计-单链表
目录1 选题背景 (1)2 方案与论证 (1)2。
1 链表的概念和作用 (1)2。
3 算法的设计思想 (2)2。
4 相关图例 (3)2.4.1 单链表的结点结构 (3)2.4。
2 算法流程图 (3)3 实验结果 (4)3.1 链表的建立 (4)3.2 单链表的插入 (4)3.3 单链表的输出 (5)3.4 查找元素 (5)3。
5 单链表的删除 (5)3。
6 显示链表中的元素个数（计数) (5)4 结果分析 (6)4。
1 单链表的结构 (6)4。
2 单链表的操作特点 (6)4。
2。
1 顺链操作技术 (6)4.2。
2 指针保留技术 (6)4。
3 链表处理中的相关技术 (6)5 设计体会及今后的改进意见 (6)参考文献 (8)附录代码： (8)1 选题背景陈火旺院士把计算机60多年的发展成就概括为五个“一”：开辟一个新时代-—--信息时代,形成一个新产业-—-—信息产业,产生一个新科学—---计算机科学与技术，开创一种新的科研方法-—--计算方法，开辟一种新文化---—计算机文化，这一概括深刻影响了计算机对社会发展所产生的广泛而深远的影响。
数据结构和算法是计算机求解问题过程的两大基石。
著名的计算机科学家P.Wegner指出，“在工业革命中其核心作用的是能量,而在计算机革命中其核心作用的是信息”.计算机科学就是“一种关于信息结构转换的科学”.信息结构（数据结构）是计算机科学研究的基本课题，数据结构又是算法研究的基础。
2 方案与论证2。
1 链表的概念和作用链表是一种链式存储结构，链表属于线性表,采用链式存储结构，也是常用的动态存储方法。
链表中的数据是以结点来表示的，每个结点的构成:元素（数据元素的映象） + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元,指针就是连接每个结点的地址数据。
以“结点的序列”表示线性表称作线性链表（单链表)单链表是链式存取的结构，为找第 i 个数据元素，必须先找到第 i-1 个数据元素。
描述单链表的创建过程
描述单链表的创建过程
单链表是一种常用的线性数据结构，它由一系列节点组成，每个节点包含数据元素和一个指向下一个节点的指针。
创建单链表的过程可以分为以下几个步骤：
定义节点结构：首先，需要定义节点的结构。
每个节点通常包含数据元素和一个指向下一个节点的指针。
在许多编程语言中，可以使用结构体或类来定义节点。
例如，在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语言的单链表头插法实现了链表的逆置。
单链表的头插法和尾插法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运⾏结果如下图所⽰：。
带头结点的单链表的插入算法
带头结点的单链表的插入算法在计算机科学中，链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
链表有多种形式，其中一种是带头结点的单链表。
带头结点的单链表是在普通的单链表的基础上添加了一个头结点，头结点不存储数据，只用来标识链表的开始。
带头结点的单链表的插入算法是指在链表中插入新的节点的操作。
下面将详细介绍带头结点的单链表的插入算法。
带头结点的单链表的插入算法包括以下几个步骤：1. 首先，创建一个新的节点，该节点包含要插入的数据。
2. 然后，找到插入位置的前一个节点，可以从头结点开始遍历链表，直到找到插入位置的前一个节点为止。
3. 接下来，将新节点的指针指向插入位置的后一个节点。
4. 最后，将插入位置的前一个节点的指针指向新节点。
下面通过一个具体的例子来说明带头结点的单链表的插入算法。
假设有一个带头结点的单链表，初始状态下只有一个头结点。
现在要在链表中插入一个新节点，该节点的数据为10。
1. 首先，创建一个新的节点，节点的数据为10。
2. 然后，从头结点开始遍历链表，直到找到插入位置的前一个节点。
在这个例子中，由于链表只有一个头结点，所以插入位置的前一个节点就是头结点。
3. 接下来，将新节点的指针指向插入位置的后一个节点。
由于链表只有一个头结点，所以插入位置的后一个节点为空。
4. 最后，将插入位置的前一个节点的指针指向新节点。
在这个例子中，将头结点的指针指向新节点。
经过以上操作，新节点就成功地插入到了链表中。
带头结点的单链表的插入算法的时间复杂度为O(n)，其中n为链表的长度。
这是因为在最坏情况下，需要遍历整个链表找到插入位置的前一个节点。
带头结点的单链表的插入算法在实际应用中有着广泛的应用。
例如，在图算法中，可以使用带头结点的单链表来表示图的邻接表。
插入节点的操作可以用来添加新的边或顶点。
带头结点的单链表的插入算法是一种常见的数据操作，它可以在链表中插入新的节点。
《数据结构》实验指导(一)
实验一线性表一、实验目的线性表是最简单、最常用的基本数据结构，在实际问题中有着广泛的应用。
通过本章的实验，巩固对线性表逻辑结构的理解，掌握线性表的存储结构及基本操作的实现，为应用线性表解决实际问题奠定良好的基础，并进一步培养以线性表作为数据结构解决实际问题的应用能力。
（1）掌握线性表的顺序存储结构；（2）验证顺序表及其基本操作的实现；（3）掌握数据结构及算法的程序实现的基本方法。
（4）掌握线性表的链接存储结构；（5）验证单链表及其基本操作的实现；（6）进一步掌握数据结构及算法的程序实现的基本方法。
二、实验示例学习——顺序表操作实验要求：（1）建立含有若干个元素的顺序表；（2）对已建立的顺序表实现插入、删除、查找等基本操作。
实现提示：首先定义顺序表的数据类型——顺序表类SeqList，包括题目要求的插入、删除、查找等基本操作，为便于查看操作结果，设计一个输出函数依次输出顺序表的元素。
const int MaxSize=10;template <class T> //定义模板类SeqListclass SeqList{public:SeqList( ){length=0;} //无参构造函数SeqList(T a[ ], int n);//有参构造函数void Insert(int i, T x); //在线性表中第i个位置插入值为x的元素T Delete(int i); //删除线性表的第i个元素int Locate(T x ); //按值查找，求线性表中值为x的元素序号void PrintList( ); //遍历线性表，按序号依次输出各元素private:T data[MaxSize]; //存放数据元素的数组int length; //线性表的长度};其次，建立含有n个数据元素的顺序表，即设计构造函数。
算法如下：template <class T>SeqList:: SeqList(T a[ ], int n){if (n>MaxSize) throw "参数非法";for (i=0; i<n; i++)data[i]=a[i];length=n;}最后，对建立的顺序表设计插入、删除、查找等基本操作的算法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
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。
③生成一个新结点*s（即由
s指向），转向④。如图2-
4。
head
s
^
④将ch写入新结点*s数据域，转向⑤。
如图2-5。
s
a
图2-3 头指针
图2-4 新结点s
图2-5 值写入数据域
03
0.5 头插法建立单链表
5 ⑤将新结点*s插入链表的前面（第1个重 复进行第②步到第⑥步，便可建立一个
含有多个结点的不带头结点的单链表， 如图2-8。 结点时是将*s指针域置为NULL），转向 ⑥。如图2-6。
头插法建单链表
⑥将头指针指向新结点，转向②。
6 如图2-7。 s
a^
head s
a^
}
s->data=ch;
//输入的数据写入结点数据域
s->next=head; //将新结点*s插入链表}
return head;
}
THANKS