数据结构与算法（链表）

最新推荐文章于 2023-10-19 23:18:13 发布
最新推荐文章于 2023-10-19 23:18:13 发布
阅读量474 收藏 1
点赞数 1
分类专栏： 程序员面试笔试宝典笔记 文章标签： 链表 数据结构 算法 java 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33700236/article/details/107099355
版权

1. 链表

1.1 如何实现单链表的增删操作

链表是一个基本的数据结构，存储特点是：可以用任意一个存储单元存储单链表中的数据元素（可以不连续）。单链表中的一个存储单元包括存储的数据元素和指向直接后继的索引。这两个总和成为一个单链表总的一个节点。单链表存储形式如下：
在这里插入图片描述
一个单链表的节点可以有如下定义：

Class Node{
	Node next=null;//指向下一个节点
	int data;//存储的元素
	public void Node(int data){
	this.data=data;
	}
}

单链表中最主要的操作是插入和删除节点。
在单链表中的节点ai和ai-1之间插入一个元素的步骤如下：
在这里插入图片描述
1、找到ai-1的引用（存储位置）p
2、生成一个数据域为x的新节点s
3、设置p.next=s
4、设置s.next=a
在一个单链表中插入一个节点：

Class Node{
	Node next=null;//指向下一个节点
	int data;//存储的元素
	public void Node(int data){
	this.data=data;
	}
}
public class LinkedList{
	Node head=null;//表头的引用
	public void addNode(int a){//a:插入的节点信息
		Node newNode = new Node(a);
		if(head==null){//当单链表为空
			head=newNode;//将该节点作为头结点
			return;
		}
		Node tmp = head;
		while(tmp.next!=null){//当头结点不为空
			tmp = tmp.next;
		}
		//将一个结点插入单链表（尾插）
		tmp.next=newNode;
}

在单链表中删除第i个节点步骤如下：
在这里插入图片描述
1、找到ai-1的存储位置p
2、让p.next指向ai节点的直接后继节点ai+1
在单链表中删除第i个节点，如果删除成功返回true，返回失败为false：

public class LinkedList{
	Node head=null;
	public Boolean deleteNode(int index){//i为第i个节点
		if(index<1||index>LinkedList.length()){//当删除的节点不在链表中
			return false;
		}
		if(index==1){//当删除头结点
			head = head.next;
			return true;
		}
		int i=1;
		Node preNode = head;//将头结点作为前一个节点
		Node curNode = preNode.next;//前一个节点的后继为当前节点（需要删除的节点）
		while(curNode!=null){//当前节点不为空
			preNode.next = curNode.next//删除当前节点，当前节点的后继作为亲一个节点的后继
			return true;
		}
		preNode = curNode;//当前节点的位置成为前一个节点
		curNode = curNode.next;//当前节点的下一个节点成为当前节点
		i++;//将其余的后面的节点顺次前移
		}
		return true;
	}
}

返回链表的长度：

public int length（）{
	int length=0;//初始化长度
	Node node = head;//链表的头结点
	while(node!=null){//当节点不为空
		length++;//长度加一
		node = node.next;
	}
	return length;
	
}

对链表进行排序，返回排序后的头结点：

public void sortLinkedList(){
	Node curNode = head;//定义两个相邻节点
	Node nextNode = null;
	int temp = 0;
	while(curNode.next!=null){
		nextNode = curNode.next;
		if(nextNode<curNode){
			temp = curNode;
			curNode = nextNode;
			nextNode = temp;
		}
			nextNode = nextNode.next;
		}
			curNode = curNode.next;
	return head;//返回排序后的头结点
		}
		public void printList(){//对排序后的链表元素挨个打印
			Node tmp = head;
			while(tmp!=null){
				System.out.println(tmp.data);
				tmp = tmp,next;
			}
		}
}

1.2 如何从链表中删除重复数据

通过遍历链表，将遍历到的值存储到一个hashtable中，若当前遍历到的元素在hashtable中已经存在，则该数据是重复的，进行删除。

