链表

最新推荐文章于 2021-08-31 21:54:30 发布
最新推荐文章于 2021-08-31 21:54:30 发布
阅读量158 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1059682127/article/details/104387123
版权

第2章 算法复杂度

算法的时间复杂度定义（大O记法）

语句总执行次数T(N)跟问题规模N的函数，时间复杂度记作：T(N) = O(f(N)),表达随着问题规模的增大，算法执行时间的增长率和f(N)的增长率相同，f(N)是问题规模N的某个函数。

O(1)：常数阶 O(N):线性阶 O(N^2)：平方阶

 总结：参考大话数据结构第二章小节

第3章 线性表

3.2 线性表的定义

线性表：零个或多个元素的有限序列（有序，有前驱，有后继）

3.3 线性表的顺序存储结构

用一段地址连续的存储单元依次存储线性表的数据元素

3.4 线性表的链式存储结构

数据域：存储数据元素信息的域

指针域：存储直接后置位置的域

结点：包括数据域和指针域

头指针：链表第一个结点的存储位置（一定不为空，链表的必要元素）

头结点：在第一个结点前设的节点，其指针域存储指向第一个节点的指针（若链表有头结点，头指针是指向头结点的指针）（有了头结点，就可以对链表第一元素进行删除操作或者插入操作）

 

 

//链表结点定义
struct ListNode {
	int val;
	ListNode *next;
	ListNode(int x) : val(x), next(NULL) {}
};

 删除链表的节点：

版本1：val: int 解法O(N)/O(1)使用头结点
版本2：val: ListNode 解法：信息交换法O(1)/O(1)

/*版本1：val: int 解法O(N)/O(1)
版本2：val: ListNode 解法：信息交换法O(1)/O(1)
*/

class Solution {
public:
	//使用头结点，万一要删除第一结点n

	ListNode* deleteNode(ListNode* head, int val) {
		ListNode* dummyNode = new ListNode(0);
		dummyNode->next = head;
		ListNode* cur = dummyNode;
		while (cur != NULL && cur->next != NULL) {  //注意先判断cur != NULL,再判断cur->next != NULL
			//遇到则删除该结点
			if (cur->next->val == val) {
				cur->next = cur->next->next;
			}
			cur = cur->next;
		}
		return dummyNode->next;
	}
	//val: ListNode 解法：信息交换法
	//当输入参数为删除的结点时，可以采用信息交换，即deleteNode->val = deleteNode->next->val; deleteNode->next = deleteNode->next->next;
	//当删除结点不在尾结点时，可以实现常数时间删除
	//当删除结点是尾结点，无法找到尾结点的后一元素，所以需要从头遍历
	//时间复杂度:(O(1)*(N - 1) + 0(N))/N = O(1)

	ListNode* deleteNode2(ListNode* head, ListNode* deleteNode) {
		if (head == NULL || deleteNode == NULL) return NULL;
		if (deleteNode->next != NULL) {
			deleteNode->val = deleteNode->next->val;
			deleteNode->next = deleteNode->next->next;
		}
		//头尾结点相同
		else if (head == deleteNode) return NULL;
		else {
			ListNode* cur = head;
			//找到倒数第二结点
			while (cur->next != NULL && cur->next->next != NULL) {
				cur = cur->next;
			}
			cur->next = NULL;
		}
		return head;
	}
};

链表设计：

版本1：单向表
版本2：双向表


/*
设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

在链表类中实现这些功能：


	get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
	addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
	addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
	addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val  的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
	deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。


*/

//执行用时:40 ms, 在所有 C++ 提交中击败了98.40%的用户
//内存消耗 :19.3 MB, 在所有 C++ 提交中击败了21.27%的用户
class MyLinkedList {
private:
	//单链表版本
	struct ListNode {
		int val;
		ListNode* next;
		ListNode(int x) :val(x), next(NULL) {}
	};
	ListNode* head;
public:
	MyLinkedList() :head(NULL) {
	}

