AOP-Chap21-Linked Lists 链表

最新推荐文章于 2024-07-18 17:57:16 发布
最新推荐文章于 2024-07-18 17:57:16 发布
阅读量504 收藏 1
点赞数
分类专栏： ECE 551 文章标签： 链表 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Joyji99/article/details/121276417
版权

Chap21 Linked Lists

  • linked list—a data structure that is a linear sequence of nodes connected by pointers
  • 需要LinkedList class, 也需要Node class (private inner class of LinkedList) --> 一个class里面可以有别的class
template<typename T>
class LinkedList {
	class Node { 
	public:
		T data;
    	Node * next;
    };
	Node * head;
public：
	LinkedList() : head(NULL) {}
};
  • 编译器要求在类型完全声明(即到达结构或类声明的右花括号)之前，只能使用指向该类型的指针(recursive)
  • Node类是public，这样LinkedList可以直接access，Node is private to the LinkedList，所以不用担心外部影响
    请添加图片描述
  • 如果list为空，head为NULL
  • 可以通过改变指针所指向的位置来添加更多的元素(在任何位置)，而不是通过移动元素
  • 双向链表使反向遍历链表更加容易
template<typename T>
class LinkedList {
	class Node { 
	public:
		T data;
    	Node * next;
    	Node * prev;
    };
	Node * head;
	Node * tail;
	size_t size;
public：
	LinkedList() : head(NULL), tail(NULL), size(0) {}
};
  • circular list循环列表，没有最后一个节点，而是节点组成一个圆。圆形列表可以是单链的，也可以是双链的——通过反向链接，可以很容易地从相反的方向遍历圆形

1 Linked List Basic Operations

1.1 Add to Front

  • Adding to the front of a singly linked list
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
  • 时间复杂度O(1)
  • Adding to the front of a doubly linked list
    在这里插入图片描述
    prev直接是NULL，因为在最前插入没有prev，Node构造器来自动完成
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    请添加图片描述

1.2 Add to Back

  • Adding to the back of a doubly linked list
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

1.3 Searching

  • 如果想要list的第i个element，通常从头节点开始，遍历每个节点，沿着下一个指针从一个节点到下一个节点，需要O(N)， 而数组只需要O(1)，因为可以accsess a particular index
  • 将轻松访问特定索引的能力转换为无需复制元素就可以修改结构的能力

1.4 Copying

  • deep copy（copy constructor或copying assignment operator）需要遍历它的节点，创建具有相同数据的新节点，并将它们链接在一起，以便项以相同的顺序出现
  • 一种方法是以相反的顺序遍历我们的源列表，并将每个项添加到目标列表的前面(即调用已经编写的addToFront方法)。如果列表支持简单的反向迭代(即双向链接)，那么这个选项就简单而有效
  • 也可以遍历源列表，并将每一项添加到目标列表的后面。如果列表支持addToBack in O(1)(即有尾部指针)，那么这个选项也很简单和有效。
  • 如果列表没有尾指针，可以通过在执行复制时保留一个显式的指向列表末尾的指针来有效地执行这一操作——实际上是复制方法的局部临时尾指针。
  • 也可以重新设计列表以包含一个尾部指针

1.5 Destruction

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
请添加图片描述
请添加图片描述
8

2 Insert in Sorted Order

  • 3种方法

2.1 Pointer to Node Before

  • 在想要添加的节点之前搜索链表中的节点。我们有一个Node * current并遍历我们的list，寻找the situation where we want to set current’s next to the node we want to add，然后执行指针操作来插入新节点
  • corner case --> 想要添加到list的前面(因为想要更改head指针，而不是某个节点的下一个字段)，必须单独处理
  • Adding in sorted order to a linked list by searching for the node before where we want to add
    请添加图片描述
    请添加图片描述
    请添加图片描述
    请添加图片描述
  • 截图内容有错：应该是data > curr->next->data

2.2 Recursion

template<typename T>
class LinkedList {
	//other parts elided
private:
	class Node {
	public:
		T data;
		Node * next;
		Node(const T & d) : data(d), next(NULL) {} 
		Node(const T & d, Node * n): data(d), next(n) {}
	};
	//private recursive helper method
	Node * addSorted(const T & data, Node * current) { 
		//base case: insert before current
		if (current == NULL || data < current->data) {
			return new Node(data, current); 
		}
		//recursive case: add to the rest of list
		//then update current’s next
		current->next = addSorted(data, current->next); 
		return current;
	}
public:
	//public addSorted method: just takes data to add, 
	//has private recursive helper do the work
	void addSorted(const T & data) {
  		head = addSorted(data, head);	
  	}
};

