单链表的建立和基本的操作 c代码

合集下载

链表的基本操作代码c语言

链表的基本操作代码c语言链表是一种常见的数据结构，其基本操作包括创建、插入、删除和遍历等。

以下是链表的基本操作代码（C语言实现）：1. 链表节点的定义cCopy codetypedef struct ListNode { int val; // 节点的值struct ListNode *next; // 指向下一个节点的指针 } ListNode;2. 创建链表cCopy codeListNode* createList(int arr[], int n) { ListNode *head = NULL, *tail = NULL; for (int i = 0; i < n; i++) { ListNode *node = (ListNode *)malloc(sizeof(ListNode)); node->val = arr[i]; node->next = NULL; if (tail == NULL) { head = tail = node; } else { tail->next = node; tail = node; } } return head; }3. 插入节点cCopy codevoid insertNode(ListNode **head, int val, int index) { if (index < 0) { return; } ListNode *node = (ListNode *)malloc(sizeof(ListNode)); node->val = val; node->next = NULL; if (index == 0) { node->next = *head; *head = node; } else { ListNode *prev = *head; for (int i = 0; i < index - 1; i++) { if (prev == NULL) { return; } prev = prev->next; }if (prev == NULL) { return; } node->next = prev->next; prev->next = node; } }4. 删除节点cCopy codevoid deleteNode(ListNode **head, int index) { if (*head == NULL || index < 0) { return; } if (index == 0) { ListNode *node = *head; *head = (*head)->next; free(node); } else { ListNode *prev = *head; for (int i = 0; i < index - 1; i++) { if (prev->next == NULL) { return; } prev = prev->next; } if (prev->next == NULL) { return; } ListNode *node = prev->next; prev->next = node->next; free(node); } }5. 遍历链表cCopy codevoid traverseList(ListNode *head) { while (head != NULL) { printf("%d ", head->val); head = head->next; } printf("\n"); }以上是链表的基本操作代码，可以根据需要进行调整和扩展。

单链表初始化 c语言

单链表初始化 c语言单链表是一种常用的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。

在使用单链表之前，需要先进行初始化操作，即创建一个空链表。

本文将介绍单链表的初始化方法，并给出相应的C语言代码。

单链表的初始化操作包括两个步骤：1. 创建一个头结点：头结点不包含任何数据元素，只有一个指向第一个节点的指针。

它的作用是统一处理链表的操作，简化代码的编写。

2. 将头结点的指针域置为空：由于此时还没有节点加入链表，所以头结点的指针域应该为空。

下面是单链表初始化的C语言代码：```#include <stdio.h>#include <stdlib.h>typedef struct Node { //定义单链表节点结构体int data; //数据域struct Node *next; //指针域} Node, *LinkedList; //Node为节点类型，LinkedList为指向节点的指针类型LinkedList InitList() { //初始化单链表LinkedList L; //定义头结点指针L = (LinkedList)malloc(sizeof(Node)); //分配头结点空间 if (L == NULL) { //判断内存是否分配成功printf('内存分配失败！');exit(0);}L->next = NULL; //将头结点的指针域置为空return L; //返回头结点指针}int main() {LinkedList L = InitList(); //创建一个空链表printf('单链表初始化成功！');return 0;}```在上面的代码中，我们首先定义了一个节点结构体，包含一个数据域和一个指针域。

然后定义了一个头结点指针类型，用于指向链表的头结点。

接着我们使用malloc函数为头结点分配内存空间，并判断内存分配是否成功。

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

数据结构-单链表基本操作实现（含全部代码）今天是单链表的实现，主要实现函数如下：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),因为可以与后继结点交换数据域，然后删除后继结点。

实现单链表的基本操作c语言

实现单链表的基本操作c语言单链表是一种基本的数据结构，在计算机科学中广泛使用。

它由一系列节点构成，每个节点都包含数据和对下一个节点的引用。

本文将介绍如何用C语言实现单链表的基本操作，包括创建、插入、删除以及遍历。

1. 创建单链表创建单链表需要定义一个结构体来表示每个节点，结构体中包括数据和指向下一个节点的指针。

接着，需要编写一个函数来创建一个新的节点，并把它插入到链表中。

具体步骤如下：（1）定义单链表结构体```ctypedef struct node{int data;struct node* next;}Node;```（2）创建新节点```cNode* create_node(int data){Node* new_node = (Node*)malloc(sizeof(Node));new_node->data = data;new_node->next = NULL;return new_node;}```（3）插入新节点到链表```cNode* insert_node(Node* head, Node* new_node){if(head == NULL){head = new_node;}else{Node* p = head;while(p->next != NULL){p = p->next;}p->next = new_node;}return head;}```2. 插入节点插入节点的操作可以分为两种情况：在链表的开头插入和在链表的中间插入。

