203.移除链表元素
题目链接:https://leetcode.cn/problems/remove-linked-list-elements/description/
注意:单链表只能遍历删除,删除结点需要知道该结点的前驱结点
若不想单独处理头结点或者链表没有头结点,可以自己定义一个虚拟头结点head,head->next指向当前链表的头结点或者第一个结点,注意返回时要返回head->next
//在原链表进行操作
struct ListNode* removeElements(struct ListNode* head, int val) {
struct ListNode* temp;//辅助结点
// 当头结点存在并且头结点的值等于val时
while(head&&head->val==val){
temp=head;
head=head->next; //更新头结点
free(temp);//释放之前的头结点
}
struct ListNode* pre=head;
//单链表中删除某个结点,需要找到它的前驱结点,因此用pre表示该结点的前驱结点,pre->next表示当前结点,便于进行删除操作
while(pre){
if(pre->next && pre->next->val==val){
temp=pre->next;
pre->next=pre->next->next;
free(temp);
}else
pre=pre->next;
}
return head;
}
//使用虚拟头结点
struct ListNode* removeElements(struct ListNode* head, int val) {
typedef struct ListNode ListNode;
ListNode* temp,*shead;
shead=(ListNode*)malloc(sizeof(ListNode));
shead->next=head;
struct ListNode* pre=shead;
while(pre){
if(pre->next && pre->next->val==val){
temp=pre->next;
pre->next=pre->next->next;
free(temp);
}else
pre=pre->next;
}
head=shead->next;//更新头结点并删除虚拟头结点
free(shead);
return head;
}
707.设计链表
题目链接:https://leetcode.cn/problems/design-linked-list/description/
思路:使用带头结点的单链表,头结点的数据域记录链表长度
注意在插入和删除操作时,要先找到其前驱结点,才方便进行相应操作
typedef struct Node {
int val;
struct Node *next;
} MyLinkedList;
MyLinkedList *myLinkedListCreate() {
MyLinkedList *obj = (MyLinkedList *) malloc(sizeof(MyLinkedList));
obj->val = 0;//初始化头结点的数据域,表示链表长度为0
obj->next = NULL;
return obj;//返回头结点
}
int myLinkedListGet(MyLinkedList *obj, int index) {
MyLinkedList *p = obj->next;
int i = 0;
if (index < 0 || index > obj->val - 1) { //位置合法性检查
return -1;
}
while (i < index) {
p = p->next;
i++;
}
return p->val;
}
void myLinkedListAddAtHead(MyLinkedList *obj, int val) {
MyLinkedList *p = (MyLinkedList *) malloc(sizeof(MyLinkedList));
p->val = val;
p->next = obj->next;
obj->next = p;
obj->val++;
}
void myLinkedListAddAtTail(MyLinkedList *obj, int val) {
MyLinkedList *p, *r;
p = obj;
while (p) {//循环遍历寻找尾结点
if (p->next == NULL) { //找到尾结点并插入新结点
r = (MyLinkedList *) malloc(sizeof(MyLinkedList));
r->val = val;
p->next = r;
r->next = NULL;//注意新的尾结点next要指向NULL
obj->val++;
break;
}
p = p->next;
}
}
void myLinkedListAddAtIndex(MyLinkedList *obj, int index, int val) {
if (index > obj->val || index < 0) return;
obj->val++;
MyLinkedList *p = obj, *s;
for (int i = 0; i < index; i++) { //寻找插入位置的前驱结点,所以不是i<=index
p = p->next;
}
s = (MyLinkedList *) malloc(sizeof(MyLinkedList));
s->val = val;
s->next = p->next;
p->next = s;
}
void myLinkedListDeleteAtIndex(MyLinkedList *obj, int index) {
if (index >= obj->val || index < 0) return;
obj->val--;
MyLinkedList *p = obj, *s;
for (int i = 0; i < index; i++) { //寻找删除位置的前驱结点,所以不是i<=index
p = p->next;
}
s = p->next;
p->next = p->next->next;
free(s);
}
void myLinkedListFree(MyLinkedList *obj) {
MyLinkedList *p = obj->next, *temp;
while (p) {
temp = p;
p = p->next;
free(temp);
}
free(obj);
}
206.反转链表
题目链接:https://leetcode.cn/problems/reverse-linked-list/description/
题目描述:
思路
1.头插法
要反转链表,那么按头插法建立链表即可
struct ListNode* reverseList(struct ListNode* head) {
typedef struct ListNode ListNode;
ListNode *p,*temp;
p=(ListNode*)malloc(sizeof(ListNode));//虚拟头结点
p->next=NULL;
while(head){
temp=head->next;//辅助结点保存下一个结点
head->next=p->next;
p->next=head;
head=temp;
}
return p->next;
}
2.双指针迭代-不需要定义新的链表
在遍历链表时,将当前节点的 next
指针改为指向前一个节点。由于节点没有引用其前一个节点,因此必须事先存储其前驱结点。在更改引用之前,还需要存储后一个节点。最后返回新的头引用。
struct ListNode* reverseList(struct ListNode* head) {
struct ListNode* tmp;
struct ListNode* pre=NULL;
while(head){
tmp=head->next;
head->next=pre;
pre=head;
head=tmp;
}
return pre;
}
3.递归
逻辑与双指针的逻辑相同,只不过把两个结点交换顺序的方法用递归来实现
//代码一
struct ListNode* reverse(struct ListNode* pre, struct ListNode* cur) {
if(!cur) return pre; // 链表为空时直接返回,链表不为空则到返回最后一个节点
struct ListNode* temp = cur->next;
cur->next = pre;
//将cur作为pre传入下一层
//将temp作为cur传入下一层,改变其指针指向当前cur
return reverse(cur, temp);
}
struct ListNode* reverseList(struct ListNode* head){
return reverse(NULL, head);
}
//代码二
struct ListNode* reverseList(struct ListNode* head) {
// 链表为空时直接返回,链表不为空则到返回最后一个节点
if (head == NULL || head->next == NULL) {
return head;
}
// 递归调用,翻转第二个节点开始往后的链表
// newHead先指向最后一个节点,注意此时参数是倒数第二个节点
// 这一步很精妙,每一次newHead都是指向空指针(链表为空)或保留在原链表中的最后一个节点(链表不空),作用就是返回新的头结点
struct ListNode* newHead = reverseList(head->next);
// 最后一个节点指向倒数第二个节点,翻转头节点与第二个节点的指向
head->next->next = head;
// 倒数第二个节点的下一节点置空。此时倒数第三个节点仍指向倒数第二个节点,下一次递归中将倒数第二个节点下一节点指向倒数第三个节点,不断重复这一过程
// 此时的 head 节点为尾节点,next 需要指向 NULL
head->next = NULL;
return newHead;
}