请添加图片描述
请添加图片描述
这里假设有个空链表，head为NULL
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述

2.3 Pointer to a Pointer

请添加图片描述
在这里插入图片描述

3 Removing from a List

3.1 Remove from Front or Back

3.1.1 从Front删除O(1)

  • 从Front删除O(1) --> 在检查列表不是空的之后，将head指针的当前值存储在一个临时变量中，然后将head指针更新到head->next，然后删除原始的head节点(我们将其存储在临时变量中正是为了这个目的) --> 参照1.5 destruction
  • 如果列表是双向链接的，如果列表不是空的，我们需要更新new head node的previous field。同样，如果我们的列表有一个尾指针，我们需要检查它现在是否为空，如果是，将尾指针更新为NULL

3.1.2 从Back删除

  • 如果链表是双向链表并且有一个尾部指针，那么从链表的后面删除O(1)。在这种情况下，与remove from front类似，除了是在尾部而不是头部操作，使用previous field而不是next field。然后，更新new tail的next field(如果非空)，如果列表为空，则将head设置为NULL
  • 如果列表是单链接的(或没有尾指针)，我们需要遵循一种O(N)算法来删除一个元素(后面看到)。如果需要频繁地从列表后面删除，最好使列表具有双链接并有一个尾部指针(可以实现O(1))

3.2 Other Removals: Pointer to Node Before

  • 如果想要删除元素的数据是42，则要找到一个node，current->next->data是42。如果列表是双向链接的，则找到想要的节点，然后后退一个节点(通过previous pointer)
  • 然而，删除列表中的第一个节点仍然是一种特殊情况——需要更新head pointer，而不是任何节点的next field
  • 找到前一个节点后，首先需要用temp variable指向要删除节点(即current->next)，以便稍后删除它。然后更新current->next to be current->next->next，这将从列表中删除所需删除的节点
  • 如果是双向链表，则需要更新current->next->prev(如果current->next不是NULL)。如果有一个尾指针，需要在删除列表的最后一个节点时更新current->next->prev

3.3 Other Removals: Recursion

template<typename T>
class LinkedList {
	//other parts elided
private:
	class Node {
	public:
		T data;
		Node * next;
		Node(const T & d) : data(d), next(NULL) {} 
		Node(const T & d, Node * n) : 	data(d), next(n) {}
	};
	//private recursive helper	
	Node * remove(const T & data, Node * current) {
		if (current == NULL) { //base case: empty list
			return NULL;       //answer is empty list
		}
		if (data == current->data) { //base case: node to remove
			Node * ans = current->next; //answer will be "everything after"
			delete current; //delete node we are removing
			return ans; //return our answer
		}	
		//revursive case: remove from rest of list, then update current's next
		current->next = remove(data, current->next);
		return current;
	}
public:
	//public remove method: just take data to remove, has private recursive helper do the work
	void remove(const T & data) {
		head = remove(data, head);
	}		
};

3.4 Other Removals: Pointer to a Pointer

  • 使用Node **，它从&head开始，表示“我们可能想要更改的框”，然后沿着列表迭代，找到要删除的位置。一旦找到它，就执行适当的指针操作(将所指向的方框更改为要删除的node之后的下一个node)

3.5 Remove All Occurrences

template<typename T>
class LinkedList {
	//other parts elided
private:
	//private recursive helper
	//templated over whether to remove all or one 
	template<bool removeAll>
	Node * remove(const T & data, Node * current) {
		if (current == NULL) { 
			return NULL;
		}
		if (data == current->data) {
			Node * ans;
			if (removeAll) {
    			ans = remove<removeAll>(data, current->next);
  			}
			else {
				ans = current->next;
			}
			delete current; 
			return ans;
		}
		current->next = remove<removeAll>(data, current->next); 
		return current;
	}
public:
	//public remove methods: just takes data to remove, 
	//has private recursive helper do the work
	void remove(const T & data) {
		head = remove<false>(data, head); 
	}
	void removeAll(const T & data) { 
		head = remove<true>(data, head);
	}
};

4 Iterators

  • iterators --> objects that 封装数据结构中的位置，并提供了一种无需了解结构内部就可以访问和移动元素的方式
  • 链表的lterator可以使得下面为O(N) algorithm
LinkedList<T>::iterator it = myList.begin();
while (it != myList.end()) {
	T & current = *it;
	//do stuff with current
	++it;
}

4.1 Implementation

  • 在LinkedList类中编写一个内部类来实现迭代器。作为LinkedList的内部类，迭代器是类的一部分，因此它可以了解列表的实现细节(并访问私有成员)
