一、哈希表

1、哈希表在使用层面上可以理解为一种集合结构
2、如果只有key，没有伴随数据value，可以使用HashSet结构(C++中叫UnOrderedSet)
3、如果既有key，又有伴随数据value，可以使用HashMap结构(C++中叫UnOrderedMap)
4、有无伴随数据，是HashMap和HashSet唯一的区别，底层的实际结构是一回事
5、使用哈希表增(put)、删(remove)、改(put)和查(get)的操作，可以认为时间复杂度为o(1),但是常数时间比较大
6、放入哈希表的东西，如果是基础类型，内部按值传递，内存占用就是这个东西的大小
7、放入哈希表的东西，如果不是基础类型，内部按引用传递，内存占用是这个东西内存地址的大小（都是八字节）。

二、有序表

1、有序表在使用层面上可以理解为一种集合结构
2、如果只有key，没有伴随数据value，可以使用TreeSet结构(C++中叫OrderedSet）
3、如果既有key，又有伴随数据value，可以使用TreeMap结构(C++中叫OrderedMap)
4、有无伴随数据，是TreeSet和TreeMap唯一的区别，底层的实际结构是一回事
5、有序表和哈希表的区别是，有序表把key按照顺序组织起来，而哈希表完全不组织
5、红黑树、AWL树、size-balance-tree和跳表等都属于有序表结枸，只是底层具体实现不同
6、放入有序表的东西。如果是基础类型，内部按值传递。内存占用就是这个东西的大小。
7、放入有序表的东西，如果不是基础类型，必须提供比较器，内部按引用传递，内存占用是这个东西内存地址的大小。
8、不管是什么底层具体实现，只要是有序表，都有以下固定的基本功能和固定的时间复杂度。

三、链表

单链表的节点结构：

class Node {
public:
    int data;
    Node *next;

    Node(int da = 0, Node *p = NULL) {
        this->data = da;
        this->next = p;
    }
};

由以上结构的节点依次连接起来所形成的链叫单链表结构。
双链表的节点结构：

Class Node<V> {
v value ;
Node next;
Node last;
}

由以上结构的节点依次连接起来所形成的链叫双链表结构。
单链表和双链表结构只需要给定一个头部节点head，就可以找到剩下的所有的节点。

四、单链表反转

class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode pre = null, cur = head;
        while (cur != null) {
            ListNode node = cur.next;
            cur.next = pre;
            pre = cur;
            cur = node;
        }
        return pre;
    }
}

动图展示：

五、面试时链表解题的方法论

1）对于笔试，不用太在乎空间复杂度，一切为了时间复杂度
2）对于面试，时间复杂度依然放在第一位，但是一定要找到空间最省的方法
重要技巧:
1)额外数据结构记录（哈希表等)
2)快慢指针
判断一个链表是否为回文结构
【题目】给定一个单链表的头节点head，请判断该链表是否为回文结构。
【例子】1->2->1，返回true;1->2->2->1，返回true;15->6->15，返回true;1->2->3，返回false。

该题如果不考虑空间复杂度的话，解决方法可以用栈的数据结构来解决如上问题，首先将链表里所有的数据全部入栈，然后再进行出站操作，如果出栈的第一个数与链表中第一个数相同，则继续出栈，如果有中途有一个数据没有对上，则非回文，如果所有数据均出栈晚上，且所有数据都一致，则为回文。
我们也可以只将链表的后半部分入栈，然后再挨个出栈与链表的第一个数及其后面的数据进行对比，规则同上。
但是链表是一个未知长度的数据结构，我们怎么才能知道链表的中间值呢，这时候我们就需要快慢指针的操作，也就是快指针每次走两个节点，慢指针一次走一个节点，当快指针到达链表的结尾时，慢指针也就指向了链表的终点。
代码如下：

#include<iostream>
#include<vector>
using namespace std;
//定义一个节点的结构体，该结构体包括指针域和数值域
typedef struct ListNode {
	int val;
	struct ListNode* next;
}ListNode, *List;

//创建新节点
void createList(List L, int n) {
	//记录头结点
	ListNode* r = L;
	for (int i = 0; i < n; i++) {
		//创建一个新的节点
		ListNode* p = new ListNode;
		//给新的节点赋值
		cin >> p->val;
		//将新节点的结尾值赋空
		p->next = NULL;
		//将头结点的指针域指向新节点的地址
		r->next = p;
		//节点向下移动
		r = p;
	}
}

