leetcode练习01--链表操作

#关于单链表删除某一节点
给定的题目：
链接：https://leetcode-cn.com/problems/delete-node-in-a-linked-list
自己的做法：很繁琐还绕弯路

// algorithm01.cpp : 定义控制台应用程序的入口点。
#include "stdafx.h"
#include <iostream>
using namespace std;
struct ListNode{
	int val;
	ListNode* next;
};
void DeleteNode(ListNode* node,int val)
{
	ListNode* p=node;
	ListNode* q=NULL;
	while (p->next!=NULL&&p->val!=val)
	{
		q=p;
		p = p->next;
	}
	if (p->val==val)
	{
		q->next = p->next;
		delete p;
	}
	while(node->next!=NULL)
	{
		cout<<node->val;
		node = node->next;
	}
}

官方答案这样:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void deleteNode(ListNode* node) {
         node->val = node->next->val;
         node->next = node->next->next;
    }
};

还是需要再多学习习。

补充01

leetcode21题 合并两个有序链表

将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例：
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-two-sorted-lists

这种主要用来递归的方法比较简单

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1==NULL){return l2;}
        else if(l2==NULL){return l1;}
        if(l1->val <= l2->val){
            l1->next = mergeTwoLists(l1->next,l2);//这里不能为l1否者永远长度为1，不断替换当前
            return l1;
        }else{
            l2->next = mergeTwoLists(l1,l2->next);
            return l2;
        }
    }
};

这里采用的是迭代算法

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* list = ListNode(-1);
        ListNode* temp = &list;
        if(l1==NULL){return l2;}
        else if(l2==NULL){return l1;}
        while(l1 != NULL && l2 != NULL)
        {
            if(l1->val <= l2->val)
            {
                temp->next = l1;
                l1 = l1->next;
            }
            else{
                temp->next = l2;
                l2 = l2->next;
            }
        }
        if(l1!=NULL){
            temp->next = l1;
        }
        else{
            temp->next = l2;
        }
        return temp.next;
        
};

关于迭代与递归的区别，参考的是这位博主大大的，很实用
https://www.cnblogs.com/zhizhan/p/4892886.html
谢谢这位大大哇

补充02

更 关于从尾到头打印链表

1.push_back 在数组的最后添加一个数据
2.begin 得到数组头的指针
3.end 得到数组的最后一个单元+1的指针

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        vector<int> tempList;
        if(head==NULL)return tempList;
        int len;
        ListNode* tempHead = head;
        while(tempHead!=NULL)
        {
            tempList.push_back(tempHead->val);
            tempHead = tempHead->next;
        }
        reverse(tempList.begin(),tempList.end());//很好利用指针收尾倒置，get
        return tempList;
    }
};