template<typename T>
class LinkedList {
	class Node {
		//contents of Node elided
	};
public:
	class iterator { 
		Node * current;
	public:
		iterator() : current(NULL) {}
		explicit iterator(Node * c) : current(c) {} //explicit关键字修饰的类构造函数，不能进行自动地隐式类型转换，只能显式地进行类型转换
		iterator & operator++() { //++i
  			current = current->next;
			return *this; 
		}
		iterator & operator++(int) { //i++
			iterator ans(current); 
			current = current->next; 
			return ans;
		}
		T & operator*() const {
			return current->data; 
		}
		T * operator->() const { 
			return &current->data;
		}
		bool operator!=(const iterator & rhs) const {
			return current != rhs.current; 
		}
		bool operator==(const iterator & rhs) const { 
			return current == rhs.current;
		}
		//possibly other methods	
	};
	iterator begin() {
		return iterator(head); 
	}
	iterator end() {
		return iterator(NULL);
	}	
	//other things in LinkedList elided
};	

/*
explicit关键字只对有一个参数的类构造函数有效, 如果类构造函数参数大于或等于两个时, 是不会产生隐式转换的, 所以explicit关键字也就无效了
*/
  • explicit关键字详解
  • 以上迭代器是forward iterator，只能在前向方向上遍历结构
  • 如果是双向链表，则添加–操作符使迭代器成为双向迭代器，该操作符将沿着previous links backwards遍历列表
  • const_iterator --> read-only access to the list --> overload begin and end
template<typename T>
class LinkedList {
	class Node {
		//contents of Node elided
	};
public:
	class iterator { 
		//as above
	};
	class const_iterator {
		//similar, but const Node *
   		//returns const &s/const *s
   	};
   	iterator begin() { return iterator(head); }
	iterator end() { return iterator(NULL); }
	const_iterator begin() const { return const_iterator(head); } 
	const_iterator end() const { return const_iterator(NULL); } 
	//other things in LinkedList elided	
};

5 Uses for ADTs

5.1 Stacks

  • stack是LIFO后进先出，可以通过在链表的同一末端添加和删除来实现这种行为(添加到前面和从前面删除通常是最简单的 --> O(1))

5.2 Queues

  • FIFO先进先出，可以通过在链表的两端进行添加和删除来实现这种行为——如果向链表的后面(即尾部)添加，那么就从前面(即头部)删除。如果有尾指针，就可以实现这两个操作O(1)

5.3 Sets

  • 通过将元素添加到列表中来添加元素;通过遍历列表中的元素来检查set是否包含元素，测试每个元素是否匹配(如果匹配返回true，如果不匹配返回false);和通过从列表中删除元素来删除元素
  • 如果添加一个元素两次，然后又删除了它(在一个集合中，正确的行为是元素不再在集合中)。可以用两种方法来解决这个问题:要么在添加时检查重复，要么在删除时删除所有的重复。前者的优点是，列表会更小，但缺点是，添加变成了一个O(N)操作(必须遍历列表)

5.4 Maps

  • 通过在每个节点中存储键值对来实现一个带有链表的映射。
  • 通过将键/值对插入到列表中来添加键/值对(可能首先删除旧的映射);通过遍历列表来查找键的值(检查每个节点是否匹配，并返回匹配的值);通过找到匹配的节点并删除它，从列表中删除一个键

6 STL List