具体步骤如下：（1）在链表开头插入节点```cNode* insert_head(Node* head, Node* new_node){if(head == NULL){head = new_node;}else{new_node->next = head;head = new_node;}return head;}```（2）在链表中间插入节点```cNode* insert_node(Node* head, int pos, Node* new_node){if(head == NULL){head = new_node;}else{Node* p = head;int i = 1;while(i < pos-1 && p != NULL){p = p->next;i++;}new_node->next = p->next;p->next = new_node;}return head;}```3. 删除节点删除节点的操作也可以分为两种情况：删除链表的第一个节点和删除链表中间的节点。

写出单链表存储结构的 c 语言描述

写出单链表存储结构的 c 语言描述一、单链表的概述单链表是一种常见的数据结构，它由若干个节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。

单链表的特点是插入和删除操作效率高，但查找操作效率较低。

二、单链表的存储结构单链表的存储结构采用动态分配内存的方式，每个节点都是一个独立的内存区域，通过指针将它们连接在一起。

下面是单链表存储结构的 c 语言描述：```typedef struct Node{int data; // 数据域struct Node *next; // 指针域} ListNode, *LinkedList;```上面代码中，ListNode 表示节点类型，LinkedList 表示链表类型。

其中 data 是数据域，next 是指针域，用于存放下一个节点的地址。

三、单链表的基本操作1. 初始化操作初始化操作用于创建一个空链表。

```void InitList(LinkedList *L){*L = (ListNode*)malloc(sizeof(ListNode)); // 创建头结点(*L)->next = NULL; // 头结点指针域为空}```2. 插入操作插入操作用于在链表中插入新节点。

```int Insert(LinkedList L, int i, int x)int j = 0;ListNode *p = L;while (p && j < i - 1) // 找到第 i-1 个节点{p = p->next;j++;}if (!p || j > i - 1) // 判断 i 的范围是否合法{return 0;}ListNode *s = (ListNode*)malloc(sizeof(ListNode)); // 创建新节点s->data = x; // 赋值数据域s->next = p->next; // 新节点指向下一个节点p->next = s; // 前一个节点指向新节点 return 1;```3. 删除操作删除操作用于删除链表中的某个节点。

单链表的基本算法（c语言）

单链表的基本算法（c语言）#include#include#include#define MaxSize 50typedef char ElemType;typedef struct LNode{ ElemType data;struct LNode *next;} LinkNode;//1--用尾插法建立单链表void CreateListR(LinkNode *&L,ElemType a[],int n) { LinkNode *s,*r;L=(LinkNode *)malloc(sizeof(LinkNode));r=L;for (int i=0;i<n;i++)< p="">{s=(LinkNode*)malloc(sizeof(LinkNode));s->data=a[i];r->next=s;r=s;}r->next=NULL;}//2--初始化线性表void InitList(LinkNode *&L){L=(LinkNode*)malloc(sizeof(LinkNode));L->next=NULL;}//3--销毁线性表void DestroyList(LinkNode*&L){LinkNode *pre=L,*p=L->next;while(p!=NULL){free(pre);pre=p;p=pre->next;}free(pre);}//4--输出单链表void DispList( LinkNode *L){LinkNode *p=L->next;while(p!=NULL){printf("%c ",p->data);//char类型用%c p=p->next;}printf("\n");}//5--输出单链表的长度void ListLength(LinkNode *L){int n=0;LinkNode *p=L;while(p->next!=NULL){n++;p=p->next;}printf("%d\n",n);//与书上不一样}//6--判断单链表是否为空表void ListEmpty(LinkNode *L){if(L->next==NULL)printf("\n此列表为空\n");elseprintf("\n此列表不为空\n");}//7--输出单链表某个数据元素void GetElem(LinkNode *L,int i){LinkNode *p=L;int n=0;while(p!=NULL&&n!=i){p=p->next;n=n+1;}if(n==i)printf("%c\n",p->data);elseprintf("此单链表不存在第%d个元素\n",i); //与书不一样} //8--查找单链表元素a的位置int LocateElem(LinkNode *L,ElemType e){LinkNode *p=L->next;int i=1;while(p!=NULL&&p->data!='a'){p=p->next;i++;}if(p==NULL)return 0;elsereturn i;}//9--在单链表插入元素fbool ListInsert(LinkNode *&L,int i,ElemType f) {LinkNode *p=L,*s;int j=0;if(i<=0)return false;while(j<i-1&&p!=null)< p="">{j++;p=p->next;}if(p==NULL)return false;else{s=(LinkNode *)malloc(sizeof(LinkNode));s->data='f';s->next=p->next;p->next=s;return true;}}//10--删除数据元素bool ListDelete(LinkNode *&L,int i,ElemType &e) { LinkNode *p=L,*q;int j=0;if(i<=0)return false;while(j<i-1&&p!=null)< p="">{j++;p=p->next;}if(p==NULL)return false;else{q=p->next;if(q==NULL)return false;e=q->data;p->next=q->next;free(q);}return true;}</i-1&&p!=null)<></i-1&&p!=null)<> </n;i++)<>。

