本段代码实现了

1 新建链表

2 输出链表

3 删除链表中的指定元素

#include <stdio.h>
#include <stdlib.h>
#include<malloc.h>
#include "test1.h"

/*
创建一个结构体
*/
typedef struct Node {
	int data;//数据
	struct Node *next;//下一个结点的指针
}Node;
int count = 0;//记录链表的长度

Node *InitList() {
	Node *head;//定义头指针
	Node *q, *p;//定义两个结构体指针用于后面迭代
	head = (Node *)malloc(sizeof(Node));
	q = head;
	while (1)
	{
		count++;
		p = (Node *)malloc(sizeof(Node));
		printf("请输入第%d个数: (如需结束输入0):   ", count);
		scanf_s("%d", &p->data);
		if (p->data == 0) {
			return head;
		}
		//在迭代插入新的节点的过程中一直使P指向新的节点，q指向当前节点
		p->next = NULL;
		q->next = p;
		q = p;
	}
}

void showList(Node *m) {
	Node *p;
	p = m->next;//让p指针指向第一个节点
	while (p!=NULL)
	{	
		//注意头指针的数据是不需要输出的
		printf("%d\n", p->data);
		p = p->next;
	}
}
void DeleteListItem(Node *n,int x) {
	Node *p,*q,*pre; //p为循环指针，q指向需要删除的指针, pre始终为当前指针的前一位，类似双链表
	p = n->next;//让p指向第一个节点，跳过头节点
	pre = n;
	while (p!=NULL)
	{
		if (p->data==x)
		{	
			printf("找到要删除的数据%d---%d\n",p->data,x);
			q = p;//q指针指向需要删除的指针
			p = p->next;//循环指针跳到下一个位置
			pre->next = p;//此时，可以理解为前驱节点跳过要删除的点，next指向P
			free(q);//释放内存
			count--;
		}else
		{
			pre = p;
			p = p->next;
		}
	}
}

int main() {
	//创建好了一个链表
	Node *m = InitList();
	//输出链表中的数据信息
	showList(m);
	printf("请输入需要删除的元素: ");
	int d;
	scanf_s("%d", &d);
	//删除链表中指定元素
	DeleteListItem(m, d);
	//删除完再输出数据
	printf("删除了指定元素后的列表:\n", d);
	printf("链表总长度为:%d\n", count);
	showList(m);
	system("pause");
	return 0;
}

// 删除单链表指定元素5
#include <iostream>
#include <vector>
using namespace std;

//节点定义：
struct ListNode {
	int val;
	ListNode* next;
	ListNode(int x) : val(x), next(nullptr) {}
};
class Solution {
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;
	}
};
//创造节点
void CreateList(ListNode *head) {
	vector<int> nums = { 1,2,3,3,1,5,1 };
	ListNode *p = head;
	for (int i = 1; i < nums.size(); ++i)
	{
		p->next = new ListNode(nums[i]);
		p = p->next;
	}
}
//输出节点
void PrintList(ListNode *head) {
	ListNode *p = head;
	while (p != NULL)
	{
		cout << p->val << endl;
		p = p->next;
	}
}
int main() {
	ListNode* head = new ListNode(1);//创造头节点
	CreateList(head);
	Solution List;
	ListNode* ret = List.removeElements(head, 5);
	PrintList(ret);
	system("pause");
	return 0;
}

一、链表种类

简单列表：包含 val 和next指针

双端链表： 包含val 和 pre、next指针

二、定义链表

class ListNode_handle:
    def __init__(self):
        self.cur_node = None

    def add(self, data):
        # add a new node pointed to previous node
        node = ListNode()
        node.val = data
        node.next = self.cur_node
        self.cur_node = node
        return node

    def print_ListNode(self, node):
        while node:
            print('\nnode: ', node, ' value: ', node.val, ' next: ', node.next)
            node = node.next

    def reverse(self, nodelist):
        list = []
        while nodelist:
            list.append(nodelist.val)
            nodelist = nodelist.next
        result = ListNode()
        result_handle = ListNode_handle()
        for i in list:
            result = result_handle.add(i)
        return result



# node_list = [5,3,4,1,6]
list_handle = ListNode_handle()
l1 = ListNode()
l1_list = [1, 8, 3]
for i in l1_list:
    l1 = list_handle.add(i)
l1 = list_handle.reverse(l1)
list_handle.print_ListNode(l1)

输出结果：

三、删除链表中的一个元素

删除链表中的元素思想就是找到这个元素的下一个元素赋值给需要删除的元素，然后把当前这个元素指针指向需要删除元素的后两个值

class ListNode1:
    def __init__(self, x):
        self.val = x
        self.next = None


class Solution:
    """
    @param: head: a ListNode
    @param: val: An integer
    @return: a ListNode
    """

    def removeElements(self, head, val):
        # write your code here
        tem_head = tem = ListNode1(-1)
        head_tem = head
        # 遍历一遍链表然后发现和val不相等就加入tem后
        while head_tem:
            if head_tem.val != val:
                tem.next = head_tem
                tem = tem.next
            # 无论相不相等都需要继续遍历，
            head_tem = head_tem.next
        # 最后结尾的时候一定要加上None，否则tem的下一位很有可能还有其他元素
        tem.next = None
        return tem_head.next


head = l1
val = 3
res = Solution().removeElements(head, val)
# list_handle.print_ListNode(l1)
while l1:
    print(f'node---: {l1},value:{l1.val},next:{l1.next}')
    l1 = l1.next

输出结果：

四、如何合并两个有序链表

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next

class Solution:
    def mergeTwoLists(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        prehead = ListNode(-1)

        prev = prehead
        while l1 and l2:
            if l1.val <= l2.val:
                prev.next = l1
                l1 = l1.next
            else:
                prev.next = l2
                l2 = l2.next            
            prev = prev.next

        # 合并后 l1 和 l2 最多只有一个还未被合并完，我们直接将链表末尾指向未合并完的链表即可
        prev.next = l1 if l1 is not None else l2

        return prehead.next

输出结果：