不乖不乖
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring-aop-5.0.4.RELEASE.jar
12-07
spring-aop-5.0.4.RELEASE.jar。
spring-boot-starter-aop及其使用场景说明
吴声子夜歌的博客
11-21 1万+
如今，AOP（Aspect Oriented Programming）已经不是什么崭新的概念了，在经历了代码生成、动态代理、字节码增强甚至静态编译等不同时代的洗礼之后，Java 平台上的 AOP 方案基本上已经以 SpringAOP 结合 AspectJ 的方式稳固下来（虽然大家依然可以自己通过各种字节码工具偶尔“打造一些轮子”）。 现在 Spring 框架提供的 AOP 方案倡导了一种各取所长的...
Spring AOP -- Spring入门（五）
HHX_01的博客
05-06 7827
为了巩固所学的知识，作者尝试着开始发布一些学习笔记类的博客，方便日后回顾。当然，如果能帮到一些萌新进行新技术的学习那也是极好的。作者菜菜一枚，文章中如果有记录错误，欢迎读者朋友们批评指正。（博客的参考源码以及文章末尾链接的学习视频源码可以在我主页的资源里找到，如果在学习的过程中有什么疑问欢迎大家在评论区向我提出）(xml配置对比注解开发）（博客的参考源码以及文章末尾链接的学习视频源码可以在我主页的资源里找到，如果在学习的过程中有什么疑问欢迎大家在评论区向我提出）
Spring AOP--图解AOP思想
aq_112700的博客
07-27 3203
AOP使用场景：       可以看出上图场景导致代码冗余度特别高，这个问题我们可以采取两种办法来解决：    一，将复用代码抽取成一个方法，在需要的位置手动调用此方法    二，运用AOP思想，不需要在业务方法中手动调用抽取的方法，通过配置自动执行 方法一：  普通解决方案，比较简单，这里不再详细叙述。下面进入方法二------本篇文章的核心阶段。 方法二： 学习AOP思想之...
SpringAOP学习--SpringAOP简介及原理
热门推荐
u012098021的博客
05-15 6万+
前文对AOP做了介绍，实际项目中，一般不会直接上手手动实现aop，而是使用一些高级封装的aop实现，如SpringAOP。 Spring是一个广泛应用的框架，SpringAOP则是Spring提供的一个标准易用的aop框架，依托Spring的IOC容器，提供了极强的AOP扩展增强能力，对项目开发提供了极大地便利。 前文提到AOP的实现有AspectJ、JDK动态代理、CGLIB动态代理，SpringAOP不是一种新的AOP实现，其底层采用的是JDK/CGLIB动态代理。 JDK动态代理回顾 上一篇简单介绍了
开发工具 spring-aop-4.3.6.RELEASE
05-31
开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE...
spring-aop-5.3.26.jar
04-22
spring-aop.jar 各个版本，免费下载 Spring 的面向切面编程，提供 AOP（面向切面编程）的实现。 如果下载不了，关注我，评论区联系我。
spring-aop-6.0.10.jar
04-22
spring-aop.jar 各个版本，免费下载 Spring 的面向切面编程，提供 AOP（面向切面编程）的实现。 如果下载不了，关注我，评论区联系我。
spring-aop-6.0.8.jar
04-22
spring-aop.jar 各个版本，免费下载 Spring 的面向切面编程，提供 AOP（面向切面编程）的实现。 如果下载不了，关注我，评论区联系我。
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1062
可以参考以下视频。
数据结构day3
最新发布
qq_55245263的博客
07-18 283
顺序表实现学生管理系统
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 242
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
数据结构初阶·排序算法(内排序)
2301_79697943的博客
07-18 916
目前常见的排序算法有9种，冒泡排序，选择排序，插入排序，希尔排序，快速排序，归并排序，计数排序，基数排序，桶排序。实际生活中排序的应用也是有限的，今天我们介绍其中7个，基数排序和桶排序不介绍。介绍常用的即可。顺带一嘴，本文里面所有的排序都是内排序，也就是在内存里面进行排序的，还有一种排序叫做外排序，即是在磁盘里面进行排序的，这种排序具有记忆性，外排序用到的就是归并排序，因为归并排序有一个特点就是空间复杂度为O(N)。好了正文开始。
数据结构第32节 无锁编程
hummhumm的专栏
07-17 874
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
数据结构第35节 性能优化 算法的选择
hummhumm的专栏
07-18 730
算法的选择对于优化程序性能至关重要。不同的算法在时间复杂度、空间复杂度以及适用场景上有着明显的差异。下面我将结合具体的代码示例，来讲解几种常见的算法选择及其优化方法。
【Java--数据结构】二叉树
2301_80898480的博客
07-16 1101
如有错误，欢迎指出~
24暑假算法刷题 | Day16 | LeetCode 513. 找树左下角的值，112. 路径总合，106. 从中序和后序遍历序列构造二叉树
weixin_54468359的博客
07-18 1099
24暑假刷题day15打卡 二叉树进阶
数据结构之细说链表
m0_73634434的博客
07-17 1078
这里while循环的条件判断必须是tail->next->next，因为我们需要释放最后一个节点的地址，所以需要利用它前面一共节点来释放它，然后将tail->next置空，如果我们直接找最后一个地址然后将它释放前面一个节点就会指向被释放的地址变成一个野指针，因为我们已经找不到前面一个节点的位置了。头插就比较简单了，将该节点连接在第一个节点和第二个节点之间就可以了，但是我们需要先连接第二个和新节点，如果先连接第一个节点和新节点就会找不到第二个节点的地址。下面我们给出链表的构成，看看链表是如何解决这些问题的。
spring-aop-4.3.4jar包
11-19
spring-aop-4.3.4.jar是Spring框架中的一个核心jar包，用于实现面向切面编程（AOP）。AOP是一种程序设计思想，通过在程序运行期间动态地将代码织入到现有的类和方法中，来实现一些跨越多个组件的功能，如日志记录、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值