算法学习笔记（四）链表

最新推荐文章于 2024-03-13 17:16:12 发布

shaluey

最新推荐文章于 2024-03-13 17:16:12 发布

阅读量173

点赞数

文章标签：链表算法数据结构

本文链接：https://blog.youkuaiyun.com/qq_45952394/article/details/120618140

版权

（一）哈希表

unordered_map和unsorted_set

unordered_map Key-> Value

unordered_set Key

hastable中的东西，若为基础类型，内部按值传递，否则按引用传递（内存占用为这个东西内存地址的大小）如装入hashtable的东西为struct，记录内存地址作为key

如 nodeA=new Node(1); nodeB=new Node(1) 两个不一样，因为内存地址不一样

可以认为hashtable增删改查都为常数时间的操作

内部结构无区别，更新Value而不更新Key

有序表和hashtable的区别：

有序表是把key按照顺序组织起来，哈希表不组织

链表解题的方法论：

笔试追求做出来，不追求空间复杂度

面试时间复杂度占第一也要找到空间最小的方法

额外技巧：

（1）额外数据结构的使用如hashtable

（2）快慢指针

（二）题目练习

（1）实现单向链表反转时间复杂度O（n）空间复杂度O（1）

~~顺便用c++的形式写了一个链表，手有点生，犯了好几个错orz~~

#include <bits/stdc++.h>
using namespace std;

struct node {
	int val;
	node *next;
};

class Linked_list {
	private:
		node *head;
		int length;
	public:
		Linked_list() {
			head = nullptr;
            length=0;
		}
		void Insert_node(int value) {
			node *temp = new node();
			temp->val = value;
			node *p = head;
			temp->next = nullptr;
			if (head == nullptr) {
				head = temp;
			} else {
				while (p->next)
					p = p->next;
				p->next = temp;
			}

			length++;
		}
		void Move_node(int value) {
			node *p = new node();
			p->next = head;
			node *dummy = p;
			//if (p->next)
			//	cout << "11111" << endl;
			while (p->next != nullptr) {
				if (p->next->val == value) {
					node *temp = p->next;
					p->next = p->next->next;
					delete (temp);
					length--;
				} else
					p = p->next;
			}
			head = dummy->next;
			delete (dummy);
		}
		void Print() {
			node *p = head;
			while (p) {
				cout << p->val << endl;
				p = p->next;
			}
		}
		int Get_length() {
			return length;
		}
		void Reverse() {
			node *p, *s, *t;
			p = head;
			t = nullptr;
			while (p) {
				s = p->next;
				p->next = t;
				t = p;
				p = s;
			}
			head = t;

		}
};


int main() {
	Linked_list L;
	L.Insert_node(3);
	L.Insert_node(5);
	L.Insert_node(7);
	L.Insert_node(3);
	L.Insert_node(9);
	L.Print();

	L.Reverse();
    cout <<" 反转之后：" << endl;
	L.Print();
	L.Move_node(3);
    cout << "删除节点之后：" << endl;
	L.Print();
}

（2）实现双向链表的反转

（3）打印两个有序链表的公共部分实现复杂度O(n) 额外空间复杂度O(1)