数据结构关于单链表的一些操作的源代码

单链表的可以有许多问题,这是我特意整理一下的有关他的相关操作,给出代码,有需要的可以自己调试,重要的就是关于环的一些操作:

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <ctime>
using namespace std;
typedef int Elemtype;
typedef struct Node{
Elemtype data;
struct Node *next;
}Node,*Linklist;
void lengthList(Linklist &L){//求基础长度
Linklist p,q;
p=L->next;
while(p!=NULL){
L->data++;
p=p->next;
}
}
void createList(Linklist &L){//创造单链表
L=new Node;
Linklist p,q;
int x;
L->data=0;
q=L;
cin>>x;
while(x!=-999){
p=new Node;
p->data=x;
q->next=p;
q=p;
cout<<" if you want to continue to input some data,please don‘t input -999"<<endl;
cin>>x;
}
p->next=NULL;
lengthList(L);
}
void display(Linklist &L){//输出
Linklist p;
p=L->next;
while(p!=NULL){
cout<<p->data<<" ";
p=p->next;
}
cout<<endl;
}
void ReverseList(Linklist &L){//单链表反转/逆序
Linklist p,q;
display(L);
p=L->next->next;
L->next->next=NULL;
while(p!=NULL){
q=p;
p=p->next;
q->next=L->next;
L->next=q;
}
display(L);
}
void NIndex(Linklist &L){//求单链表倒数第N个数
int N;
cin>>N;//请输入倒数第几个
int d=L->data-N+1;
int i=1;
Linklist p=L->next;
while(i<d){
i++;
p=p->next;
}
cout<<p->data<<endl;
}
void middle(Linklist &L){//找到单链表的中间结点
// int d=L->data/2+1,i=1; //通过使用链表总长实现
// Linklist p;
// p=L->next;
// while(i<d){
// i++;
// p=p->next;
// }
// cout<<p->data<<endl;

Linklist p,q; //通过双指针实现
p=L->next;
q=L->next;
while(q->next!=NULL&&q->next->next!=NULL){
p=p->next;
q=q->next->next;
// if(q->next==NULL){
// break;
// }
}
cout<<p->data;

}
bool judgement(Linklist L){ //如何判断链表是否有环的存在
Linklist slow,fast;
slow=L->next;
fast=L->next->next;
while(slow!=fast){
slow=slow->next;
fast=fast->next->next;
if(fast->next==NULL||fast->next->next==NULL){
cout<<"没有环";
return false;
}

}
cout<<"有一个环";
return true;

}
void circle(Linklist &L,int a){//单链表建环,无环链表变有环
Linklist p,q;
p=L->next;
int i;
for( i=1;p->next!=NULL;i++){
if(i==a)
q=p;
p=p->next;
}
p->next=q;
}
void BulidListLoop(Linklist &L, int num){//单链表建环,无环链表变有环的另一种操作

int i = 0;
Linklist cur = L;
Linklist tail = NULL;
if(num <= 0 || L == NULL)
{
return ;
}
for(i = 1; i < num; ++i)
{
if(cur == NULL)
{

return ;
}
cur = cur->next;
}
tail = cur;
while(tail->next)

{

tail = tail->next;

}

tail->next = cur;

return ;

}
void lengthcircle(Linklist L){//如何知道环的长度?
Linklist slow,fast;
int i;
slow=L->next;
fast=L->next->next;
while(slow!=fast){
slow=slow->next;
fast=fast->next->next;
}
i=0;
slow=slow->next;
fast=fast->next->next;
while(slow!=fast){
i++;
slow=slow->next;
fast=fast->next->next;
}
cout<<i;
}
void deletereelem(Linklist &L){//删除单链表中的重复元素
Linklist p,q,r;
p=L->next;
while(p){
q=p->next;
r=p;
while(q){
if(p->data==q->data){
r->next=q->next;
delete q;
q=r;
}
else{
r=r->next;
}
q=q->next;
}
p=p->next;
}
p=NULL;

}
void findloopPort(Linklist &L){//给出环的入点方法1
Linklist slow,fast,f;
int i;
slow=L->next;
f=L;
fast=L->next->next;
while(slow!=fast){
slow=slow->next;
fast=fast->next->next;
}
while(f!=slow){
f=f->next;
slow=slow->next;
}
cout<<f->data;
}
void FindLoopPort(Linklist head){//给出环的入点方法2
Linklist slow = head,fast = head;
while ( fast && fast -> next )
{
slow = slow -> next;
fast = fast -> next -> next;
if ( slow == fast ) break ;
}
if (fast == NULL || fast -> next == NULL)
return ;
slow = head;
while (slow != fast)
{
slow = slow -> next;
fast = fast -> next;
}
cout<<slow->data;
}
//扩展问题:两个链表都不存在环,如果相交,给出相交的第一个点。
void judgeconnect(Linklist L1,Linklist L2){//判断两个链表是否相交,并求相交的点----方法一
Linklist p1,p2;
lengthList(L1);
lengthList(L2);
p1=L1->next;
p2=L2->next;
while(p1){
p1=p1->next;
}
while(p2){
p2=p2->next;
}
if(p2==p1){
cout<<"两个链表相交";
}
p1=L1->next;
p2=L2->next;
for(int i=1;i<(L1->data-L2->data);i++)//默认L1是长链,此处也可以比较一下
p1=p1->next;
while(p1!=p2){
p1=p1->next;
p2=p2->next;
}
cout<<p1->data;
}
void Judgecontact(Linklist L1,Linklist L2){//判断两个链表是否相交,并求相交的点----方法二
Linklist p1=L1->next;
while(p1){
p1=p1->next;
}
p1=L1->next;

if(judgement(L2)){
findloopPort(L2);
}
else
;
}
void lenghcircle(Linklist L2){//求链表的长度
//比较简单,就是把上面的求环的长度+上面给环入点时可以同时求出的入点到头指针的距离
}
int main()
{
Linklist L;
createList(L);
circle(L,3);
// FindLoopPort(L);
findloopPort(L);
// lengthcircle(L);
// display(L);
// deletereelem(L);
// display(L);
// NIndex(L);
// BulidListLoop(L,4);
// middle(L);
// cout<<judgement(L);
// ReverseList(L);
return 0;
}

