数据结构之单链表及其函数算法

最新推荐文章于 2024-05-06 11:07:47 发布
最新推荐文章于 2024-05-06 11:07:47 发布
阅读量70 收藏
点赞数
文章标签： 数据结构与算法 c/c++ 面试
原文链接：http://www.cnblogs.com/BetterThanEver_Victor/p/5145298.html
版权

---恢复内容开始---

　　单链表是非常重要的数据结构，动态在数据处理中确实是及其必要的，静态的比如定义一个数组，大小是固定的，定小了不够用，定多了浪费空间，链表增删数据不需要像数组那样要移动数据，但是也付出了需要提供指针域的空间。
　　单链表分为带头指针和不带头指针，头指针意思是它里面没数据元素，仅仅有指向下一个结点的指针，也就是说第二个结点才是存放的第一个数据元素，为了防止删除或者增加数据元素在第一个元素的位置而带来的更改头指针的麻烦。
　　下面是完整的代码，附带解释来研究单链表及其功能函数。 
//快慢指针的问题，比如找一个单链表的中间节点，可以i每次走一个，j每次走两个。
#define _CRT_SECURE_NO_DEPRECATE//vs编译器c语言需要加此条代码
#include<stdio.h>
#include<stdlib.h>
#define DataType int   //定义数据类型
typedef struct LNode   //结点数据类型
{
	DataType data;
	struct LNode *next;
}LNode,*Linklist;     //结点非指针类型和指针类型定义
//接下来是两种构造单链表的算法尾插法和头插法
void CreatListTail(Linklist &L, int n)   //尾插法构造长度为n的单链表
{
	L = (Linklist)malloc(sizeof(LNode));//动态申请一个头结点空间
	L->next = NULL;  //初始化头为空
	//注意在C语言中结构变量若是指针类型Linklist则要用->,若不是指针变量LNode则用.(L.next)
	printf("Input %d datas:\n",n);
	Linklist s,p=L;  //定义指针变量s来申请空间，指针变量p指向链表尾
	DataType x;     //定义变量来接收输入的数据元素
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &x);
		s = (Linklist)malloc(sizeof(LNode));
		s->data = x;
		s->next = p->next;   //尾插法，在p之后插入s所指结点
		p->next = s;
		p = s;   //p指向最后
	}
}
void CreatListHead(Linklist &L, int n)//头插法构造长度为n的单链表
{
	L = (Linklist)malloc(sizeof(LNode));
	L->next = NULL;
	printf("Input %d datas:\n", n);
	Linklist s;
	DataType x;
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &x);
		s = (Linklist)malloc(sizeof(LNode));
		s->data = x;
		s->next=L->next;   //头插法
		L->next = s;
	}
}
void PrintList(Linklist L)//遍历输出
{
	Linklist p = L->next;
	while (p)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}