bool isPalindrome(List L) {
	vector<int> nums;
	while (L) {
		nums.push_back(L->val);
		L = L->next;
	}
	vector<int>temp = nums;
	reverse(temp.begin(), temp.end());
	for (int i = 0; i < nums.size(); i++) {
		if (nums[i] != temp[i])
			return false;
	}
	return true;
}

【例子】如果链表长度为N，时间复杂度达到O(N)，额外空间复杂度达到O(1)。
但如果限制额外空间复杂度达到O(1)时，我们就可以利用快慢指针的操作了，当慢指针找到了终点时，需要将慢指针之后的链表进行反转，反转完成后再设置两个指针，一个指针从链表开始与一个指针从链表结尾开始，一一进行对比，对比机制同上，当返回true或者fales之后我们再将后半部分的链表恢复到之前的状态，完成操作。

// 链表长这样

struct ListNode {
	int val;
	ListNode *next;
	ListNode() : val(0), next(nullptr) {}
	ListNode(int x) : val(x), next(nullptr) {}
	ListNode(int x, ListNode *next) : val(x), next(next) {}
};

class Solution {
public:
    bool isPalindrome(ListNode* head) {
		//如果传进来的是空指针或者只有一个值 直接返回true
        if(head->next == nullptr||head == nullptr)
            return true;
        //定义快慢指针
        struct ListNode *slow = head;
        struct ListNode *fast = head;
        
        //通过快慢指针找出右半边链表的头
        while(fast->next != nullptr && fast->next->next != nullptr){
                slow = slow->next;
                fast = fast->next->next;
        }
        fast = slow->next;	 //此时fast为右半链表的头地址
        slow->next = NULL;  //在左边结束的节点之后设置一个空值
        
        //下面是实现右半链表的反转
        struct ListNode *store = NULL;
        while(fast != nullptr){
        	//记录左边第一个节点的地址
            store = fast->next;
            //将右边头结点的指针域指向左边的尾部
            fast->next = slow;
            //两个辅助指针右移
            slow = fast;
            fast= store;
        }
	
		//右边最后一个节点的指针
        store = slow;
        //记录左边第一个指针
        fast = head.next;
        bool res = true;
        //最终就是从头到尾开始比较各结点的值 如果出现不相等的则return false
        while(slow != nullptr && fast != nullptr){
            if(slow->val != fast->val)
            {
	            res = false;
	            break;
            }                   
            //两个指针同时移动
            rhead = slow->next;
            fast = fast->next;
        }
        
        //将右半部分的链表再逆序回去
        //记录右边第一个节点的地址
        slow = store.next;
        store.next = NULL;
		while(slow != NULL)
		{
			fast = slow.next;
			slow.next = store;
			store = slow;
			slow = fast;
		}
		return res;
    }
};

六、将单向链表按某值划分成左边小、中间相等、右边大的形式

【题目】给定一个单链表的头节点head，节点的值类型是整型，再给定一个整数pivot。实现一个调整链表的函数，将链表调整为左部分都是值小于pivot的节点，中间部分都是值等于pivot的节点，右部分都是值大于pivot的节点。
【进阶】在实现原问题功能的基础上增加如下的要求
【要求】调整后所有小于pivot的节点之间的相对顺序和调整前一样
【要求】调整后所有等于pivot的节点之间的相对顺序和调整前一样
【要求】调整后所有大于pivot的节点之间的相对顺序和调整前一样
【要求】时间复杂度请达到O(N)，额外空间复杂度请达到O(1)。

 //将链表分成三个部分：