时间: 2024-10-13 12:02:36

数据结构关于单链表的一些操作的源代码的相关文章

C#数据结构-单链表

理论基础: 链表是用一组任意的存储单元来存储线性表中的数据元素. 如果结点的引用域只存储该结点直接后继结点的存储地址,则该链表叫单链表(Singly Linked List). 单链表由头引用H唯一确定.头引用指向单链表的第一个结点,也就是把单链表第一个结点的地址放在H中. C#实现: 1接口 引用线性表的接口IListDS<T> 2实现 首先,必须定义一个单链表的节点类.  1 public class Node<T> 2    { 3        private T data

数据结构(一) 单链表的实现-JAVA

数据结构还是很重要的,就算不是那种很牛逼的,但起码得知道基础的东西,这一系列就算是复习一下以前学过的数据结构和填补自己在这一块的知识的空缺.加油.珍惜校园中自由学习的时光.按照链表.栈.队列.排序.数组.树这种顺序来学习数据结构这门课程把. -WH 一.单链表的概念 链表是最基本的数据结构,其存储的你原理图如下图所示 上面展示的是一个单链表的存储原理图,简单易懂,head为头节点,他不存放任何的数据,只是充当一个指向链表中真正存放数据的第一个节点的作用,而每个节点中都有一个next引用,指向下一

单链表的基础操作

