今天该链表咯!
一、链表节点的定义
面试的时候如果让你自己写链表节点的定义,你会吗?
#C++
struct ListNode{//定义了一个结构体struct ListNode(代表每一个节点);
int val;//每一个节点由两部分组成,一个是数据域;
ListNode *next;//一个是指针域(存放指向下一个节点的指针,下一个节点也用一个结构体来表示,所以是ListNode类型的)
//还可以加一个节点的构造函数,也可以不加,我一般就不加hh
ListNode(int x):val(x),next(NULL){}
};//不要忘记分号哦
通过自己定义的构造函数初始化节点:
ListNode *p = new ListNode(2);//p是一个指向这个节点的指针,这个节点用一个结构体来表示
如果没有定义构造函数,C++会默认生成一个构造函数:
ListNode *p = new ListNode();
p->val = 2;
二、203. 移除链表元素
(简单)题目描述:给你一个链表的头节点
head
和一个整数val
,请你删除链表中所有满足Node.val == val
的节点,并返回 新的头节点 。
思路:要删除一个节点要找到它的前一个节点,但是头节点head没有前一个节点,可以直接head=head->next;,但最后别忘记把删掉的头结点从内存中删(delete)掉; 删完满足条件的头节点,如果链表为空了,直接返回NULL; 否则继续删链表里面值为val的节点。
我的代码(已通过):
class Solution {
public:
ListNode* removeElements(ListNode* head, int val) {
//删与val值相同的头节点
while(head!=NULL && head->val==val){
ListNode *q = head;
head=head->next;
delete q;//刚忘记把原头结点从内存中删掉咯
}
ListNode *p = head;
if(head==NULL) return head;//删完之后头节点为空则直接返回
while(p->next != NULL){
if(p->next->val==val){
ListNode *q=p->next;
p->next = q->next;
delete q;
}
else{
p=p->next;
}
}
p=head;
cout<<'[';
/*while(p!=NULL){
cout<<p->val<<',';//这样会多一个逗号虽然通过测试了啊偶~
p=p->next;
}*/
while(p!=NULL){
cout<<p->val;
if(p->next!=NULL){
cout<<',';
}
p=p->next;
}
cout<<']';
return head;
}
};
- 时间复杂度: O(n)
- 空间复杂度: O(1)
三、707. 设计链表
(中等但基础但出现了好多bug)题目描述:你可以选择使用单链表或者双链表,设计并实现自己的链表。
单链表中的节点应该具备两个属性:
val
和next
。val
是当前节点的值,next
是指向下一个节点的指针/引用。如果是双向链表,则还需要属性
prev
以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。实现
MyLinkedList
类:
MyLinkedList()
初始化MyLinkedList
对象。int get(int index)
获取链表中下标为index
的节点的值。如果下标无效,则返回-1
。void addAtHead(int val)
将一个值为val
的节点插入到链表中第一个元素之前。在插入完成后,新节点会成为链表的第一个节点。void addAtTail(int val)
将一个值为val
的节点追加到链表中作为链表的最后一个元素。void addAtIndex(int index, int val)
将一个值为val
的节点插入到链表中下标为index
的节点之前。如果index
等于链表的长度,那么该节点会被追加到链表的末尾。如果index
比长度更大,该节点将 不会插入 到链表中。void deleteAtIndex(int index)
如果下标有效,则删除链表中下标为index
的节点。
直接写代码(已通过):
bug:忘记size++;未考虑空指针
#include<iostream>
using namespace std;
class MyLinkedList {
public:
//正好测试一下记没记住刚刚单链表节点的定义
struct ListNode{
int val;
ListNode *next;
//构造函数
ListNode(int x):val(x),next(NULL){}
};
MyLinkedList() {//初始化 单链表MyLinkedList 对象:头节点和大小size。
size = 0;
head = new ListNode(0);;//初始化链表的时候,头指针指向头节点(这里我们随便搞一个假的头节点,也就是说它不增加链表的size)
}
int get(int index) {//获取链表中下标为 index 的节点的值。如果下标无效,则返回 -1 。
//如果链表为空,那么size=0;判定条件就变为index小于0或者大于-1,也就是说此时不管index是多少都无效
//所以说下面的if判断语句已经考虑了链表为空的情况
if(index<0 || index>size-1) return -1;//下标无效,则返回 -1
//if(p==NULL) return -1;
ListNode *p = head->next;//p指向真正的(开始计数的)头节点
int t=0;//下标初始为0
while(t!=index){//这里下标一定是有效的
p=p->next;
t++;
}
return p->val;
}
//将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后,新节点会成为链表的第一个节点。
void addAtHead(int val) {
ListNode *p = new ListNode(val);
p->next = head->next;
head->next = p;
//别忘记size++
size++;
}
// 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
void addAtTail(int val) {
ListNode *p = new ListNode(val);
ListNode *q = head;
while(q->next!=NULL){
q=q->next;
}
p->next = NULL;
q->next = p;
//别忘记size++啊啊啊
size++;
}
//将一个值为 val 的节点插入到链表中下标为 index 的节点之前。
void addAtIndex(int index, int val) {
if(index>size) return;
ListNode *p = new ListNode(val);
int i=-1;
ListNode *q = head;
while(i != index-1){ //找index-1
q=q->next;
i++;
}
p->next = q->next;
q->next = p;
//别忘记size++
size++;
}
void deleteAtIndex(int index) { //如果下标有效,则删除链表中下标为 index 的节点。
if(index<0 || index>size-1) return;
/*这段为错误代码
ListNode *p = head->next;
int i=0;*/
ListNode *p = head;
int i=-1;
//删除下标为 index 的节点,要找它的前一个节点,但倘若它没有前一个节点呢?答:用那个假头节点
while(i != index-1){
p=p->next;
//cout<<p->val<<endl;
i++;
}
ListNode *q = p->next;
p->next = q->next;
delete q;
size--;
}
void printlist(){
ListNode *p = head->next;
while(p!=NULL){
cout<<p->val;
cout<<"->";
p=p->next;
}
cout<<endl;
}
private:
int size;
ListNode *head;//链表的头指针
};
int main(){
//MyLinkedList* ptr = new MyLinkedList();
//MyLinkedList& ref = *ptr; // 使用引用
//MyLinkedList myLinkedList = new MyLinkedList();
MyLinkedList *p = new MyLinkedList();
MyLinkedList& myLinkedList = *p;
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2); // 链表变为 1->2->3
int a = myLinkedList.get(1);
cout<<a<<endl; // 返回 2
myLinkedList.printlist();
myLinkedList.deleteAtIndex(2); // 现在,链表变为 1->3
myLinkedList.printlist();
myLinkedList.get(1); // 返回 3
}
/*int main(){
MyLinkedList *p = new MyLinkedList();
MyLinkedList& myLinkedList = *p;
myLinkedList.printlist();
myLinkedList.addAtHead(1);
myLinkedList.printlist();
myLinkedList.deleteAtIndex(0); // 现在,链表变为 1->3
myLinkedList.printlist();
}*/
/**
* 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);
*/
四、206. 反转链表
(easy~,就是考头插法咯)题目描述:给你单链表的头节点
head
,请你反转链表,并返回反转后的链表。
示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL
我的代码:
class Solution {
public:
ListNode* reverseList(ListNode* head) {
//头插法,头节点一直是p
ListNode *p = new ListNode();//假头节点
p->next=NULL;
ListNode *q=head;
while(q!=NULL){
ListNode *h=q->next;
q->next = p->next;
p->next = q;
q=h;
}
return p->next;
}
};
继续加油哦~