//分别为小于p、等于p、大于p
//分别用一串链表连接起来，最终，连接成一个链表
ListNode* listPartition2(ListNode* head, int num) {
	ListNode* sH = NULL;
	ListNode* sT = NULL;
	ListNode* eH = NULL;
	ListNode* eT = NULL;
	ListNode* bH = NULL;
	ListNode* bT = NULL;
	ListNode* next = NULL;
	while (head != NULL) {
		next = head->next;
		head->next = NULL;
		if (head->val < num) {
			if (sH == NULL) {
				sT = head;
				sH = head;
			}
			else {
				sT->next = head;
				sT = head;
			}
		}
		else if (head->val > num) {
			if (bH == NULL) {
				bH = head;
				bT = head;
			}
			else {
				bT->next = head;
				bT = head;
			}
		}
		else{
			if (eH == NULL) {
				eH = head;
				eT = head;
			}
			else {
				eT->next = head;
				eT = head;
			}
		}
		head = next;
	}
	if (sT != NULL) {
		sT->next = eH;
		eT = eT == NULL ? sT : eT;
	}
	if (eT != NULL) {
		eT->next = bH;
	}
	return sH != NULL ? sH : (eH != NULL ? eH : bH);
}

七、复制含有随机指针节点的链表

【题目】一种特殊的单链表节点类描述如下

class Node 
{
	int value;
	Node next;
	Node rand;
	Node(int val){
		value = val;
	}
}

rand指针是单链表节点结构中新增的指针，rand可能指向链表中的任意一个节点，也可能指向null。给定一个由Node节点类型组成的无环单链表的头节点head，请实现一个函数完成这个链表的复制，并返回复制的新链表的头节点。
【要求】时间复杂度0(N)，额外空间复杂度0(1)

ListNode* copyListWithRand(ListNode* head) {
	if (head == NULL) {
		return NULL;
	}
	ListNode* cur = head;
	1->1'->2
	while (cur != NULL) {
		//克隆出一个新的节点
		ListNode* node = new ListNode(cur->val);
		//将当前节点的指针指向赋值给克隆出新节点的指向
		node->next = cur->next;
		//将当前节点指向新的节点
		cur->next = node;
		//向下移动
		cur = node->next;
	}
	cur = head;
	while (cur != NULL) {
		//找到克隆节点
		ListNode* node = cur->next;
		//将原节点的rand赋给克隆节点的rand
		node->random = cur->random == NULL ? NULL : cur->random->next;
		//指针向下移动
		cur = node->next;
	}
	
	//开始分离原结点和克隆节点
	cur = head;
	//设置克隆节点的头
	ListNode* cloneHead = head->next;
	while (cur->next != NULL){   //注意边界处理，不然容易溢出
		//克隆结点
		ListNode* node = cur->next;
		//将克隆结点的指针指向赋值给原结点的指针域
		cur->next = node->next;
		//指针移动
		cur = node;
	}
	return cloneHead;
}

八、两个单链表相交的一系列问题

单链表可能有环，也可能无环。给定两个单链表的头节点 head1和head2，这两个链表可能相交，也可能不相交。请实现一个函数， 如果两个链表相交，请返回相交的第一个节点；如果不相交，返回null 即可。
【要求】如果两个链表长度之和为N，时间复杂度请达到0(N)，额外空间复杂度请达到O(1)。
思路：
1、首先判断两个链表是不是有环，采用快慢指针的方法，慢指针从链表第二个元素开始出发，快指针从链表第三个元素开始出发。如果链表有环，则两个指针必定会在环内相遇，如果快指针首先到达了NULL，则无环。然后快指针返回到链表的初始结点，慢指针不动，两个指针同时开始移动一个元素。则两个指针会在入环结点相遇。
2、判断完有环无环后则需要分情况进行讨论了。
**首先是两个链表都无环：**记录两个链表的长度，并且判断两个链表的最后一个结点的地是否一致，如果一致，则一定相交。然后长链表指针的初始值设定在两个链表长度插值处，短链表指针从头开始，两个指针相遇的第一个结点则是相交的第一个结点。
**两个都有环：**首先判断两个链表的入环结点是否一致，如果一致，返回到上一个两个都无环的链表相交问题，唯一的区别就是这两种情况在计数时的终止结点不一致，上面那种是两个指针都指向NULL结束，而此种情况是到第一个入环结点结束。而下图的一、三的情况判断是一致的，如果两个入环结点不一致，则使用其中的一个入环结点继续往下走，如果在走的过程中与另外一个入环结点相等，则为三情况，否则为1情况。如果为情况一，则没有相交结点，如果为情况三，两个入环结点的第一个相交点为两个其中任意一个都可以。
**一个有环一个无环的情况：**这种情况并不会相交。