单链表基本操作的实现

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

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

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

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

单链表的基本操作c语言

单链表的基本操作(C语言)什么是单链表单链表（Singly Linked List）是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。

每个节点只能访问其后继节点，而无法直接访问前驱节点。

单链表的特点是可以动态地插入和删除节点，相比于数组，具有更好的灵活性和扩展性。

在C语言中，我们可以使用指针来实现单链表。

单链表的基本操作1. 定义单链表结构体在C语言中，我们首先需要定义一个表示单链表的结构体。

结构体包含两个成员：数据元素和指向下一个节点的指针。

typedef struct Node {int data; // 数据元素struct Node *next; // 指向下一个节点的指针} Node;2. 创建单链表创建一个空的单链表需要进行以下步骤：•定义头节点，并初始化为NULL。

•向链表中插入新的节点。

Node* createLinkedList() {Node *head = NULL; // 头节点初始化为NULLint n; // 节点数量printf("请输入要创建的节点数量：");scanf("%d", &n);for (int i = 0; i < n; i++) {int data;printf("请输入第%d个节点的值：", i + 1);scanf("%d", &data);Node *newNode = (Node*)malloc(sizeof(Node)); // 创建新节点newNode->data = data;newNode->next = NULL;if (head == NULL) {head = newNode; // 如果是第一个节点，将其设置为头节点 } else {Node *temp = head;while (temp->next != NULL) {temp = temp->next; // 移动到链表末尾}temp->next = newNode; // 将新节点插入到链表末尾}}return head;}3. 插入节点在单链表中插入一个新的节点需要进行以下步骤：•创建一个新的节点。

C语言单链表的基本操作（增删改查）

C语⾔单链表的基本操作（增删改查）这是尾插法单链表，单链表⽐较适合⽤来做队列和栈，因为在链表的头和尾时的增删改查的时间复杂度为O(1)，⽽在链表内部的增删改查的平均时间复杂度为O(n)。

#include "stdio.h"#include "stdlib.h"//提供malloc()和free()#include "string.h"#include "time.h"//提供strcpy()，time()等//1.⽤结构体创建链表节点//⼀个⽤来存放数据，另⼀个存放指针struct Node{int data; //数据域struct Node* next; //指针域(指向节点的指针）};//2.全局定义链表头尾指针，⽅便调⽤struct Node* head = NULL;struct Node* end = NULL;//3.向链表添加数据void AddListTill(int a ){//创建⼀个节点struct Node* temp = (struct Node*)malloc(sizeof(struct Node)); //此处注意强制类型转换//节点数据进⾏赋值temp->data = a;temp->next = NULL;//连接分两种情况1.⼀个节点都没有2.已经有节点了，添加到尾巴上if(NULL == head){head = temp;//end=temp;}else{end->next=temp;//end=temp; //尾结点应该始终指向最后⼀个}end=temp; //尾结点应该始终指向最后⼀个}//4.遍历链表并输出void ScanList(){struct Node *temp = head; //定义⼀个临时变量来指向头while (temp != NULL){printf("%d\n",temp->data);temp = temp->next; //temp指向下⼀个的地址即实现++操作}}//5.查找指定的数据是否在链表内struct Node* FindNode(int a ){struct Node *temp = head;while(temp != NULL){if(a == temp->data){return temp;}temp = temp->next;}//没找到return NULL;}//6.删除链表void FreeList(){struct Node *temp = head; //定义⼀个临时变量来指向头while (temp != NULL){struct Node* pt = temp;temp = temp->next; //temp指向下⼀个的地址即实现++操作free(pt); //释放当前}//头尾清空，不然下次的头就接着0x10head = NULL;end = NULL;}//7.在指定位置处插⼊数据void AddListRand(int index,int a){if (NULL == head){printf("链表没有节点\n");return;}struct Node* pt = FindNode(index);if(NULL == pt) //没有此节点{printf("没有指定节点\n");return;}//有此节点//创建临时节点，申请内存struct Node* temp =(struct Node *)malloc(sizeof(struct Node));//节点成员进⾏赋值temp->data = a;temp->next = NULL;//连接到链表上 1.找到的节点在尾部 2.找到的节点在中间if (pt == end){//尾巴的下⼀个指向新插⼊的节点end->next = temp;//新的尾巴end = temp;}else{//先连后⾯（先将要插⼊的节点指针指向原来找到节点的下⼀个） temp->next = pt->next;//后连前⾯pt->next = temp;}}//8.删除链表末尾数据void DeleteListTail(){if (NULL == end){printf("链表为空，⽆需删除\n");return;}//链表不为空//链表有⼀个节点if (head == end){free(head);head = NULL;end = NULL;}else{//找到尾巴前⼀个节点struct Node* temp = head;while (temp->next != end){temp = temp->next;}//找到了，删尾巴//释放尾巴free(end);//尾巴迁移end=temp;//尾巴指针为NULLend->next = NULL;}}//9.删除链表的第⼀个数据void DeleteListHead(){ //记住旧头struct Node* temp = head;//链表检测if (NULL == head){printf("链表为空\n");return;}head = head->next; //头的第⼆个节点变成新的头free(temp);}//10.删除链表指定的数据void DeleteListRand(int a){//链表判断是不是没有东西if(NULL == head){printf("链表没东西\n");return;}//链表有东西，找这个节点struct Node* temp = FindNode(a);if(NULL == temp){printf("查⽆此点\n");return;}//找到了,且只有⼀个节点if(head == end){free(head);head = NULL;end = NULL;}else if(head->next == end) //有两个节点{//看是删除头还是删除尾if(end == temp){DeleteListTail();}else if(temp == head){DeleteListHead();}}else//多个节点{//看是删除头还是删除尾if(end == temp)DeleteListTail();else if(temp == head)DeleteListHead();else//删除中间某个节点{ //找要删除temp前⼀个，遍历struct Node* pt = head;while(pt->next != temp){pt=pt->next;}//找到了//让前⼀个直接连接后⼀个跳过指定的即可 pt->next = temp->next;free(temp);}}}//主函数void main(){struct Node *pFind;srand((unsigned)time(NULL));int i;//创建20个节点for(i = 0; i < 20; i++)AddListTill(i); //添加数据//AddListTill(rand());AddListRand(4,86); //在指定位置4增加节点14//DeleteListHead(); //删除⼀个头结点//DeleteListTail(); //删除⼀个尾结点DeleteListRand(4); //删除4节点ScanList(); //遍历输出链表//FreeList(); //删除链表pFind = FindNode(5); //查找5节点if (pFind != NULL){printf("找到%d\n",pFind->data); //找到节点并且输出该节点数据 }else{printf("No Find!\n");}}以下是排序算法的时间和空间复杂度表：。

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

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");

单链表的建立、插入和删除

单链表的建立、插入和删除单链表的建立插入删除#include<stdio.h>#include<stdlib.h>/*线性表*/struct TLink {int data;struct TLink * next;};/*end struct TLink*//*生成新元素*/struct TLink * new_item(int number){struct TLink * r = 0;r = (struct TLink *)malloc(sizeof(struct TLink));r->data = number;r->next = 0;return r;}/*end new_item*//*在线性表中查询数据*/struct TLink * lookup(struct TLink * root, int number) {struct TLink * h = root;while(h) {if (h->data == number) return h;h = h->next ;}/*end lookup*/return 0;}/*在线性表中追加一个数据*/void append(struct TLink * * root, int number){struct TLink * r = 0, * n = 0;if (!root) return ;/*不记录重复元素*/if (lookup(*root, number)) return;/*如果表为空则新建表*/r = *root;if (!r) {*root = new_item(number);return ;}/*end if*//*为保证为有序线性表，如果数据比表头还小则作为表头*/ if (number < r->data ) {n = new_item(number);n->next = r;*root = n;return ;}/*end if*//*在有序线性表中查找位置插入元素*/while(r) {n = r->next ;/*如果已经是表尾则直接追加*/if (!n) {n = new_item(number);r->next = n;return ;}/*end if*//*在中央某处插入*/if (number < n->data ) {r->next = new_item(number);r->next->next = n;return ;}/*end if*/r = n;}/*end while*/}/*end append*//*打印有序线性表*/void print(struct TLink * root){struct TLink * r = root;printf("【");while(r) {printf("%d ", r->data );r = r->next ;}/*end while*/printf("\b】\n");}/*end print*//*将有序线性表h1合并至有序线性表h0，并销毁线性表h1*/ void merge(struct TLink ** h0, struct TLink ** h1){struct TLink * h = 0, * k = 0;if (!h0 || !h1) return ;h = *h1;while(h) {append(h0, h->data );k = h;h = h->next ;free(k);}/*end h*/h1 = 0;}int main(void){int i = 0; struct TLink * x=0, *y = 0;int a[] = {8,4,3,9,5,1};int b[] = {7,2,1,5,6,0};printf("原数据为：\n数组A：【");for(i = 0; i < 6; i++) {printf("%d ", a[i]);append(&x, a[i]);}/*next*/printf("\b】\n数组B：【");for(i = 0; i < 6; i++) {printf("%d ", b[i]);append(&y, b[i]);}/*next*/printf("\b】\n转换为有序线性表\nA：");print(x);printf("B：");print(y);printf("AB合并后为：");merge(&x, &y);print(x);return 0;}。

c语言链表定义

c语言链表定义链表是一种非常基础的数据结构，它的定义可以用多种编程语言来实现，其中最为常见的就是C语言。

本文将着重介绍C语言的链表定义。

第一步：首先，我们需要定义一个链表节点的结构体，用来存储链表中每个节点的数据信息以及指向下一个节点的指针。

具体代码如下所示：```struct ListNode {int val;struct ListNode *next;};```在这个结构体中，我们定义了两个成员变量，一个是表示节点值的val，一个是表示指向下一个节点的指针next。

其中，节点值可以是任意类型的数据，而指针next则是一个指向结构体类型的指针。

第二步：我们需要定义链表的头节点，通常会将头节点的指针定义为一个全局变量，方便在程序的不同部分中都能够访问。

这个头节点的作用是指向链表的第一个节点，同时也充当了哨兵节点的作用，使得链表的操作更加方便。

具体代码如下所示：```struct ListNode *list_head = NULL;```在这个全局变量中，我们定义了一个指向链表头节点的指针list_head，并将它初始化为NULL，表示目前链表为空。

第三步：链表的基本操作主要包括创建、插入、删除和遍历等。

我们将逐一介绍它们的定义方法。

1. 创建链表创建链表时，我们需要动态地分配内存，以保证每个节点的空间都是连续的而不会被覆盖。

具体代码如下所示：```struct ListNode *create_list(int arr[], int n) {struct ListNode *head = NULL, *tail = NULL;for (int i = 0; i < n; i++) {struct ListNode *node = (struct ListNode*)malloc(sizeof(struct ListNode));node->val = arr[i];node->next = NULL;if (head == NULL) {head = node;tail = node;} else {tail->next = node;tail = node;}}return head;}```在这个代码中，我们首先定义了链表的头节点head和尾节点tail，并将它们初始化为空。

循环单链表定义初始化及创建（C语言）

循环单链表定义初始化及创建（C语⾔）#include <stdio.h>#include <stdlib.h>/*** 含头节点循环单链表定义，初始化及创建*/#define OK 1;#define ERROR 0;//函数返回类型，表⽰函数运⾏结果的状态typedef int Status;//定义数据元素类型typedef char ElemType;//循环单链表定义typedef struct LoopLnode {ElemType data; //数据域，这⾥是char类型变量struct LoopLnode *next; //指针域，结构体类型指针} LoopLnode, *LoopLinkList;//循环单链表初始化Status InitList(LoopLinkList *list) {(*list)=(LoopLinkList)malloc(sizeof(LoopLnode));(*list)->next=(*list);(*list)->data='T'; //测试⽤，可不写return OK;}//1."头插法"创建仅含"头指针"的单向循环链表Status CreateList_H(LoopLinkList *list,ElemType arrData[],int length){int j;for(j=length-1;j>=0;j--){//新建结点LoopLnode *node;node=(LoopLnode*)malloc(sizeof(LoopLnode));node->data=arrData[j];node->next=NULL;//插⼊循环链表node->next=(*list)->next;(*list)->next=node; //list始终指向头结点}return OK;}//2."尾插法"创建仅含"头指针"的单向循环链表Status CreateList_R(LoopLinkList *list,ElemType arrData[],int length){LoopLnode *r;r=*list;int j;for(j=0;j<length;j++) {//新建结点LoopLnode *node;node=(LoopLnode*)malloc(sizeof(LoopLnode));node->data=arrData[j];node->next=NULL;//插⼊循环链表node->next=r->next;r=node;}return OK;}//3."头插法"创建仅含"尾指针"的单向循环链表Status BuildList_H(LoopLinkList *list,ElemType arrData[],int length){int j;for(j=length-1;j>=0;j--){//新建结点LoopLnode *node;node=(LoopLnode*)malloc(sizeof(LoopLnode));node->data=arrData[j];node->next=NULL;//node插⼊1号结点,list为尾指针node->next=(*list)->next->next; //node->next=头结点->nextif((*list)->next==(*list)) (*list)=node; //当只有头结点时(插⼊第⼀个结点时，⼿动设置node为尾指针)(*list)->next->next=node; //头结点->next=node;}return OK;}//4."尾插法"创建仅含"尾指针"的单向循环链表Status BuildList_R(LoopLinkList *list,ElemType arrData[],int length) {int j;for(j=0;j<length;j++) {//新建结点LoopLnode *node;node=(LoopLnode*)malloc(sizeof(LoopLnode));node->data=arrData[j];node->next=NULL;node->next=(*list)->next; //node->next=头结点(*list) = node; //尾指针 —> node}return OK;}int main(void){//产⽣待插⼊到链表的数据ElemType data1='A',data2='B',data3='C';ElemType waitInserted[]={data1,data2,data3,};//获得数组长度int arrLength=sizeof(waitInserted)/sizeof(waitInserted[0]);/**1.头插法建⽴只含头指针循环单链表**///定义链表并初始化LoopLinkList list1;InitList(&list1);//按既定数据建⽴链表CreateList_H(&list1,waitInserted,arrLength);//测试printf("%c\n",list1->next->next->next->next->next->next->data); //B/**2.尾插法建⽴只含头指针循环单链表**///定义链表并初始化LoopLinkList list2;InitList(&list2);//按既定数据建⽴链表CreateList_R(&list2,waitInserted,arrLength);//测试printf("%c\n",list1->next->next->next->next->next->next->data); //B/**3.头插法建⽴只含尾指针循环单链表**///定义链表并初始化LoopLinkList list3;InitList(&list3);//按既定数据建⽴链表BuildList_H(&list3,waitInserted,arrLength); //list3指向表尾//测试printf("%c\n",list3->next->next->next->next->next->next->next->next->next->data); //T/**4.尾插法建⽴只含尾指针循环单链表**///定义链表并初始化LoopLinkList list4;InitList(&list4);//按既定数据建⽴链表BuildList_H(&list4,waitInserted,arrLength); //list4指向表尾//测试printf("%c\n",list4->next->next->next->next->next->next->next->next->next->next->data); //A printf("\nEND!");return0;}。

VC++程序设计链表与链表的基本操作

产生下一个结点链表尾要输出链表首先要知道链表头的地址然后用一个指针指向第一个结点输出该结点的数据成员pnum和pscore再使p指向下一结点再输出直到链表的尾结点pnextnull
VC++程序设计链表与链表的基本操作
简单链表
链表是一种动态地进行存储分配的结构。最简单的链表称为单向链表，如图所示： Head
初始 p1=head;
$7.7.4 对链表的插入操作
设已有的链表中各结点的成员是按学号由小到大顺序排列的。
p1
head p2
11041 89
11043 90
11047 85 NULL
p0
89102
初始 p1=p2=head; p0=&stud;
p1
head
p2 p0
11041 89 89102
11043 90
1249
1249
A 1356
1356
B 1475
1475
C 1021
1021
D NULL
特点： 1。头指针变量head, 它存放一个地址，用于指向一个元素。链表中的一个元素称为结点。 2。每个结点至少应包含两个部分：一为用户需要的实际数据二为下一个结点的地址。 3。“表尾” 的地址部分放一个“Null”（表示“空地址”）表示链表的最后一个元素，该元素不再指向其它元素。
//插入结点的函数insert如下：
student *insert(student *head, student *stud) { student *p0,*p1,*p2; p1=head; p0=stud; if(head==Null) //原为空链表 { head=p0; p0->next=Null; } else while((p0->num > p1->num)&&(p1->next != Null)) { //查找插入位置 p2=p1; p1=p1->next; };

数据结构c++顺序表、单链表的基本操作,查找、排序代码

实验1：顺序表的基本操作实验2：单链表的基本操作实验3：查找实验4：排序实验1代码及结果：#include <iostream>using namespace std;template <class T>class sq_LList{private:int mm;int nn;T *v;public:sq_LList(){mm=0;nn=0;return;}sq_LList(int);void prt_sq_LList();int flag_sq_LList();void ins_sq_LList(int,T);void del_sq_LList(int);};//建立空顺序表template <class T>sq_LList<T>::sq_LList(int m){mm=m;v=new T[mm];nn=0;return;}//顺序输出顺序表中的元素与顺序表长度template <class T>void sq_LList<T>::prt_sq_LList(){int i;cout<<"nn="<<nn<<endl;for(i=0;i<nn;i++)cout<<v[i]<<endl; return;}//检测顺序表的状态template <class T>int sq_LList<T>::flag_sq_LList(){if(nn=mn)return(-1);if(nn=0)return(0);return (1);}//在表的指定元素前插入新元素template<class T>void sq_LList<T>::ins_sq_LList(int i,T b){int k;if(nn==mm){cout<<"overflow"<<endl;return;}if(i>nn)i=nn+1;if(i<1)i=1;for(k=nn;k>=i;k--)v[k]=v[k-1];v[i-1]=b;nn=nn+1;return ;}//在顺序表中删除指定元素template<class T>void sq_LList<T>::del_sq_LList(int i){int k;if(nn==0){cout<<"underflow!"<<endl;return;}for(k=i;k<nn;k++)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;}运行及结果：实验2代码#include<iostream>#include<iomanip>using namespace std;struct node{float data;node *next;};node *create(){ //建立单链表node *head,*p,*s;head=new node;p=head;p->data=0;p->next=0; //表头创建完成float newnum=0;cin>>newnum;if(newnum<0){cout<<"未输入数据...\n";//输入负数则结束system("pause");}while(newnum>=0 ){ //??如何用字符型作为结束标志s=new node; //创建表中数据s->data=newnum;p->next=s;p=s;cin>>newnum;}p->next=NULL; //最后元素指针return(head); //返回空表头}//插入一个结点x，将成为第i个节点void insertnode(node *head,int i,float x){node *s,*p;int j;s=new node;s->data=x;p=head;j=1; //查找第i个结点，由p指向while(p!=NULL && j<i){j++;p=p->next;}s->next=p->next;p->next=s;}//删除结点xvoid deletenode(node *head,float x){node *p,*s;if(head->next==NULL)cout<<"这是空链表,不能执行删除操作\n"; else{s=head;p=head->next;while(p!=NULL && p->data!=x)if(p->data!=x){s=p;p=p->next;}if(p!=NULL){s->next=p->next;delete(p);}else cout<<"未找到!\n";}}//存取链表某节点Kvoid read(node*head,int k){while(head->next!=0&&k>0){head=head->next;k--;}cout<<"该处数据为"<<head->data<<".\n\n"; }int main( ) {node *linktable=0;int choice=1;cout<<"1.创建链表\n";cout<<"2.显示信息\n";cout<<"3.删除信息\n";cout<<"4.查找信息\n";cout<<"5.插入信息\n";cout<<"6.读取信息\n";cout<<"0.退出程序\n";cout<<"请输入您的选择：";cin>>choice;while(1){switch (choice){case 0: exit(0);case 1:{cout<<"输入正数数据，并以负数作为结束标记\n";linktable=create();break;}case 2:{cout<<"链表长度为"<<length(linktable)<<",详细信息：\n";printlist(linktable);break;}case 3:{cout<<"要删除的数据为？\n";float del;cin>>del;deletenode(linktable,del);break;}case 4:{if(linktable->next==0)cout<<"链表为空，不能查找\n";else{cout<<"要查找数据为?";float search;cin>>search;find(linktable,search);} break;}case 5:{cout<<"存储数据为？";int des;float it;cin>>it;cout<<"想让该数据存储为第几个节点？";cin>>des;if((des>(length(linktable)+1)||des<1))cout<<"输入错误\n";elseinsertnode(linktable,des,it);break;}case 6:{cout<<"想读取第几个节点？";int c;cin>>c;if(c<1||c>length(linktable))cout<<"位置不合法\n";elseread(linktable,c);break;}default :cout<<"输入错误!\n";}system("pause");system("cls");cout<<"当前信息：\n";printlist(linktable);cout<<"\n1.创建链表\n";cout<<"2.显示信息\n";cout<<"3.删除信息\n";cout<<"4.查找信息\n";cout<<"5.插入信息\n";cout<<"6.读取信息\n";cout<<"0.退出程序\n";cout<<"继续选择：\n";cin>>choice;}return 0;}实验三查找实验名称：实验3 查找实验目的：掌握顺序表和有序表的查找方法及算法实现；掌握二叉排序树和哈希表的构造和查找方法。

单链表的基本操作代码

单链表的基本操作代码单链表是一种常用的数据结构，它具有优秀的插入和删除性能，在数据存储和处理方面具有广泛的应用。

单链表的基本操作包含创建链表、插入节点、删除节点、查找节点等，下面是单链表的基本操作代码：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;}单链表的基本操作是数据结构中最基础的部分，掌握好这些代码对于往后的学习和应用都会有很大的帮助。

c语言单链表基本操作

prevNode->next = currentNode->next; } free(currentNode); // 释放内存 } } ```
c语言单链表基本操作
5. 查找节点：
```c struct Node* searchNode(struct Node* head, int data) {
c语言单链表基本操作
4. 删除节点：
```c void deleteNode(struct Node** head, int data) {
struct Node* currentNode = *head; struct Node* prevNode = NULL;
// 遍历链表，找到要删除的节点 while (currentNode != NULL && currentNode->data != data) {
c语言单链表基本操作
这些是单链表的基本操作，可以根据需要进行调用和组合，实现对链表的创建、插入、删除、查找和打印等操作。需要注意的是，在使用完链表后，要记得释放节点所占用的内存，避免内存泄漏。
struct Node* currentNode = head; while (currentNode != NULL && currentNode->data != data) {
currentNode = currentNode->next; } return currentNode; // 返回找到的节点（如果找到） } ```
c语言单链表基本操作
2. 创建链表： ```c struct Node* createLinkedList() {
return NULL; // 返回一个空链表 }

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

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

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

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

c语言单链表的实现

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

在C语言中，我们可以通过定义结构体和指针来实现单链表的操作。

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

假设我们需要实现一个存储整数的单链表，可以定义如下结构体：```cstruct Node {int data;struct Node* next;};```接下来，我们可以定义一些基本的操作函数，例如创建链表、插入节点、删除节点、查找节点等。

下面我们逐一介绍这些操作函数的实现方法。

1. 创建链表创建链表需要分配内存，并设置头节点的指针为空。

代码如下：```cstruct Node* createList() {struct Node* head = (struct Node*)malloc(sizeof(struct Node));head->next = NULL;return head;}```2. 插入节点插入节点需要找到要插入位置的前一个节点，然后进行插入操作。

代码如下：```cvoid insertNode(struct Node* head, int data, int position) {struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));newNode->data = data;struct Node* temp = head;for (int i = 0; i < position - 1; i++) {temp = temp->next;}newNode->next = temp->next;temp->next = newNode;}```3. 删除节点删除节点需要找到要删除节点的前一个节点，然后进行删除操作。

单链表的创建和基本操作C语言

单链表的创建和基本操作C语⾔创建单链表，⾸先要建⽴⼀个结构体，如下：#include<stdio.h>#include<stdlib.h>typedef int ElemType;typedef struct Lnode{ElemType data;struct Lnode *next;}Lnode,*LinkList;创建链表，这⾥使⽤的是尾插法建⽴链表，它主要是在表尾不断地添加新元素，直到输⼊-1，然后退出。

LinkList CreatList()//创建列表{ElemType x;LinkList head,p,tail;head=(LinkList)malloc(sizeof(Lnode));head->next=NULL;tail=head;scanf("%d",&x);while(x!=-1){p=(LinkList)malloc(sizeof(Lnode));p->data=x;p->next=NULL;tail->next=p;tail=p;scanf("%d",&x);}return head;}计算表长，运⽤遍历，将链表的长度利⽤⼀个变量存储，然后有指针存储。

int LongList(LinkList head,int* length)//计算表长第⼀个元素列表第⼆个存储表长{LinkList p;p=(LinkList)malloc(sizeof(Lnode));p=head->next;if(p==NULL){return0;}int i=1;while(p){p=p->next;i++;}*length=i-1;//因为每次先查询后⾯的元素，所以i也把最后⼀个NULL加了进去，所以要减⼀return1;}插⼊元素，单链表插⼊元素，需要知道该位置的链表元素，然后先将插⼊元素的尾部连接到链表内，再将该节点的头部接⼊。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

{
p=p->next;
j++;
}
if(i==j)return p;
else return NULL;
}
linklist *LOCATE(Link l,int m)
{
p=l->next;
while(p!=NULL)
if(p->data!=m)
p=p->next;
else {printf("%d",p->data);break;}
return p;
}
int INSERTAFTER(Link l,int x)
{
linklist *s;
p=l;
s=(linklist*)malloc(sizeof(linklist));
s->data=x;
{datatype data;
struct node *next;
}linklist,*Link;
linklist *head,*p;
int InitList(Link *L) //初始化单链表
{
*L=(Link)malloc(sizeof(linklist));
(*L)->next=NULL;
s=s->next;
}
printf("\n");
return 0;
}
int main()
{
Link l;
int k;
InitList(&l);
printf("please xuanze 1 to 6");
printf("\n");
scanf("%d",&k);
r=s;
ch=getchar();
}
r->next=NULL;
return 0;
}
linklist *GET(Link l,int i)
{ linklist *p;
int j;
if(i<0)return NULL;
p=l;
j=0;
while((p->next !=NULL)&&(j<i))

{
case 1:CREATLISTF(l);break;//头插入
case 2:CREATLISTR(l);break;//尾插入
case 3:GET(l,3); p=GET(l,3);printf("%c",p->data);PrintList(l);break;
case 4:LOCATE(l,3);PrintList(l);break;
case 5:INSERTAFTER(l,9);PrintList(l);break;
case 0:;default:return 1;
}
printf("继续请输入K");
scanf("%d",&k);
s->next=p->next;
p->next=s;printf("%d",s->data);
return 0;
}
int PrintList( Link l)
{
linklist *s;
s=l->next;
while(s!=NULL)
{
printf("%d ",s->data);
s->data=ch;
s->next=l->next;
l->next=s;
ch=getchar();
}
return 0;
}
linklist *CREATLISTR(Link l)
{
char ch;
linklist *s,*r;
head=(linklist*)malloc(sizeof(linklist));
}
return 0;
}
/*单链表的建立和基本的操作*/
#include"stdio.h"
#include"string.h"
#include"iostream.h"
#include"malloc.h"
#include<stdlib.h>
typedef int datatype;
typedef struct node
r=head;
printf("qing yi ci shuru jiedianshuju\n");
ch=getchar();
while(ch!='$')
{
s=(linklist*)malloc(sizeof(linklist));
s->data=ch;
r->next=s;
return 0;
}
linklist *CREATLISTF(Link l)//头插法建表
{
char ch;
linklist *s;
head=NULL;
printf("qingshuru shuju");
ch=getchar();
while(ch!='$')
{
s=(linklist*)malloc(sizeof(linklist));