	//获取链表中第index个结点的值
	int get(int index) {
		ListNode* cur = head;
		int i = 0;
		while (cur && i < index) {
			cur = cur->next;
			++i;
		}
		//不是末尾
		if (cur) return cur->val;
		else return -1;
	}

	//在头结点前面新增结点
	void addAtHead(int val) {
		ListNode* newHead = new ListNode(val);
		newHead->next = head;
		head = newHead;   //指向第一个结点
	}
	//在链表末尾添加元素
	/** Append a node of value val to the last element of the linked list. */
	void addAtTail(int val) {
		//链表为空，直接将新节点作为头结点
		ListNode* p = new ListNode(val);
		if (!head) {
			head = p;
			return;
		}
		//链表不为空，则在尾部添加，找到尾结点
		ListNode* cur = head;
		while (cur->next) {
			cur = cur->next;
		}
		cur->next = p;
	}

	//在链表中第index个结点之前添加值为val的结点
	void addAtIndex(int index, int val) {
		ListNode* p = new ListNode(val);
		if (index <= 0) {
			addAtHead(val);  //index <= 0, 在头部插入
			return;
		}
		ListNode* cur = head;
		int i = 0;
		//获得第index - 1个结点
		while (cur && i < index - 1) {
			cur = cur->next;
			++i;
		}
		//一种是cur == NULL，说明超出尾结点，不添加
		//另一种是cur != NULL,添加结点(包括)
		if (cur) {
			p->next = cur->next;
			cur->next = p;
		}

	}

	//删除第index个结点
	void deleteAtIndex(int index) {
		if (head == NULL || index < 0) return;
		if (index == 0) {
			head = head->next;
			return;
		}
		ListNode* cur = head;
		int i = 0;
		//找到第index - 1个元素
		while (cur && i < index - 1) {
			cur = cur->next;
			++i; //用前置++更好
		}
		if (cur) {
			//如果index - 1是最后一个结点
			if (!cur->next) return;
			else {
				cur->next = cur->next->next;
			}
		}
	}
	//计算链表长度
	int length() {
		int i = 0;
		ListNode* cur = head;
		while (cur) {
			++i;
			cur = cur->next;
		}
		return i;
	}
};


//双向链表版
class MyLinkedList {
private:
	struct ListNode {
		int val;
		ListNode* next;
		ListNode* prev;
		ListNode(int x) :val(x), prev(NULL), next(NULL) {}
	};
	ListNode* head;
	ListNode* tail;
	int size;
public:
	MyLinkedList() :size(0), head(NULL), tail(NULL) {
	}

	//获取链表中第index个结点的值
	int get(int index) {
		ListNode* cur = head;
		int i = 0;
		while (cur && i < index) {
			cur = cur->next;
			++i;
		}
		//不是末尾
		if (cur) return cur->val;
		else return -1;
	}

	//在头结点前面新增结点
	void addAtHead(int val) {
		ListNode* newHead = new ListNode(val);
		if (head) {
			newHead->next = head;
			head->prev = newHead;
			head = newHead;   //重定位head

		}
		else {
			//如果头尾结点都不存在
			head = tail = newHead;

		}
		++size; //累计数量
	}
	//在链表末尾添加元素
	/** Append a node of value val to the last element of the linked list. */
	void addAtTail(int val) {
		//链表不为空，直接将新节点作为头结点
		ListNode* p = new ListNode(val);
		if (tail) {
			tail->next = p;
			p->prev = tail;
			tail = p;   //重定位tail
		}
		else {
			tail = head = p;
		}
		++size;
	}

	//在链表中第index个结点之前添加值为val的结点
	void addAtIndex(int index, int val) {
		ListNode* p = new ListNode(val);
		if (index <= 0) {
			addAtHead(val);  //index <= 0, 在头部插入
			return;
		}
		if (index == size) {
			addAtTail(val);
			return;
		}
		if (index > size) return;
		//寻找第index个结点cur，记录前面一个结点before，before->next = p...
		ListNode* cur = head;
		ListNode* b = NULL;
		int i = 0;
		while (cur && i < index) {
			b = cur;
			cur = cur->next;
			++i;
		}
		if (cur) {
			b->next = p;
			p->prev = b;
			p->next = cur;
			cur->prev = p;
			++size;
		}
	}

