单链表各种操作详解

#include "stdio.h"
#include "stdlib.h"#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0#define MAXSIZE 20 /* 存储空间初始分配量 */typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType;/* ElemType类型根据实际情况而定，这里假设为int */typedef struct Node
{ElemType data;struct Node *next;
}Node;
/* 定义LinkList */
typedef struct Node *LinkList;/* 初始化顺序线性表 */
Status InitList(LinkList *L)
{*L=(LinkList)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点 */if(!(*L)) /* 存储分配失败 */{return ERROR;}(*L)->next=NULL; /* 指针域为空 */return OK;
}/* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(LinkList L)
{int i=0;LinkList p=L->next; /* p指向第一个结点 */while(p){i++;p=p->next;}return i;
}/* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
Status ClearList(LinkList *L)
{LinkList p,q;p=(*L)->next;           /*  p指向第一个结点 */while(p)                /*  没到表尾 */{q=p->next;free(p);p=q;}(*L)->next=NULL;        /* 头结点指针域为空 */return OK;
}/* 初始条件：顺序线性表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status ListTraverse(LinkList L)
{LinkList p=L->next;while(p){visit(p->data);p=p->next;}printf("\n");return OK;
}/* 初始条件：顺序线性表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status ListTraverseLimit(LinkList L, int n)
{int i = 0;LinkList p=L->next;while(p && i < n){visit(p->data);p=p->next;i++;}printf("\n只显示 %d 个\n", n);return OK;
}Status visit(ElemType c)
{printf("-> %d ",c);return OK;
}/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值 */
Status GetElem(LinkList L,int i,ElemType *e)
{int j;LinkList p;		/* 声明一结点p */p = L->next;		/* 让p指向链表L的第一个结点 */j = 1;		/*  j为计数器 */while (p && j < i)  /* p不为空或者计数器j还没有等于i时，循环继续 */{p = p->next;  /* 让p指向下一个结点 */++j;}if ( !p || j>i )return ERROR;  /*  第i个元素不存在 */*e = p->data;   /*  取第i个元素的数据 */return OK;
}/* 初始条件：顺序线性表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
int LocateElem(LinkList L,ElemType e)
{int i=0;LinkList p=L->next;while(p){i++;if(p->data==e) /* 找到这样的数据元素 */return i;p=p->next;}return 0;
}/*  随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */
void CreateListHead(LinkList *L, int n)
{LinkList p;int i;srand(time(0));                         /* 初始化随机数种子 */*L = (LinkList)malloc(sizeof(Node));(*L)->next = NULL;                      /*  先建立一个带头结点的单链表 */for (i=0; i < n; i++){p = (LinkList)malloc(sizeof(Node)); /*  生成新结点 */p->data = rand()%100+1;             /*  随机生成100以内的数字 */p->next = (*L)->next;(*L)->next = p;						/*  插入到表头 */}
}/*  随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法） */
void CreateListTail(LinkList *L, int n)
{LinkList p,r;int i;srand(time(0));                      /* 初始化随机数种子 */*L = (LinkList)malloc(sizeof(Node)); /* L为整个线性表 */r=*L;                                /* r为指向尾部的结点 */for (i=0; i < n; i++){p = (Node *)malloc(sizeof(Node)); /*  生成新结点 */p->data = rand()%100+1;           /*  随机生成100以内的数字 */r->next=p;                        /* 将表尾终端结点的指针指向新结点 */r = p;                            /* 将当前的新结点定义为表尾终端结点 */}r->next = NULL;                       /* 表示当前链表结束 */
}/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(LinkList *L,int i,ElemType e)
{int j;LinkList p,s;p = *L;     /* 声明一个结点 p，指向头结点 */j = 1;while (p && j < i)     /* 寻找第i个结点 */{p = p->next;++j;}if (!p || j > i)return ERROR;   /* 第i个元素不存在 */s = (LinkList)malloc(sizeof(Node));  /*  生成新结点(C语言标准函数) */s->data = e;s->next = p->next;      /* 将p的后继结点赋值给s的后继  */p->next = s;          /* 将s赋值给p的后继 */return OK;
}/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(LinkList *L,int i,ElemType *e)
{int j;LinkList p,q;p = *L;j = 1;while (p->next && j < i)	/* 遍历寻找第i个元素 */{p = p->next;++j;}if (!(p->next) || j > i)return ERROR;           /* 第i个元素不存在 */q = p->next;p->next = q->next;			/* 将q的后继赋值给p的后继 */*e = q->data;               /* 将q结点中的数据给e */free(q);                    /* 让系统回收此结点，释放内存 */return OK;
}/* 单链表反转/逆序 */
LinkList ListReverse(LinkList L)
{LinkList current,pnext,prev;if(L == NULL || L->next == NULL)return L;current = L->next;  /* p1指向链表头节点的下一个节点 */pnext = current->next;current->next = NULL;while(pnext){prev = pnext->next;pnext->next = current;current = pnext;pnext = prev;}//printf("current = %d,next = %d \n",current->data,current->next->data);L->next = current;  /* 将链表头节点指向p1 */return L;
}LinkList ListReverse2(LinkList L)
{LinkList current, p;if (L == NULL){return NULL;}current = L->next;while (current->next != NULL){p = current->next;current->next = p->next;p->next = L->next;L->next = p;ListTraverse(L);printf("current = %d, \n", current -> data);}return L;
}LinkList ListReverse3(LinkList L)
{LinkList newList;    //新链表的头结点LinkList tmp;       //指向L的第一个结点，也就是要摘除的结点//参数为空或者内存分配失败则返回NULLif (L == NULL || (newList = (LinkList)malloc(sizeof(Node))) == NULL){return ERROR;}//初始化newListnewList->data = L->data;newList->next = NULL;//依次将L的第一个结点放到newList的第一个结点位置while (L->next != NULL){tmp = newList->next;         //保存newList中的后续结点newList->next = L->next;       //将L的第一个结点放到newList中L->next = L->next->next;     //从L中摘除这个结点newList->next->next = tmp;        //恢复newList中后续结点的指针}//原头结点应该释放掉，并返回新头结点的指针free(L);return newList;
}// 获取单链表倒数第N个结点值
Status GetNthNodeFromBack(LinkList L, int n, ElemType *e)
{int i = 0;LinkList firstNode = L;while (i < n && firstNode->next != NULL){//正数N个节点，firstNode指向正的第N个节点i++;firstNode = firstNode->next;printf("%d\n", i);}if (firstNode->next == NULL && i < n - 1){//当节点数量少于N个时，返回NULLprintf("超出链表长度\n");return ERROR;}LinkList secNode = L;while (firstNode != NULL){//查找倒数第N个元素secNode = secNode->next;firstNode = firstNode->next;//printf("secNode:%d\n", secNode->data);//printf("firstNode:%d\n", firstNode->data);}*e = secNode->data;return OK;
}// 找到链表的中间节点
Status GetMidNode(LinkList L, ElemType *e) {LinkList search, mid;mid = search = L;while (search->next != NULL){//search移动的速度是 mid 的2倍if (search->next->next != NULL){search = search->next->next;mid = mid->next;//printf("search %d\n", search->data);//printf("mid %d\n", mid->data);}else{search = search->next;}}*e = mid->data;return OK;
}int HasLoop(LinkList L)
{int step1 = 1;int step2 = 2;LinkList p = L;LinkList q = L;//while (p != NULL && q != NULL && q->next == NULL)while (p != NULL && q != NULL && q->next != NULL){p = p->next;if (q->next != NULL)q = q->next->next;printf("p:%d, q:%d \n", p->data, q->data);if (p == q)return 1;}return 0;
}int HasLoop2(LinkList L)
{int step1 = 1;int step2 = 2;LinkList p = L;LinkList q = L;while (p != NULL && q != NULL && q->next != NULL){p = p->next;if (q->next != NULL)q = q->next->next;printf("p:%d, q:%d \n", p->data, q->data);if (p == q)return 1;}return 0;
}Status BulidListLoop(LinkList *L, int num)
{int i = 0;LinkList cur = *L;LinkList tail = NULL;if(num <= 0 || L == NULL){return ERROR;}for(i = 1; i < num; ++i){if(cur == NULL){return ERROR;}cur = cur->next;}tail = cur;while(tail->next){tail = tail->next;}tail->next = cur;return OK;
}LinkList RemoveDupNode(LinkList L)//删除重复结点的算法
{LinkList p,q,r;p=L->next;while(p)    // p用于遍历链表{q=p;while(q->next) // q遍历p后面的结点，并与p数值比较{if(q->next->data==p->data){r=q->next; // r保存需要删掉的结点q->next=r->next;   // 需要删掉的结点的前后结点相接free(r);}elseq=q->next;}p=p->next;}return L;
}int main()
{LinkList L;Status i;int j,k,pos,value;int opp;ElemType e;i=InitList(&L);printf("链表L初始化完毕，ListLength(L)=%d\n",ListLength(L));printf("\n1.整表创建（头插法） \n2.整表创建（尾插法） \n3.遍历操作 \n4.插入操作");printf("\n5.删除操作 \n6.获取结点数据 \n7.查找某个数是否在链表中 \n8.置空链表");printf("\n9.链表反转逆序 \n10.求链表倒数第N个数 \n11.找到链表的中间结点 \n12.判断链表是否有环");printf("\n13.链表建环 ");printf("\n14.链表去重 ");printf("\n0.退出 \n请选择你的操作：\n");while(opp != '0'){scanf("%d",&opp);switch(opp){case 1:CreateListHead(&L,10);printf("整体创建L的元素(头插法)：\n");ListTraverse(L);printf("\n");break;case 2:CreateListTail(&L,10);printf("整体创建L的元素(尾插法)：\n");ListTraverse(L);printf("\n");break;case 3:ListTraverse(L);printf("\n");break;case 4:printf("要在第几个位置插入元素？");scanf("%d",&pos);printf("插入的元素值是多少？");scanf("%d",&value);ListInsert(&L,pos,value);ListTraverse(L);printf("\n");break;case 5:printf("要删除第几个元素？");scanf("%d",&pos);ListDelete(&L,pos,&e);printf("删除第%d个元素成功，现在链表为：\n", pos);ListTraverse(L);printf("\n");break;case 6:printf("你需要获取第几个元素？");scanf("%d",&pos);GetElem(L,pos,&e);printf("第%d个元素的值为：%d\n", pos, e);printf("\n");break;case 7:printf("输入你需要查找的数：");scanf("%d",&pos);k=LocateElem(L,pos);if(k)printf("第%d个元素的值为%d\n",k,pos);elseprintf("没有值为%d的元素\n",pos);printf("\n");break;case 8:i=ClearList(&L);printf("\n清空L后：ListLength(L)=%d\n",ListLength(L));ListTraverse(L);printf("\n");break;case 9:ListReverse2(L);//L=ListReverse3(L);printf("\n反转L后\n");ListTraverse(L);printf("\n");break;case 10:printf("你要查找倒数第几个结点的值？");scanf("%d", &value);GetNthNodeFromBack(L,value,&e);printf("倒数第%d个元素的值为：%d\n", value, e);printf("\n");break;case 11:GetMidNode(L, &e);printf("链表中间结点的值为：%d\n", e);printf("\n");break;case 12:if( HasLoop(L) ){printf("方法一: 链表有环\n");}else{printf("方法一: 链表无环\n");}if( HasLoop2(L) ){printf("方法二: 链表有环\n");}else{printf("方法二: 链表无环\n");}printf("\n");break;case 13:printf("你要在哪个位置开始建环？");scanf("%d", &pos);BulidListLoop(&L, pos);ListTraverseLimit(L, 20);printf("\n");break;case 14:RemoveDupNode(L);ListTraverse(L);printf("\n");break;case 0:exit(0);}}}

延伸阅读

此文章所在专题列表如下：

  1. 第01话：线性表的概念与定义
  2. 第02话：线性表的抽象数据类型ADT定义
  3. 第03话：线性表的顺序存储结构
  4. 第04话：线性表的初始化
  5. 第05话：线性表的遍历、插入操作
  6. 第06话：判断线性表是否为空与置空操作
  7. 第07话：线性表的查找操作
  8. 第08话：线性表删除某个元素
  9. 线性表顺序存储的优缺点
  10. 线性表链式存储结构的由来与基本概念
  11. 单链表的头指针、头结点与首元结点
  12. 单链表的结构体定义与声明
  13. 单链表的初始化
  14. 单链表的插入与遍历操作
  15. 单链表的删除某个元素的操作
  16. 获取单链表中的指定位置的元素
  17. 查找某数在单链表中的位置
  18. 用头插法实现单链表整表创建
  19. 用尾插法实现单链表整表创建
  20. 将单链表重置为空表
  21. 单链表反转/逆序的两种方法
  22. 单链表反转/逆序的第三种方法
  23. 求单链表倒数第N个数
  24. 用标尺法快速找到单链表的中间结点
  25. 如何判断链表是否有环的存在
  26. 单链表建环，无环链表变有环
  27. 删除单链表中的重复元素


本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/383697.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Linux系统【五】进程间通信-共享内存mmap

Linux系统【五】进程间通信-共享内存mmap

mmap函数 #include <sys/mman.h> void *mmap(void *addr, size_t length, int prot, int flags,int fd, off_t offset);参数&#xff1a; void *addr建立映射区的首地址&#xff0c;由Linux内核指定&#xff0c;所以我们直接传递NULL。也就是说虽然这是一个参宿但是并不…
阅读更多...
socket编程 -- epoll模型服务端/客户端通信的实现

socket编程 -- epoll模型服务端/客户端通信的实现

https://blog.csdn.net/y396397735/article/details/50680359 本例实现如下功能&#xff1a; 支持多客户端与一个服务端进行通信&#xff0c;客户端给服务端发送字符串数据&#xff0c;服务端将字符串中小写转为大写后发送回客户端&#xff0c;客户端打印输出经转换后的字符串。…
阅读更多...
Python3 面向对象程序设计

Python3 面向对象程序设计

类的定义 Python使用class关键字来定义类 class Car:def infor(self):print("This is a car") car Car() car.infor()内置方法isinstance()来测试一个对象是否为某个类的实例 self参数 类的 所有实例方法都有一个默认的self参数&#xff0c;并且必须是方法的第一…
阅读更多...
计算机网络【二】物理层基础知识

计算机网络【二】物理层基础知识

计算机网络的性能 速率&#xff1a;连接在计算机网络上的主机在数字信道上传送数据位数的速率&#xff0c;也成为data rate 或bit rate&#xff0c;单位是b/s,kb/s,Mb/s,Gb/s。 我们平时所讲的宽带的速度是以字为单位的&#xff0c;但是实际中应用一般显示的是字节 &#xff0…
阅读更多...
Linux网络编程——tcp并发服务器（多进程）

Linux网络编程——tcp并发服务器（多进程）

https://blog.csdn.net/lianghe_work/article/details/46503895一、tcp并发服务器概述一个好的服务器,一般都是并发服务器&#xff08;同一时刻可以响应多个客户端的请求&#xff09;。并发服务器设计技术一般有&#xff1a;多进程服务器、多线程服务器、I/O复用服务器等。二、…
阅读更多...
求序列第K大算法总结

求序列第K大算法总结

参考博客&#xff1a;传送门 在上面的博客中介绍了求序列第K大的几种算法&#xff0c;感觉收益良多&#xff0c;其中最精巧的还是利用快速排序的思想O(n)查询的算法。仔细学习以后我将其中的几个实现了一下。 解法 1&#xff1a; 将乱序数组从大到小进行排序然后取出前K大&a…
阅读更多...
Linux网络编程——tcp并发服务器（多线程）

Linux网络编程——tcp并发服务器（多线程）

https://blog.csdn.net/lianghe_work/article/details/46504243tcp多线程并发服务器多线程服务器是对多进程服务器的改进&#xff0c;由于多进程服务器在创建进程时要消耗较大的系统资源&#xff0c;所以用线程来取代进程&#xff0c;这样服务处理程序可以较快的创建。据统计&a…
阅读更多...
计算机网络【三】物理层数据通信

计算机网络【三】物理层数据通信

物理层传输媒介 导向传输媒体&#xff0c;比如光纤和铜线 双绞线&#xff08;屏蔽双绞线STP 五屏蔽双绞线UTP&#xff09;电线扭曲在一起可以降低互相之间的电磁干扰 同轴电缆 (50欧姆的基带同轴电缆&#xff0c;75欧姆的宽带同轴电缆) 10M和100M网络只使用了四根线&#xf…
阅读更多...
02_算法分析

02_算法分析

02_算法分析 0.1 算法的时间复杂度分析0.1.1 函数渐近增长概念&#xff1a;输入规模n>2时&#xff0c;算法A1的渐近增长小于算法B1 的渐近增长随着输入规模的增大&#xff0c;算法的常数操作可以忽略不计测试二&#xff1a;随着输入规模的增大&#xff0c;与最高次项相乘的常…
阅读更多...
Linux网络编程——I/O复用之select详解

Linux网络编程——I/O复用之select详解

https://blog.csdn.net/lianghe_work/article/details/46506143一、I/O复用概述I/O复用概念&#xff1a;解决进程或线程阻塞到某个 I/O 系统调用而出现的技术&#xff0c;使进程不阻塞于某个特定的 I/O 系统调I/O复用使用的场合&#xff1a;1.当客户处理多个描述符&#xff08;…
阅读更多...
Linux多进程拷贝文件

Linux多进程拷贝文件

学习了mmap以后&#xff0c;实现一个简单的小程序&#xff0c;进行多个进程对一个文件进行拷贝。 Linux　mmap共享内存学习可以参考我的另一篇博客&#xff1a;传送门 实现思想 我们可以将原来的文件利用mmap分成多个段分别进行传输。 实现代码 #include<stdio.h> #…
阅读更多...
斐波那契查找(Fibonacci Search)和折半查找

斐波那契查找(Fibonacci Search)和折半查找

两个查找算法都是针对有序数组进行查找&#xff0c;不同点在于分界点的取值不同。 算法介绍 折半查找很简单&#xff0c;每次与当前区间的中点进行比较&#xff0c;然后决定查找前一部分还是后一部分。 Fibonacci查找利用了Fibonacci序列每一项等于前两项和的特点进行划分&a…
阅读更多...
Linux网络编程——tcp并发服务器（I/O复用之select）

Linux网络编程——tcp并发服务器（I/O复用之select）

https://blog.csdn.net/lianghe_work/article/details/46519633与多线程、多进程相比&#xff0c;I/O复用最大的优势是系统开销小&#xff0c;系统不需要建立新的进程或者线程&#xff0c;也不必维护这些线程和进程。代码示例&#xff1a;#include <stdio.h> #include &l…
阅读更多...
SQL server 2008下载+安装详细

SQL server 2008下载+安装详细

教程博客&#xff1a;传送门
阅读更多...
操作系统【二】死锁问题以及处理方法

操作系统【二】死锁问题以及处理方法

死锁的概念 死锁&#xff1a;在并发环境下&#xff0c;个进程因为竞争资源而造成的一种互相等待对方手里的资源&#xff0c;导致各进程都阻塞&#xff0c;无法向前推进的现象。 区别&#xff1a; 饥饿&#xff1a;由于长期得不到想要的资源进程无法向前推进的现象。死循环&a…
阅读更多...
Linux网络编程——I/O复用之poll函数

Linux网络编程——I/O复用之poll函数

https://blog.csdn.net/lianghe_work/article/details/46534029一、回顾前面的selectselect优点&#xff1a;目前几乎在所有的平台上支持&#xff0c;其良好跨平台支持也是它的一个优点select缺点&#xff1a;1.每次调用 select()&#xff0c;都需要把 fd 集合从用户态拷贝到内…
阅读更多...
操作系统【一】进程同步和信号量

操作系统【一】进程同步和信号量

基本概念 进程异步性特征&#xff1a;各并发执行的进程以各自独立的&#xff0c;不可预知的速度向前推进。 进程同步又称作直接制约关系&#xff0c;他是指为完成某种任务而建立的两个或者多个进程&#xff0c;这些进程因为需要在某些位置上协调他们的工作顺序而产生的制约关…
阅读更多...
计算机网络【四】数据链路层基本概念+点到点通信(PPP协议）

计算机网络【四】数据链路层基本概念+点到点通信(PPP协议）

数据链路层基本概念 路由器是网络层设备 数据链路层&#xff1a;数据管道&#xff0c;传输的是数据包加上发送地址&#xff0c;接收地址&#xff0c;校验的数据帧 数据链路层的信道类型&#xff1a; 点到点信道&#xff1a;使用一对一的点到点通信方式&#xff08;两个设备…
阅读更多...
Linux网络编程——tcp并发服务器（poll实现）

Linux网络编程——tcp并发服务器（poll实现）

https://blog.csdn.net/lianghe_work/article/details/46535859想详细彻底地了解poll或看懂下面的代码请参考《Linux网络编程——I/O复用之poll函数》 代码&#xff1a;#include <string.h>#include <stdio.h>#include <stdlib.h>#include <unistd.h>#…
阅读更多...
二分查找的最大比较次数

二分查找的最大比较次数

二分查找很简单&#xff0c;可是对于一个区间长度为n的数组&#xff0c;最大的比较次数为多少呢&#xff1f; 对于标准的二分查找&#xff0c;我们每次从区间[l,r)中取一个值&#xff0c;和中间值mid(lr)>>1进行比较&#xff0c;然后将数组分为[l,mid) [mid1,r)&#xf…
阅读更多...
最新文章

Copyright @ 2022~2023