【学习笔记&思考】代码随想录03|链表|1-4节

链表：一种通过指针串联在一起的线性结构。
节点：由数据域和指针域（存放指向下一个节点的指针）两部分组成。

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(NULL) {}  // 自定义构造函数
};

// 调用自定义构造函数初始化节点
ListNode* head = new ListNode(5);

// 调用系统默认构造函数初始化节点
ListNode* head = new ListNode();
head->val = 5;

链表类型：
1. 单链表
节点：1个数据域、1个指针域
头节点（入口节点）称为head。
一般最后一个节点指向null（空指针）。

2. 双链表
节点：1个数据域、2个指针域（指向下一个和上一个节点）
既可以向前查询，也可以向后查询

 3. 循环链表
首尾相连，可用来解决约瑟夫环问题

链表的存储方式：不连续分布（散乱分布，分配取决于OS内存管理机制），通过指针域的指针链接到内存中各个节点，串联在一起。

链表的操作：
删除节点（注意养成习惯手动释放清理删除的节点内存，Java和Python不用手动管理内存）
添加节点
查找O（n）删除O（1）

性能分析：

第2节是203移除链表元素removeElements：删除链表中等于给定值val的所有节点；

 一开始想到的思路就是让节点next指针直接指向下下一个节点。如果删除的是head节点呢？

①直接使用原来的链表进行删除操作，将头节点向后移动一位，需要单独写一段代码逻辑来实现；

class Solution203_0 {
public:
	ListNode* removeElements(ListNode* head, int val) {
		while (head != NULL && head->val == val) {
			ListNode* tmp = head;
			head = head->next;
			delete tmp;
		}
		ListNode* cur = head;
		while (cur != NULL && cur->next != NULL) {  
// 有前一个while循环要么head==NULL要么head->val不等于val值
// 所以要判断cur不等于NULL进入循环判断cur->next是否等于val
			if (cur->next->val == val) {
				ListNode* tmp = cur->next;
				cur->next = cur->next->next;
				delete tmp;
			}
			else {
				cur = cur->next;
			}
		}
		return head;
	}
};

②设置一个虚拟头节点dummy node进行删除操作，以统一的逻辑移除节点，注意return dummyNode->next。

class Solution203_1 {
public:
	ListNode* removeElements(ListNode* head, int val) {
		ListNode* dummyHead = new ListNode(0);
		dummyHead->next = head;
		ListNode* cur = dummyHead;
		while (cur->next != NULL) {
			if (cur->next->val == val) {
				ListNode* tmp = cur->next;
				cur->next = cur->next->next;
				delete tmp;
			}
			else {
				cur = cur->next;
			}
		}
		head = dummyHead->next;
		delete dummyHead;
		return head;
	}
};
// O(n)
// O(1)

第3节是707设计链表，实现五个功能：索引、插入头节点、插入尾节点、插入节点、删除节点

 （注意链表head节点的索引为0）

通过设置虚拟头节点的方式操作链表：在类中定义结构体并初始化类

Class Solution707_MyLinkedNode {
public:
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val) : val(val), next(nullptr) {}
    }
    Solution707_MyLinkedNode() {
        _dummyHead = new LinkedNode(0);
        _size = 0;
    }
    ...
private:
    int _size;
    LinkedNode* _dummyHead;
};

分别在类中添加5中方法：

void addAtHead(int val) {
    LinkedNode* newNode = new LinkedNode(val);
    newNode->next = _dummyHead->next;
    _dummyHead->next = neNode;
    _size++;
}

void addAtTail(int val) {
    LinkedNode* newNode = new LinkedNode(val);
    LinkedNode* cur = _dummyHead;
    while (cur->next != nullptr) {
        cur = cur->next;
    }
    cur->nxet = newNode;
    _size++;
}

void addAtIndex(int index, int val) {
    if (index > _size) return;
    if (index < 0) index = 0;
    LinkedNode* newNode = new LinkedNode(int val);
    LinkedNode* cur = _dummyHead;
    while (index--) {
        cur = cur->next;
    }
    // 插入时先右后左
    newNode->next = cur->next;
    cur->next = newNode;
    _size++;
}

int get(int index) {
    if (index > (_size -1) || index < 0) {
        return -1;
    }
    LinkedNode* cur = _dummyHead->next;
    while (index--) {
        cur = cur->next;
    }
    return cur->val;
}

void deleteAtIndex(int index) {
    if (index >= _size || index < 0) {
        return;
    }
    LinkedNode* cur = _dummyHead;
    while (index--) {
        cur = cur->next;
    }
    LinkedNode* tmp = cur->next;
    cur->next = cur->next->next;
    delete tmp;
    tmp = nullptr;
    _size--;
}

void printLinkedList() {
    LinkedNode* cur = _dummyHead;
    while (cur->next != nullptr) {
        cout << cur->next->val << " ";
        cur = cur->next;
    }
    cout << endl;
}

第4节206翻转链表reverseList，实现对链表的翻转，如果再定义新链表翻转是浪费内存。实际上改变链表的next指针指向即可。

利用双指针pre和cur进行翻转：

class Solution206_0 {
public:
	ListNode* reverseList(ListNode* head) {
		ListNode* temp;
		ListNode* cur = head;
		ListNode* pre = nullptr;
		while (cur) {
			temp = cur->next;
			cur->next = pre;
			pre = cur;
			cur = temp;
		}
		return pre;
	}
};

 利用递归法（从前往后）：

class Solution206_1 {
public:
	ListNode* reverse(ListNode* pre, ListNode* cur) {
		if (cur == NULL) return pre;
		ListNode* temp = cur->next;
		cur->next = pre;
		return reverse(cur, temp);
	}

	ListNode* reverseList(ListNode* head) {
		return reverse(NULL, head);
	}
};

利用递归法（从后往前）：这个方法不好理解，技巧性太强，细节理解不到位，根本写不出来，建议画图了解一下。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        // 边缘条件判断
        if(head == NULL) return NULL;
        if (head->next == NULL) return head;
        
        // 递归调用，翻转第二个节点开始往后的链表
        ListNode *last = reverseList(head->next);
        // 翻转头节点与第二个节点的指向
        head->next->next = head;
        // 此时的 head 节点为尾节点，next 需要指向 NULL
        head->next = NULL;
        return last;
    }
}; 

注意：每一层递归返回的是同一个last，在最底层开始的倒数第二个head开始迭代head->next->next=head，就是把head的下一个节点连在自己身上，自己连到nullptr暂放，返回last后接着进行上一层函数的head->next->next=head，注意此时的head是倒数第三个节点，把第二个节点（原本连在nullptr上）连在自己身上，自己连到nullptr暂放。

以上就是今天的全部学习内容。