int find(Linklist L, DataType x)//查找某一元素位置，没有则返回0
{
	Linklist p = L->next;
	int j = 1;
	while (p)   //如果未遍历完则循环找
	{
		if (p->data == x)
			return j;
		j++;
　　　　p=p->next;
	}
	return 0;
}
Linklist Get(Linklist L, int i)  //返回第i个元素的地址
{
	Linklist p = L->next;
	int j = 1;
	while (p&&j < i)  //链表未遍历完且还没到第i个元素
		p = p->next;
	if (p&&j == i)
		return p;
	else
		return 0;
}
bool ListInsert(Linklist &L, DataType x,int i)  //第i个位置插入元素x
{
	Linklist p = L;
	int j = 0;
	while (p&&j < i - 1)//找第i-1个元素地址
	{
		p = p->next;
		j++;
	}
	if (p&&j == i - 1)//第i-1个元素后面插入新结点
	{
		Linklist s = (Linklist)malloc(sizeof(LNode));
		s->data = x;
		s->next = p->next;
		p->next = s;
		return true;
	}
	else
		return false;
}
bool ListDelete(Linklist &L, int i)//删除第i个元素，与上面类似先找第i-1个元素位置
{
	Linklist p = L;
	int j = 0;
	while (p&&j < i - 1)
	{
		p = p->next;
		j++;
	}
	if (p&&j == i - 1)
	{
		Linklist s = p->next;
		p->next = s->next;
		free(s);
		return true;
	}
	else
		return false;
}
void ListReverse(Linklist &L)//头插法就地转置
{
	Linklist p = L->next,s;//p为元素头
	L->next = NULL;//L为新的头结点
	while (p)
	{
		s = p;
		p = p->next;
		s->next = L->next;
		L->next = s;
	}
}
void ListInsertSort(Linklist &L)//插入法排序
{
	Linklist head=L->next;
	L->next = NULL;
	Linklist p,s;
	while (head)
	{
		s = head;
		head = head->next;
		p = L;
		while (p->next&&p->next->data <= s->data)
			p = p->next;
		s->next = p->next;
		p->next = s;
	}
	
}
void ListSlectSort(Linklist &L)//选择排序
{
	Linklist p=L, s,q,min;
	while (p->next)
	{
		q = p;
		s = p;
		while (s->next)
		{
			if (s->next->data < q->next->data)//q指向最小值的前驱
				q = s;
			s = s->next;
		}
		min = q->next;
		if (p != q)
		{
			q->next = min->next;//记下min
			min->next = p->next;
			p->next = min;
		}
	
		p = p->next;//已经确保最后NULL结尾
	}
}
int main()//测试代码
{
	Linklist L;
	CreatListHead(L,6);
	CreatListTail(L, 6);
	PrintList(L);
	ListReverse(L);
	PrintList(L);
	/*ListInsertionSort(L);*/
	ListSlectSort(L);
	PrintList(L);
	//if (ListInsert(L, 32, 4))
	//	printf("do insert!\n");
	//else
	//	printf("fail insert!\n");
	//PrintList(L);
	//if(ListDelete(L, 3))
	//	printf("do delete !\n");
	//else
	//	printf("fail delete!\n");
	//PrintList(L);
	//int x = 32;
	//if (find)
	//	printf("%d is in %d", x,find(L, x));
	//else
	//	printf("fail find %d!\n",x);
	//PrintList(L);
	system("pause");
	return 0;
}
　　
　　快慢指针问题：单链表在面试题中会有一种比较难的算法题——快慢指针。例如如何找到一个单链表的最中间的节点，如何判断一个单链表是否有环，面试题一定要最优解法。具体算法是定义两个快慢指针，第一个指针每次往下走一个结点，第二个指针每次往下走两个结点，两个指针同步移动，针对第一个题当快指针走到链表末尾时慢指针的位置就是链表中心点，第二道题类比于跑步套圈，当慢指针和快指针相遇则一定有环。
　　链表交点问题：找到两个单链表交点的位置，分析单链表有唯一后继，那么如果有交点，则交点之后两个链表必重合。最有效的算法是分别算两个单链表的长度X，长度差就是两个单链表从开始到交点的长度差，长的链表遍历X长度，然后两者再同步遍历，找到相同结点。

---恢复内容结束---

　　单链表是非常重要的数据结构，动态在数据处理中确实是及其必要的，静态的比如定义一个数组，大小是固定的，定小了不够用，定多了浪费空间，链表增删数据不需要像数组那样要移动数据，但是也付出了需要提供指针域的空间。
　　单链表分为带头指针和不带头指针，头指针意思是它里面没数据元素，仅仅有指向下一个结点的指针，也就是说第二个结点才是存放的第一个数据元素，为了防止删除或者增加数据元素在第一个元素的位置而带来的更改头指针的麻烦。
　　下面是完整的代码，附带解释来研究单链表及其功能函数。 
//快慢指针的问题，比如找一个单链表的中间节点，可以i每次走一个，j每次走两个。
#define _CRT_SECURE_NO_DEPRECATE//vs编译器c语言需要加此条代码
#include<stdio.h>
#include<stdlib.h>
#define DataType int   //定义数据类型
typedef struct LNode   //结点数据类型
{
	DataType data;
	struct LNode *next;
}LNode,*Linklist;     //结点非指针类型和指针类型定义
//接下来是两种构造单链表的算法尾插法和头插法
void CreatListTail(Linklist &L, int n)   //尾插法构造长度为n的单链表
{
	L = (Linklist)malloc(sizeof(LNode));//动态申请一个头结点空间
	L->next = NULL;  //初始化头为空
	//注意在C语言中结构变量若是指针类型Linklist则要用->,若不是指针变量LNode则用.(L.next)
	printf("Input %d datas:\n",n);
	Linklist s,p=L;  //定义指针变量s来申请空间，指针变量p指向链表尾
	DataType x;     //定义变量来接收输入的数据元素
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &x);
		s = (Linklist)malloc(sizeof(LNode));
		s->data = x;
		s->next = p->next;   //尾插法，在p之后插入s所指结点
		p->next = s;
		p = s;   //p指向最后
	}
}
void CreatListHead(Linklist &L, int n)//头插法构造长度为n的单链表
{
	L = (Linklist)malloc(sizeof(LNode));
	L->next = NULL;
	printf("Input %d datas:\n", n);
	Linklist s;
	DataType x;
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &x);
		s = (Linklist)malloc(sizeof(LNode));
		s->data = x;
		s->next=L->next;   //头插法
		L->next = s;
	}
}
void PrintList(Linklist L)//遍历输出
{
	Linklist p = L->next;
	while (p)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}