单链表中节点的查找.插入.删除.求单链表长度等操作. 按序号查找结点值 在单链表中从第一个结点出发,顺指针next域逐个往下搜索,直到找到第i个结点为止,否则返回最后一个结点指针域NULL. 按序号查找结点值的算法如下: LNode GetElem(LinkList L,int i){ //本算法取出单链表L(带头结点)中第i个位置的结点指针 int j=1; //计数,初始为1 LNode *p = L->next; //头结点指针赋给p if(i==0) return L; //若i等于0,

【数据结构】单链表&amp;&amp;静态链表详解和代码实例

喜欢的话可以扫码关注我们的公众号哦,更多精彩尽在微信公众号[程序猿声] 01 单链表(Singly Linked List ) 1.1 什么是单链表? 单链表是一种链式存储的结构.它动态的为节点分配存储单元.当有节点插入时,系统动态的为结点分配空间.在结点删除时,应该及时释放相应的存储单元,以防止内存泄露.由于是链式存储,所以操作单链表时,必须知道头结点或者头指针的位置.并且,在查找第i个节点时,必须找到第i-1个节点. 1.2 单链表的存储结构代码描述 对于链式存储,通过上一节的讲解相信大家已

java数据结构:单链表常见操作代码实现

一.概述: 本文主要总结单链表常见操作的实现,包括链表结点添加.删除:链表正向遍历和反向遍历.链表排序.判断链表是否有环.是否相交.获取某一结点等. 二.概念: 链表: 一种重要的数据结构,HashMap等集合的底层结构都是链表结构.链表以结点作为存储单元,这些存储单元可以是不连续的.每个结点由两部分组成:存储的数值+前序结点和后序结点的指针.即有前序结点的指针又有后序结点的指针的链表称为双向链表,只包含后续指针的链表为单链表,本文总结的均为单链表的操作. 单链表结构: Java中单链表采用No

算法数据结构 单链表的实现+操作 以及和顺序表的对比

顺序表和单链表的优缺点对比: 顺序表的优点,无需为表示表中元素之间的逻辑关系而增加额外的存储空间: 可以快速的存取表中的任意位置的元素. 顺序表的缺点,插入后删除操作需要移动大量元素: 当线性表长度不稳定时,存储空间难确定,容易造成存储空间碎片. 对于单链表 链式存储即元素存储的内存单元可以是不连续,分散的.对于元素间如何来维护他们的关系(即逻辑结构,每个元素的前驱和后继.) 即用到一个指针域来存储他和前驱或是后继直接的关系. 如上面的是一个单链表的指针结构,即每个元素中存储了他的后继元素的内存

【复习数据结构】单链表的操作

#include <stdio.h> #include <malloc.h> typedef char ElemType; typedef struct LNode{ //定义单链表结点类型 ElemType data; //数据域 struct LNode *next; //指针域 }LNode,*LinkList; /** * 头插法初始化链表 **/ LinkList CreateListhead(void){ char ch; LinkList L; //初始化链表 LNo

数据结构之——单链表

今天闲来无事,就打算把大一的时候写过的数据结构重温一遍,基本上我在大一之后只在单片机上用过几次顺序表和循环队列之外再就很少使用过数据结构了. 并且乘着写一下数据结构也可以熟悉熟悉vim. 首先定义单链表节点: 1 #define DataType int 2 3 struct node{ 4 DataType data; 5 struct node *next; 6 }; 7 struct node list,*p_list; 单链表这个数据结构需要一些函数来对她操作,一般需要有这些: 1.初始

带头节点的单链表的插入操作

1.偶然看到了十字链表的应用,想到之前在<数据结构与算法分析>的链表一章中,需要用多重表实现一个简单的查询功能.功能需求如下: “已知 学生 和 学校课程 总数 分别为 40000 和 2500,现在需要得到两份报告,一份显示每门课成注册的所有学生信息, 一份显示每个学生注册了哪些课程.” 显然可以用一个 40000 * 2500 个元素的二维数组来解决,但是每个学生选课数目很少,因此会浪费很多空间.因此选择十字链表来实现. 既然是链表,那么肯定要有插入操作,于是便有了本文.算是对功能实现前的