/*
这个问题要考虑几种情况：
1. 两个链表都是单链表，判断入环节点
2. 两个链表都有环，判断入环节点
3. 一个链表有环，一个链表无环，则一定不想交。因为它们都是单链表。
*/
ListNode* findFirst(ListNode* head1, ListNode* head2){
	//判断两个结点是否有环
	ListNode* loop1 = isLoop(head1);
	ListNode* loop2 = isLoop(head2);
	//如果都无环
	ListNode* firstNode = NULL;
	if (loop1 == NULL && loop2 == NULL) {
		firstNode = noLoop(head1, head2);
	}	
	//如果都有环
	else if (loop1 != NULL && loop2 != NULL) {
		firstNode = bothLoop(head1, head2, loop1, loop2);
	}
	//如果一个有环一个无环
	else { 
		firstNode = NULL;
	}
	return firstNode;
}
 
//判断一个链表是否有环
//返回入环的节点
 ListNode* isLoop(ListNode* head) {
	if (head == NULL || head->next == NULL || head->next->next == NULL) {
		return NULL;
	}
	
	//设置快慢指针的初始位置
	ListNode* slow = head->next;
	ListNode* fast = head->next->next;
	
	//如果快指针或者慢指针到了NULL，则返回
	while (slow != fast) {
		if (fast->next == NULL || fast->next->next == NULL) {
			return NULL;
		}
		slow = slow->next;
		fast = fast->next->next;
	}
	//将快指针设置为头结点
	fast = head;
	//两个指针开始同时只移动一步
	while (slow != fast) {
		slow = slow->next;
		fast = fast->next;
	}
	//返回遇到的第一个结点
	return slow;
}
 
//都无环的情况
ListNode* noLoop(ListNode* head1, ListNode* head2) {
	if (head1 == NULL || head2 == NULL) {
		return NULL;
	}
	//设置暂存链表长度的变量n
	int n = 0;
	ListNode* cur1 = head1;
	ListNode* cur2 = head2;
	//记录第一个链表的长度
	while (cur1->next != NULL) {
		n++;
		cur1 = cur1->next;
	}
	//记录第二个链表与第一个链表的插值
	while (cur2->next != NULL){
		n--;
		cur2 = cur2->next;
	}
	//如果两个链表最后一个结点不相等，则不相交
	if (cur1 != cur2) {
		return NULL;
	}
	//如果第一个链表长，则将第一个头结点赋值给变量cur1，否则将第二个头结点赋值给变量cur1
	cur1 = n > 0 ? head1 : head2;
	//将其余一个链表的头节点赋值给变量cur2
	cur2 = cur1 == head1 ? head2 : head1;
	//对n进行取绝对值操作
	n = abs(n);
	//将较长链表的指针设定在两个链表长度差大小的结点处
	while (n != 0) {
		n--;
		cur1 = cur1->next;
	}
	//两个指针同时移动
	while (cur1 != cur2) {
		cur1 = cur1->next;
		cur2 = cur2->next;
	}
	//返回第一个相交的结点
	return cur1;
}
 
//都有环的情况
ListNode* bothLoop(ListNode* head1, ListNode* head2, ListNode* loop1, ListNode* loop2) {
	ListNode* cur1 = NULL;
	ListNode* cur2 = NULL;
	//首先如果符合上图中的情况二
	if (loop1 == loop2) {
		int n = 0;
		cur1 = head1;
		cur2 = head2;
		//记录链表一的长度
		while (cur1 != loop1) {
			n++;
			cur1 = cur1->next;
		}
		//记录链表一与链表二的长度
		while (cur2 != loop2) {
			n--;
			cur2 = cur2->next;
		}
		//与上一个情况一致
		cur1 = n > 0 ? head1 : head2;
		cur2 = cur1 == head1 ? head2 : head1;
		n = abs(n);
		while (n != 0){
			n--;
			cur1 = cur1->next;
		}
		while (cur1 != cur2){
			cur1 = cur1->next;
			cur2 = cur2->next;
		}
		return cur1;
	}
	//判断情况一三
	else {
		cur1 = loop1->next;
		//判断是否符合情况三
		while (cur1 != loop1){
			if (cur1 == loop2) {
				return loop1;
			}
			cur1 = cur1->next;
		}
		return NULL;
	}
}