int find(Linklist L, DataType x)//查找某一元素位置，没有则返回0
{
	Linklist p = L->next;
	int j = 1;
	while (p)   //如果未遍历完则循环找
	{
		if (p->data == x)
			return j;
		j++;
　　　　p=p->next;
	}
	return 0;
}
Linklist Get(Linklist L, int i)  //返回第i个元素的地址
{
	Linklist p = L->next;
	int j = 1;
	while (p&&j < i)  //链表未遍历完且还没到第i个元素
		p = p->next;
	if (p&&j == i)
		return p;
	else
		return 0;
}
bool ListInsert(Linklist &L, DataType x,int i)  //第i个位置插入元素x
{
	Linklist p = L;
	int j = 0;
	while (p&&j < i - 1)//找第i-1个元素地址
	{
		p = p->next;
		j++;
	}
	if (p&&j == i - 1)//第i-1个元素后面插入新结点
	{
		Linklist s = (Linklist)malloc(sizeof(LNode));
		s->data = x;
		s->next = p->next;
		p->next = s;
		return true;
	}
	else
		return false;
}
bool ListDelete(Linklist &L, int i)//删除第i个元素，与上面类似先找第i-1个元素位置
{
	Linklist p = L;
	int j = 0;
	while (p&&j < i - 1)
	{
		p = p->next;
		j++;
	}
	if (p&&j == i - 1)
	{
		Linklist s = p->next;
		p->next = s->next;
		free(s);
		return true;
	}
	else
		return false;
}
void ListReverse(Linklist &L)//头插法就地转置
{
	Linklist p = L->next,s;//p为元素头
	L->next = NULL;//L为新的头结点
	while (p)
	{
		s = p;
		p = p->next;
		s->next = L->next;
		L->next = s;
	}
}
void ListInsertSort(Linklist &L)//插入法排序
{
	Linklist head=L->next;
	L->next = NULL;
	Linklist p,s;
	while (head)
	{
		s = head;
		head = head->next;
		p = L;
		while (p->next&&p->next->data <= s->data)
			p = p->next;
		s->next = p->next;
		p->next = s;
	}
	
}
void ListSlectSort(Linklist &L)//选择排序
{
	Linklist p=L, s,q,min;
	while (p->next)
	{
		q = p;
		s = p;
		while (s->next)
		{
			if (s->next->data < q->next->data)//q指向最小值的前驱
				q = s;
			s = s->next;
		}
		min = q->next;
		if (p != q)
		{
			q->next = min->next;//记下min
			min->next = p->next;
			p->next = min;
		}
	
		p = p->next;//已经确保最后NULL结尾
	}
}
int main()//测试代码
{
	Linklist L;
	CreatListHead(L,6);
	CreatListTail(L, 6);
	PrintList(L);
	ListReverse(L);
	PrintList(L);
	/*ListInsertionSort(L);*/
	ListSlectSort(L);
	PrintList(L);
	//if (ListInsert(L, 32, 4))
	//	printf("do insert!\n");
	//else
	//	printf("fail insert!\n");
	//PrintList(L);
	//if(ListDelete(L, 3))
	//	printf("do delete !\n");
	//else
	//	printf("fail delete!\n");
	//PrintList(L);
	//int x = 32;
	//if (find)
	//	printf("%d is in %d", x,find(L, x));
	//else
	//	printf("fail find %d!\n",x);
	//PrintList(L);
	system("pause");
	return 0;
}
　　
　　快慢指针问题：单链表在面试题中会有一种比较难的算法题——快慢指针。例如如何找到一个单链表的最中间的节点，如何判断一个单链表是否有环，面试题一定要最优解法。具体算法是定义两个快慢指针，第一个指针每次往下走一个结点，第二个指针每次往下走两个结点，两个指针同步移动，针对第一个题当快指针走到链表末尾时慢指针的位置就是链表中心点，第二道题类比于跑步套圈，当慢指针和快指针相遇则一定有环。
　　链表交点问题：找到两个单链表交点的位置，分析单链表有唯一后继，那么如果有交点，则交点之后两个链表必重合。最有效的算法是分别算两个单链表的长度X，长度差就是两个单链表从开始到交点的长度差，长的链表遍历X长度，然后两者再同步遍历，找到相同结点。 
#include<stdio.h>
#include<stdlib.h>
typedef int DataType;
typedef struct LNode
{
    DataType data;
    struct LNode *next;
}LNode, *Linklist;
//带头结点的单链表判断是否带环，有环的话返回入环节点的指针，否则返回NULL
Linklist FindCircleNode(Linklist L)
{
    if (!L)
        return NULL;
    Linklist p = L;
    Linklist q = L;
    while (p)
    {
        q = q->next;
        if (p->next)
        {
            p = p->next->next;
        }
        else
            return NULL;
        if (p == q)
            break;
    }
    if (!p)
        return NULL;
    p = L;
    while (q != p)
    {
        p = p->next;
        q = q->next;
    }
    return p;
}
int main()
{
    Linklist link[10];
    for (int i = 0; i < 30; i++)
    {
        link[i] = (Linklist)malloc(sizeof(LNode));
        link[i]->data = i;
    }
    for (int i = 0; i < 29; i++)
    {
        link[i]->next = link[i + 1];
    }
    link[29]->next = link[12];
    Linklist res = FindCircleNode(link[0]);
    if (!res)
        printf("该链表没有环！\n");
    else
        printf("该链表有环，入环节点值为：%d\n", res->data);
    getchar();
    return 0;
}

 

