链表(单链表)
什么是链表
链表是一种通过指针串联在一起的线性结构,每个节点由两个部分组成,一个是数据域,一个是指针域(存放指向下一个节点的值) 最后一个节点的指针域指向null 链表的入口节点称为链表的头结点也就是head
双链表
单链表中的指针域只能指向节点的下一个节点,而双链表:每个节点有两个指针域,一个指向下一个节点,一个指向上一个节点。
双链表 既可以向前查询也可以向后查询。
循环链表
循环链表就是链表首尾相连,链表可以解决约瑟夫环问题
链表的存储方式
数组在内存是连续发布的,但是链表在内存中可不是连续发布的。链表是通过指针域的指针链接在内存中各个节点。
所以说链表中的节点在内存中不是连续发布的,而是散乱分布在内存中的某个地址上。
链表的定义
//单链表
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;
链表的操作
删除节点
只要将C节点的next指针(中间为D节点,删除D)指向E节点就行了
添加节点
在D节点的后面添加F个节点,只需要将F节点next指向D节点的的next节点,D节点的next再指向F
性能分析
数组 插入/删除:(时间复杂度)O(n) 查询:O(1)
链表 :O(1) :O(n)
移除链表元素
给你一个链表的头节点 head 和一个整数 val ,请你删除链表中所有满足 Node.val == val 的节点,并返回 新的头节点 。
输入:head = [1,2,6,3,4,5,6], val = 6
输出:[1,2,3,4,5]
示例 2:
输入:head = [], val = 1
输出:[]
来源:力扣(LeetCode)
/**
* Definition for singly-linked list.
* 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:
ListNode* removeElements(ListNode* head, int val) {
//删除头结点
while (head != NULL && head->val == val){ //头结点会变 要用while
ListNode* tmp = head;
head = head->next;
delete tmp;
}
//删除非头结点
ListNode* cur = head;
while(cur != NULL && cur->next!=NULL){
if(cur->next->val ==val)
{
ListNode* tmp = cur->next;
cur->next=cur->next->next;
delete tmp;
} else {
cur =cur->next;
}
}
return head;
}
};
- 删除链表的倒数第 N 个结点
输入:head = [1,2,3,4,5], n = 2
输出:[1,2,3,5]
示例 2:
输入:head = [1], n = 1
输出:[]
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode* pre = head;
int last = length(head)-n;
if(last==0)
return head->next;
for(int i = 0 ; i<last - 1;i++)
{
pre = pre->next;
}
pre->next = pre->next->next;
return head;
}
int length(ListNode* head) {
int len=0;
while(head!=0) {
len++;
head=head->next;
}
return len;
}
};
设计链表
在链表类中实现这些功能:
get(index):获取链表中第 index 个节点的值。如果索引无效,则返回-1。
addAtHead(val):在链表的第一个元素之前添加一个值为 val 的节点。插入后,新节点将成为链表的第一个节点。
addAtTail(val):将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val):在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度,则该节点将附加到链表的末尾。如果 index 大于链表长度,则不会插入节点。如果index小于0,则在头部插入节点。
deleteAtIndex(index):如果索引 index 有效,则删除链表中的第 index 个节点。
class MyLinkedList {
public:
struct LinkedNode {
int val;
LinkedNode* next;
LinkedNode(int val):val(val),next(nullptr){}
};
// 初始化链表
MyLinkedList() {
_dummyHead = new LinkedNode(0); // 这里定义的头结点 是一个虚拟头结点,而不是真正的链表头结点
_size = 0;
}
// 获取到第index个节点数值,如果index是非法数值直接返回-1, 注意index是从0开始的,第0个节点就是头结点
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 addAtHead(int val) {
LinkedNode* newNode = new LinkedNode(val);
newNode->next=_dummyHead->next;
_dummyHead->next=newNode;
_size++;
}
// 在链表最后面添加一个节点
void addAtTail(int val) {
LinkedNode* newNode = new LinkedNode(val);
LinkedNode* cur = _dummyHead;
while(cur->next != nullptr){
cur = cur->next;
}
cur->next = newNode;
_size++;
}
// 在第index个节点之前插入一个新节点,例如index为0,那么新插入的节点为链表的新头节点。
// 如果index 等于链表的长度,则说明是新插入的节点为链表的尾结点
// 如果index大于链表的长度,则返回空
// 如果index小于0,则置为0,作为链表的新头节点。
void addAtIndex(int index, int val) {
if(index > _size||index < 0){
return;
}
LinkedNode* newNode = new LinkedNode(val);
LinkedNode* cur = _dummyHead;
while(index--) {
cur=cur->next;
}
newNode->next = cur->next;
cur->next = newNode;
_size++;
}
// 删除第index个节点,如果index 大于等于链表的长度,直接return,注意index是从0开始的
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;
_size--;
}
private:
int _size;
LinkedNode* _dummyHead;
};
/**
* Your MyLinkedList object will be instantiated and called as such:
* MyLinkedList* obj = new MyLinkedList();
* int param_1 = obj->get(index);
* obj->addAtHead(val);
* obj->addAtTail(val);
* obj->addAtIndex(index,val);
* obj->deleteAtIndex(index);
*/
反转链表
示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL
/**
* Definition for singly-linked list.
* 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:
ListNode* reverseList(ListNode* head) {
ListNode* temp;
ListNode* cur = head;
ListNode* pre = NULL;
while(cur) {
temp = cur->next;
cur->next = pre;
pre=cur;
cur=temp;
}
return pre;
}
};
两两交换链表中的节点
给定一个链表,两两交换其中相邻的节点,并返回交换后的链表。
你不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
ListNode* dummyHead = new ListNode(0); //设一个虚头结点
dummyHead->next = head;//将虚头结点指向head,这样方便后面做删除操作
ListNode* cur = dummyHead;
while(cur->next !=nullptr && cur->next->next !=nullptr) {
ListNode* tmp = cur->next; //记录临时结点
ListNode* tmp1 = cur->next->next->next; //记录临时结点
cur->next = cur->next->next; //1
cur->next->next=tmp; //2
cur->next->next->next=tmp1; //3
cur=cur->next->next;
}
return dummyHead->next;
}
};
链表相交
给你两个单链表的头节点 headA 和 headB ,请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点,返回 null 。
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
int A=a(headA);
int B=a(headB);
ListNode* curA = headA;
ListNode* curB = headB;
if(B>A){
swap(A,B);
swap(curA,curB);
}
int gap = A-B;
while(gap--){
curA = curA->next;
}
while(curA!=NULL)
{
if(curA == curB) {
return curA;
}
curA = curA->next;
curB = curB->next;
}
return NULL;
}
private:
int a(ListNode* head) {
int len = 0;
while(head!=NULL) {
head=head->next;
len++;
}
return len;
}
};