	//删除第index个结点
	void deleteAtIndex(int index) {
		//如果索引不在范围内，不作处理
		if (index < 0 || index > size - 1) return;
		//如果删除头结点
		if (index == 0) {
			head = head->next;  //重定位head
			if (head) {
				head->prev = NULL;
			}
			else {
				tail = NULL; //重定位tail
			}
			--size;
			return;
		}
		//删除尾结点
		if (index == size - 1) {
			tail = tail->prev; //重定位尾结点
			//不用单结点，前面index = 0已经考虑过了
			tail->next = NULL;
			--size;
			return;
		}
		//删除中间结点,先找到索引为index的结点
		ListNode* b = NULL, *cur = head;
		int i = 0;
		while (cur && i < index) {
			b = cur;
			cur = cur->next;
			++i;
		}
		b->next = cur->next;
		cur->next->prev = b;
		--size;
	}
	//计算链表长度
	int length() {
		return size;
	}
};

a1059682127
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表填空题（打印）1
08-08
【链表基础知识】 链表是一种线性数据结构，与数组不同，它不连续存储数据，而是通过节点间的指针连接。每个节点包含数据部分和一个指向下一个节点的指针。链表分为单向链表、双向链表和循环链表等类型。 1. **...
Leetcode-707. 设计链表
han jan的博客
08-05 4723
设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1...
链表面试题--逆置、删除指定val
xy199931的博客
07-27 224
逆置/反转 依次遍历每个结点**   ListNode cur = head;   while(cur ! = null){ cur = cur . next ; } 把遍历的结点头插到一个新链表上   1. 什么是新链表（链表第一开始是空链表）     ListNode newList = null ;   2. 如何头插 cur 到新链表 newList     cur.next = ne...
链表常见面试题( 建议收藏！！)
一朵花花
08-31 3686
链表面试题????1.删除链表中等于给定值 val 的所有节点2.二级目录3.三级目录 1.删除链表中等于给定值 val 的所有节点 题目： 题目链接： https://leetcode-cn.com/problems/remove-linked-list-elements/. 思考： 用tmp记录当前节点，若tmp 的下一个节点不为空且下一个节点的节点值等于给定的 val，则需要删除tmp的下一个节点 2.二级目录 3.三级目录 ...
LeetCode刷题之链表 第707题 设计链表
qq_36917571的博客
03-09 127
题目描述 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。 addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成
C#LeetCode刷题之#707-设计链表（Design Linked List）
热门推荐
比特飞
09-27 1万+
问题 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(index)：获取链表中第 index 个节点的值。如果索引无效，则...
合并链表_合并链表_
10-03
合并链表是一个常见的数据结构问题，它涉及到对链表的操作，特别是涉及排序和连接操作。在本场景中，我们有两个非递减有序的链表A和B，目标是创建一个新的链表C，这个新链表C同样是非递减有序的。下面我们将详细探讨...
单链表实现双向循环链表_链表_
09-29
单链表实现双向循环链表单向链表存在一个弊端就是，当需要获取某个结点p的前驱时，需要从头指针开始遍历链表，获得“前驱”的执行时间为O(n)，为了克服单向链表的这种缺点，可以利用双向链表。在双向链表中有两个...
C语言实现静态链表
08-18
C语言实现静态链表 C语言实现静态链表是指在C语言中使用静态数组来实现链表结构的方法。静态链表是一种特殊的链表结构，它的内存是事先分配好的，链表的每个结点都是一个固定长度的结构体，而不是像动态链表那样...
JAVA OJ练习第12题——设计链表
weixin_45662626的博客
12-09 387
707. 设计链表 题目要求：在链表类中实现这些功能： get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。 addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。 addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。 addAtIndex(index,val)：在链表中的...
设计链表（Leetcode第707题）
前景
03-23 270
此题涵盖了链表的常见操作，是练习链表操作非常好的一道题目 此题涵盖了链表的常见操作，是练习链表操作非常好的一道题目 此题涵盖了链表的常见操作，是练习链表操作非常好的一道题目 题目描述： 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val和next。val是当前节点的值，next是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性prev以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： g...
数据结构学习笔记（一）—— 链表
qq_41122414的博客
03-01 374
数据结构学习笔记（一）—— 链表 （先在这里悄悄打个小广告 !^_^） 我看的是青岛大学王卓老师的数据结构视频，真的讲的非常好，每个点都讲得很仔细 B站链接：数据结构与算法基础（青岛大学-王卓） 链表 链表是一种很基础的数据结构，也可以利用链表构造其他的高级数据结构，掌握其中的一些思想也会方便学习之后的高级数据结构 一、基本结构与思想 传统的存储方式很容易想到用数组来实现。 用数组存储数据优点有很多比如： 创建起来比较方便 因为每个元素存储在连续的一片内存空间上，这样读取某个特定位置的元素就可以通
后序遍历
a1059682127的博客
03-01 1464
//lt145 /* 后序遍历 //思路1：递归 //思路2：迭代 //思路3：前序+反转（先根-右-左） //思路4：插入队首 */ class Solution { public: //思路1：递归 vector<int> postorderTraversal(TreeNode* root) { vector<int> res; postorderHe...
二叉树中的最大路径和
a1059682127的博客
03-02 914
//lt124 /* 124. 二叉树中的最大路径和 给定一个非空二叉树，返回其最大路径和。 本题中，路径被定义为一条从树中任意节点出发，达到任意节点的序列。该路径至少包含一个节点，且不一定经过根节点。 示例 1: 输入: [1,2,3] 1 / \ 2 3 输出: 6 示例 2: 输入: [-10,9,20,null,null,15,7] -10...
从中序与后序遍历序列构造二叉树
a1059682127的博客
03-01 640
//lt106 /* 从中序与后序遍历序列构造二叉树 根据一棵树的中序遍历与后序遍历构造二叉树。 注意: 你可以假设树中没有重复的元素。 例如，给出 中序遍历 inorder = [9,3,15,20,7] 后序遍历 postorder = [9,15,7,20,3] 返回如下的二叉树： 3 / \ 9 20 / \ 15 7 //思路1：分治（递归） */ c...
树
a1059682127的博客
02-29 394
树的定义 1、非空树有且只有一个根节点 2、子树互不相交 树的节点：包含一个数据元素和若干指向其它子树的分支 节点的度：节点拥有的子树数 叶节点：度为0的节点 树的度：树内节点的度的最大值 孩子：节点的子树的根，该节点称为孩子的双亲 节点的祖先：从根节点到该节点所经分支上的所有节点 堂兄...
从前序与中序遍历序列构造二叉树
a1059682127的博客
03-01 333
//lt105 /* 从前序与中序遍历序列构造二叉树 根据一棵树的前序遍历与中序遍历构造二叉树。 注意: 你可以假设树中没有重复的元素。 例如，给出 前序遍历 preorder = [3,9,20,15,7] 中序遍历 inorder = [9,3,15,20,7] 返回如下的二叉树： 3 / \ 9 20 / \ 15 7 //思路1：分治（递归） */ c...
二叉树的中序遍历
a1059682127的博客
03-01 302
//lt94 /* 二叉树的中序遍历 给定一个二叉树，返回它的中序 遍历。 示例: 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,3,2] 进阶: 递归算法很简单，你可以通过迭代算法完成吗？ //思路1：递归 //思路2:迭代（显式栈） //思路3：莫里斯遍历O(N)/O(1) */ /** * Definition for a binary...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值