public void deleteDuplecate(Node head){
	Node node=head;
	node pre;
	Hashtable<Integer,Integer> table = new Hashtable<Integer,Integer>();//创建一个hashtable存储遍历到的元素
	if(node!=null){//当该节点不为空
		if(table.constanisKey(node.data)){//当遍历的元素在hashtable中存在
			pre.next = node.next;//则删除该节点
		}
		else{
			table.put(node.data,1);//否则将该元素存入hashtable
			node = node.next;
		}
		node = node.next;//否则遍历下一个节点
	}
		
}

方法二：

public void deleteDuplecate(Node tmp){
	Node node = head;
	Node next;
	if(node==null){//当链表为空
		return null;
	}
	if(node!=null){//当链表不为空
		while(node.next!=null){//当该节点的下一个节点不为空
			next = node.next;
			if(node.data==next.data){//判断node与其他节点是否相等
				node.next = next.next;
			}
			else{
				next = next.next;
			}
			node = node.next;
		}
	}

1.3 如何找出单链表中的倒数第k个元素

第一种方法是先遍历一遍链表，得出单链表的长度n，将倒数第k个元素转换为正数第n-k个，然后再遍历一次就可以得到结果。

public int getK(){
	Node node = head;
	int length = 0;
	int n;
	while(node!=null){
		lenght++;
		node = node.next;
	}
	n = length;
	int k;
	for(int i=0;i<n;i++){
		if(i.data==(n-k).data){
			System.out.println((n-k).data);
		}
	}
}

第二种方法，若从头到尾从链表中的某个元素开始，遍历k个元素后刚好到达链表尾，则该元素就是要找的倒数第k个元素。则有：从头结点开始，依次对链表的每一个节点元素进行测试，遍历k个元素，查看是否到达链表尾，直到找到倒数第k个元素。该方法将对同一批元素进行反复多次的遍历，对链表的大部分元素，都要遍历k个元素。
第三种方法是使用两个指针，一个指针先向前移动k-1次，接着两个指针同时向前移动，直到第一个指针的值为空时，另一个指针的位置就是所要找的位置。

public Node findK(Node head,int k){
	Node n1 = null;
	Node n2 = null;
	if(k<1||k>this.length()){
		return null;
	}
	int i = 0;
	while(i<k-1){
		n1 = n1.next;
		i++;
	}
	while(n1!=null){
		while(n2!=null){
			n1 = n1.next;
			n2 = n2.next;
			}
		}
		return n2;
	}

1.4 如何实现链表的反转

i，m，n是三个相邻节点，设经过若干次操作，将节点i之前的指针调整完毕，这些节点的next指针都指向前面的一个节点。当遍历到m节点，需要将m节点的next指向i，但是这样会使得m指向n的指针断开。因此，在改变m的next指向前，需要将n存储一下，再找到反转后的冷链表的头结点，反转后的链表的头结点是原始链表的尾结点。

public void ReverseIteratively(Node head){
	Node node = head;
	Node pre = null;
	Node ReverseHead  = head;
	if(node==null){
		return null;
	}
	while(node!=null){
		nodeNext = node.next;
	if(nodeNext==null){
		ReverseHead = node;
	}
		pre = node;
		node.next = pre;
	node = nodeNext;
	}
	this.head = ReverseHead;
	}

1.5 从尾到头输出单链表

首先第一种方法是将单链表中每个节点的连接指针反过来，这样等于是将整个单链表反转，然后从头到尾一次输出每个元素。

public void ReverseIteratively(Node head){
	Node node = head;
	Node pre = null;
	Node ReverseHead  = head;
	if(node==null){
		return null;
	}
	while(node!=null){
		nodeNext = node.next;
	if(nodeNext==null){
		ReverseHead = node;
	}
		pre = node;
		node.next = pre;
	node = nodeNext;
	}
	this.head = ReverseHead;
	}
	public Node print(Node head){
		for(int i=0;i<length;i++){
			System.out.println(i);
			}
		}

第二种方法是从头到尾遍历链表，每经过一个元素，将该元素放入栈中。当遍历完整个链表，从栈的顶部输出栈中的元素。这样就将链表中的值从尾到头输出出来。

public int printLinkedListReversely(){
	Node node = head;
	Stack<Integer> stack = new Stack<Integer>();
	if(node==null){
		return null;
	}
	while(node!=null){
		stack.push(node.data);
		node = node.next;
	}
	for(int i=0;i<stack.length;i++){
		System.out.println(i);
	}
}

使用递归进行操作，每访问一个节点，先递归输出其后的节点，再输出其本身节点。

public int printLinkedListReversely(Node head){
	if(head.next!=null){
		printLinkedListReversely(head.next);
		System.out.println(head.data);
		}
	}

1.6 如何寻找单链表中间节点

第一种方法是首先遍历单链表，得到单链表的长度n，然后遍历n/2，得到单链表的中间节点。该方法需要遍历两次，第一次遍历整个单链表，第二次遍历单链表的一半的长度。

public Node middleNode(){
	int length=0;
	Node node = head;
	if(node==null){
		return null;
	}
	while(node!=null){
		length++;
		node = node.next;
	}
	int n;
	n = length/2;
	for(int i=0;i<n;i++){
		if(i.data==n.data){
			System.out.println(i);
			}
		}
	}

如果是双向链表，使用两个方向的指针同时进行遍历，一个从头到尾进行遍历，一个从尾到头遍历，当两个指针相遇时，则得到中间元素。
在单链表中也可以使用双指针实现中间节点的快速查找。第一步：两个指针同时从头到尾开始遍历；第二步：一个指针一次移动两步，一个指针一次移动一步；第三步：快指针先到链表尾部，慢指针到达链表中部。

public Node middleNode(Node head){
	Node n1 = this.head;
	Node n2 = this.head;
	while(n1!=null&&n1.next!=null&&n1.next.next!=null){
		n1 = n1.next.next;
		n2 = n2.next;
	}
	return n2;
	}

1.7 如何检测一个链表是否有环

使用两个指针，一个是快指针fast，一个是慢指针slow,二者的初始值都指向链表投，slow每次移动一步，fast每次移动两步，两个指针同时同向移动，快指针每移动一次和慢指针比一次，直到快指针等于慢指针为止，说明这个链表是带有环的单向链表。否则为不带环的单链表。

public boolean IsLoop（Node head）{
	Node f = head;//快指针
	Node s = head;//慢指针
	if(f==null){
		return false;
	}
	if(f!=null&&f.next!=null){
		f = f.next.next;
		s = s.next;
		while(f==s){
			return true;
			}
		}
		return !(f==null||f.next==null);
	}

1.8 如何在不知道头指针的情况下删除指定节点

分为两种情况讨论：
1、当待删除的节点时链表尾结点，无法删除，因为删除后无法使得其前驱结点的next指针为空。
2、当待删除的节点不是尾结点，可以通过交换该节点和其后继节点的值，然后删除后继节点。

public boolean deleteNode(Node head){
	Node n = head;
	int temp ;
	if(n==null&&n.next==null){
		return false;
		}
	tmp = n.data;
	n.data = n.next.data;
	n.next.data = tmp;
	n = n.next.next;
	return true;
	}

1.9 如何判断两个链表是否相交

如果两个链表相交，则他们一定有相同的尾结点，所以分别遍历连个链表，记录他们的尾结点，如果尾结点相同，则这两个链表相交，否则不相交。

public boolean isIntersect(Node head1,Node head2){
	Node n1 = head;
	if(n1==null||n2==null){
		return  false;
	}
	//判断两个链表中的
	while(n1.next!=null){
		n1 = n1.next;
	}
	while(n2.next!=null){
		n2 = n2.next;
	}
	if(n1==n2){
		return true;
		}
	}

1.10 使用头插法建立单链表

从空表开始，生成新节点，将读取到的数据存放到新节点的数据域中，将新节点插入到当前链表的表头，即头结点之后。
在这里插入图片描述
实现算法的伪代码如下：
在这里插入图片描述
头插法建立单链表时，读取数据的顺序与生成的俩表中元素的顺序是相反的。

1.11 按序号查找结点值

在单链表中从第i个结点出发 ，顺指针 next域逐个往下搜索，直到找到第i个结点为止，否则返回最后一个结点指针域 NULL。

Class Node{
	Node next = null;
	int data;
	public void Node(int data){
		this.data = data;
		}
	}
public class Find{
	int n=0;
	public int length(Node head){
		Node node = head;
		while(node!=null){
			n++;
			node = node.next;
		}
		return n;
	}
	public int find(Node head, int a){
		Node node = head;
		if(node==null){
			return false;
			}
		while(node!=null){
			for(int i=0;i<n;i++){
				if(i.data == a){
					double p = i.data;
					return p;
					}
				else{
					break;
				}
			}
		}
	}

1.12 按照值查找表结点

从单链表第一个节点开始，从前往后一次比较表中各节点的值，当某节点的值等于给定值，返回该节点的指针，当单链表中的节点值都不等于给定值则返回null。

public class Find{
	int n=0;
	public int length(Node head){//计算链表长度
		while(node!=null){
			n++;
			node = node.next;
			}
		return n;
		}

public void find(int a,Node head){
	Node node = head;
	if(data==null){
		return false;
		}
	while(data!=null){
		for(int i=0;i<n;i++){
			if(i.data==a){
				return i;
				}
			else{
				break;
				}
			}
		}
	}
}
加加大了
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法 链表.doc
09-30
数据结构与算法 链表.doc
C语言结构体链表 节点插入方法（从前和从后）
m0_52870614的博客
07-31 6269
1.如果是从头节点前插入，则直接令新节点的下一个等于头节点，然后返回新节点即可。第三个参数是要插入的节点的位置，用结构体的值来表示（实际项目可自由更改）第四个参数是插入方式（前AHEAD/后BEHIND）第一步那么新节点的NEXT等于P->NEXT。第一步那么新节点的NEXT等于P->NEXT。第二步P的NEXT指向新节点。第二步P的NEXT指向新节点。第二个参数是要插入的新节点地址。第一个参数是原链表头节点地址。...
数据结构-线性表课后习题14-设计一个算法在带头结点的非空单链表L中第一个最大值节点（最大值节点可能有多个）之前插入一个值为x的结点
h420405961的博客
09-26 1万+
设计一个算法在带头结点的非空单链表L中第一个最大值节点（最大值节点可能有多个）之前插入一个值为x的结点 使用maxpos 记录第一个最大值节点所出现的位置， 之后进行简单的单链表插入即可。 代码如下： #include<stdio.h> #include<stdlib.h> //设计一个算法在带头结点的非空单链表L中第一个最大值节点（最大值节点可能有多个）之前插入一个值为x的结点 typedef struct LNode { int data; str
如何实现单链表中结点的前插操作？
西小庄村高伟 的博客
06-04 4315
学过数据结构的小伙伴们都知道，如果想要对单链表进行插入操作，一般都需要寻找到要插入结点的前一个结点进行后插入操作，即 s->next = p->next; //s为插入结点，p为前一个结点 p->next = s; 但是如果要求给定一个结点p，要求在这个结点p之前前插一个结点s该怎么办呢，我们是无法找到结点p之前结点的指针的，所以按照正常的思路是无法进行插入的。 这时我们可以改变思路，偷天换日，巧妙解题，将 结点s 依旧插入 结点p 的之后， 再对结点s和p进行值交换，这样就完成了
单链表（C++实现）
qq_39559641的博客
04-07 3866
一、实验要求 (1).尾插法创建单链表，打印创建结果。 (2).头插法创建单链表，打印创建结果。 (3).销毁单链表。 (4).求链表长度。 (5).求单链表中第i个元素（函数），若不存在，报错。 (6).在第i个结点前插入值为x的结点。 (7).链表中查找元素值为x的结点，成功返回结点指针，失败报错。 (8).删除单链表中第i个元素结点。 (9).在一个递增有序的单链表L中插...
单链表的插入与删除算法
yychenxie21的专栏
10-11 1万+
的
【插入----在第i个结点前插入值为e的新结点,删除----删除第i个结点,单链表上的查找，插入，删除算法时间效率分析】
最新发布
forever_youyang的博客
10-19 479
因线性链表只能顺序存取，即在查找时要从头指针找起，查找的时间复杂度为O（n）。1.首先找到a（i-1）的存储位置p，保存想要删除的a的值。3.插入新结点：①新结点的指针域指向结点ai，②结点a（i-1）的指针域指向新结点。2.令p->next指向a(i+1).1.首先找到a（i-1）的存储位置。2.生成一个数据域为e的新结点。3.释放结点ai的空间。
数据结构之单链表在第i个元素之前插入元素的算法
weixin_34015860的博客
01-04 7034
     数据结构之单链表区第i个元素的算法算法思路：  1.声明一个结点p指向第一个结点，初始化j从1开始  2.当j&lt;i时就遍历链表，让p的指针向后移动，不断指向下一个结点，j累加1  3.若到链表末尾p为空，则说明第i个元素不存在  4.否则查找成功，在系统中生成一个空结点  5.将数据元素e赋给s-&gt;data  6.返回成功     单链表的数据结构：  typedef in...
在单链表的第i个位置插入一个节点 算法
jieranjie的博客
04-17 7129
在这里插入代码片
C语言算法基础-在一个单链表中值为y的结点前面插入一个值为x的结点
海风依旧
11-17 5619
C语言算法基础-在一个单链表中值为y的结点前面插入一个值为x的结点
《数据结构与算法》课程上机实验二（链表）_链表_fruitd55_C++_数据结构与算法_
10-04
编写一个程序，实现单链表的各种基本运算，并在此基础上完成初始化等各种基础功能。
JavaScript数据结构与算法之链表
10-22
链表就是线性表中针对顺序存储结构的一种优化手段，但是在javascript语言中由于数组的特殊性（自动更新引用位置），所以我们可以采用对象的方式做链表存储的结构
java数据结构与算法.pdf
01-04
包含了各种数据结构和算法（java）的实现方式和详解（图解），包括单双链表、环形链表（约瑟夫问题）、栈、后缀表达式、中缀表达式转后缀表达式、迷宫问题、八大排序算法、多种查找算法、哈希表、二叉树实现以及操作...
恋上数据结构与算法课件.rar
11-23
主要针对复杂度、链表、栈、队列、二叉树、B树、红黑树、集合。课件包含图片展示，容易理解，爱，就码上行动。
单向链表中插入新节点
weixin_43731183的博客
12-28 5117
在单向链表中插入新节点有三种情况： 1.加到第一个节点之前 2.加到最后一个节点之后 3.加到链表中间任一位置 先说1，新节点插入第一个节点之前，成为此链表的首节点：只需把新节点的指针指向链表原来的第一个节点，再把链表头指针指向新节点即可。 python的算法如下： newnode.next=first first=newnode 第二种情况，新节点插入最后一个节点之后：只需把链表最后一个节点的...
单链表的经典问题
weixin_42168411的博客
09-08 465
使用尾插法（头插法）创建一个带头节点（不带头节点）的单链表 单链表中的节点类型描述如下： typedef struct link { int data; link* next; }node,*linklist; 使用尾插法（头插法）创建一个带头节点的单链表 void Creat_list_Head(linklist& L) {//创建一个带头节点的单链表 //尾插法 /*int x; L = (node*)malloc(sizeof(node*));//先创建一个头节点 L->
链式存储中在第i个位置插入或删除的时间复杂度
热门推荐
Gavin的专栏
12-05 1万+
计算机的数据存储(物理结构)中有两种基本的方式：顺序存储和链式存储。顺序存储指的是用一段地址连续的存储单元依次存储数据；而链式存储中数据元素可以散乱的存储到存储单元中，每一个数据元素中包含数据项和下一个元素的存储地址。通过二者的定义不难看出，顺序存储在查找时的时间复杂度为O(1)，因为它的地址是连续的，只要知道首元素的地址，根据下标可以很快找到指定位置的元素，而对与插入和删除操作由于可能要在插入前或
线性表练习之Example045-有一个带头结点的单链表 L，设计一个算法使其元素递增有序
二木成林
03-31 4914
有一个带头结点的单链表 L，设计一个算法使其元素递增有序。
数据结构与算法 链表代码
06-09
好的，以下是一个简单的链表的实现代码，包括链表的创建、插入、删除和遍历等基本操作： ```python class Node: def __init__(self, data=None): self.data = data self.next = None class LinkedList: def __...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值