转载于:https://www.cnblogs.com/BetterThanEver_Victor/p/5145298.html

weixin_30477797
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构与算法实验（C++）：单链表实验-代码
01-18
1.内容概要： （1）实验目的： 1）熟练掌握单链表的存储特点； 2）熟练掌握单链表的基本操作算法； 3）熟练掌握面向对象程序设计方法； 4）能灵活使用单链表解决具体的问题。...数据结构与算法实验
【PTA】数据结构与算法，5-4，单链表的查询（复合数据）【可本地编译器调试】成信大，DS课程组
qq_44854473的博客
03-30 598
本题目要求完成在学生信息单链表中查找指定姓名的学生成绩，并打印出姓名，成绩。
单链表对元素的基本操作
chi's blog
03-22 652
单链表对元素的插入 删除 和查找 #include<stdio.h> #include<stdlib.h> #include<string.h> /************************类型定义************************/ typedef char datatype; void printElem(datatype x) { ...
单链表的各种基本运算
Paradox
11-25 1861
单链表的各种基本运算 码文不易，如果帮助到您，希望您可以帮我刷一下点击量，与您无害，与我有益谢谢 支持原创 。   欢迎大家阅读我的博客，如果有错误请指正，有问题请提问，我会尽我全力改正错误回答问题。在此谢谢大家。下面开始正式内容 單向鍊表（單鍊表）是鍊表的一種，其特點是鍊表的連結方向是單向的，對鍊表的訪問要通過從頭部開始，依序往下讀取。维基百科-单向链表 实验环境...
c语言数据结构单链表的算法
01-13
数据结构习题与解析（B级第3版） 李春葆 喻丹丹 编者 2.3
Python实现数据结构线性链表（单链表）算法示例
12-26
本文实例讲述了Python实现数据结构线性链表（单链表）算法。分享给大家供大家参考，具体如下： 初学python，拿数据结构中的线性链表存储结构练练手，理论比较简单，直接上代码。 #!/usr/bin/python # -*- coding:...
【数据结构算法】--单链表的相关程序实现
03-09
压缩包包含单链表的listlink.h头文件,linkliist.c函数实现文件，test.c功能测试文件
详解常用查找数据结构及算法（Python实现）
12-24
查找（Searching）就是根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素（或记录）。 查找表（Search Table）：由同一类型的数据元素（或记录）构成的集合 关键字（Key）：数据元素中某个数据项...
c语言单链表的实现，包括链表的创建、插入、查询、删除、打印、长度计算
weixin_44818115的博客
11-25 606
#include <stdio.h> #include <stdlib.h> typedef struct node{ char data; struct node *next; }LINKLIST; // 链表初始化操作,返回一个空链表 LINKLIST *INITLIST() { LINKLIST *head; head = (LINKLIST*)malloc(sizeof(LINKLIST)); head->next = NULL; return h
单链表的析构函数
尽人事，听天命
07-31 8225
刚看到一个单链表的析构方法，是我上次没有想到的，记下来，其实很简单，就是从链表的第一个开始析构，然后循环析构第一个结点，直到只剩下第一个结点，然后释放它。 LinkList::~LinkList() { Node *tempptr; while(head->next!=NULL) { tempptr=head->next; delete head; head=tempptr;
单链表解析Ⅱ
C语言这么神奇的吗的博客
08-14 247
定义： typedef char ListData; typedef struct node { ListData data; struct node * link; }ListNode;typedef ListNode * LinkList; LinkList first; //定义头指针 LinkList last; //定义尾指针 1.前插法建立单链表 LinkList creat
实现单链表各种基本运算的算法
热门推荐
金州饿霸吃不饱的博客
10-17 1万+
编写一个头文件LinkList.h，实现单链表的各种基本运算，并在此基础上设计一个主程序（exp2_2.cpp）完成如下功能： 初始化单链表h 依次采用尾插法插入a,b,c,d,e元素 输出单链表h 输出单链表h的长度 判断单链表h是否为空 输出单链表h的第3个元素 输出元素a的位置 在第4个元素位置上插入f元素 输出单链表h 删除h的第3个元素 输出单链表h 释放单链表h...
数据结构算法——单链表的三种插入
李陈的技术博客
04-25 2590
三种插入分别是： 1.头插法：从头节点插入 2.尾插法：从尾节点插入 3.有序插入：按照内容大小插入 代码如下： //定义节点的数据类型 typedef struct Node { int data;//节点数据 struct Node *next;//指向下一个节点的指针 }Node; //定义单链表 typedef struct { Node *head;/
数据结构 单链表的插入详解 例子
Z_Dream_ST的博客
08-30 3366
最近看了郝斌老师讲的数据结构的单链表插入的视频，觉得视频中链表插入的算法写的很经典，所以就把代码敲了一下分享给大家 #include #include #include typedef struct list { int vaule; //数据域 struct list *PNext; //指针域 }TNODE, *TPNODE; T
（论文阅读-优化器）EFFICIENCY IN THE COLUMBIA DATABASE QUERY OPTIMIZER
最新发布
junerli的博客
05-06 883
查询优化是一个数据库系统能够获得重要性能收益的领域。现代数据库应用通常要求优化器具有高可扩展性和效率。Columbia基于Cascades优化框架的自顶向下优化算法，通过对搜索空间结构和搜索算法的精心重构，简化了自顶向下优化器的设计。
c语言数据结构--单链表 算法函数的实现(查找位序)
09-04
单链表是一种常见的数据结构，它由一个或多个节点组成，每个节点包含一个数据域和一个指针域，指针域指向下一个节点。 实现单链表的查找位序算法函数需要以下步骤： 1. 定义一个指针p指向链表的头节点，并定义一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值