力扣链表题 持续更新

1、一个排序的链表中，存在重复结点，请删除链表中重复的结点，重复的结点不保留,返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5。（蔚来笔试编程题）

话不多说，直接上代码。

struct ListNode{
	int val;
	struct ListNode *next;
};
ListNode* deleteDuplication(ListNode* pHead){
	//考虑传入为空链表
	if(pHead == NULL)
		return NULL;
	//考虑到传入了一个结点
	if(pHead->next == NULL)
		return pHead;
	//在没带头节点的情况中,自己创建一个头结点
	ListNode *pre = new ListNode();
	ListNode *pre_head = pre;// 用来保存头节点，用于返回删除后的链表
	//把头节点的下一个结点设为pHead
	pre->next = pHead; //头节点
	ListNode *cur = pHead; //当前结点
	ListNode *Next = pHead->next; //下一个结点
	//判断当前节点与下一个节点是否相等，相等的话则保持当前节点，向右移动下一个节点，直到不等于当前节点值为止；（因为是已排好序的链表，所以重复的值一定靠在一起）
	while(Next)  //一直循环到尾节点
	{
	//如果相等且没到尾节点，一直向右移动，可能移动到不相等的节点，也有可能移动尾节点
		while(Next != NULL && cur->val == Next->val)
		{
			Next = Next->next;
		}
	//如果有出现了相等的节点，则将其全部删除
		if(cur->next!= Next){
			while(cur != Next){
			pre->next = cur->next;
			delete cur;
			cur = pre->next;
			}
    //极端情况，考虑到一直重复的数到最后一个节点；如果不是最后一个节点，则当前节点也已经和Next节点指向了同一个节点，所以为了接下来还需要判断，将Next指针指向下一个节点；如果已经到了尾节点就结束
			if(Next != NULL)
				Next = Next->next;
			}
	//如果没有相等的节点，则改变prev与cur的指向
		else{
				pre = cur;
				cur = Next;
				Next = cur->next;
		}
	}
	ListNode* my_head = pre_head->next; // 释放空间，防止内存泄漏
	delete pre_head;
	return my_head;
}

2 、给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。首先输入几个链表节点的值，接着输入要删除的某个节点的值将其从链表中删除 （联发科嵌入式软开笔试题）

例：输入: N1 N2 N3 N4 N5
N3
输出： N1 N2 N4 N5
使用c语言来完成

// 
struct ListNode {
      int val;
      ListNode *next;
  };
ListNode *deleteNode(ListNode* head, int val)
{
	if(head->val = val)
		return head->next;
	ListNode *cur  = head;
	ListNode *NEXT = head->next;
	while(NEXT != NULL && NEXT->val != val)
	{
		cur = NEXT;
		NEXT = NEXT->next;
	}
	cur->next = NEXT->next;
	return head;
}

int main()
{
	int a[100];
	int target;
    int i=0;
    char c;
     ListNode *p , *q, *head = NULL;//head为头节点
    do{
    	scanf("%d", &a[i]);
    	i++;
    }
    while(c.getchar != '\n')
    scanf("&d", &target);
    for(int j=0; j<i; j++)
    {
          //先动态分配内存空间，地址给p
		 p = (ListNode *)malloc(sizeof(ListNode )) ;
		 p->val = a[j];
		 if(head->val = NULL)
		 	haed = p;//首先把p赋给头节点
		 else
		 	q->next = p;//否则把p给上一个结点的next
        q=p;//用q记录p，所以在下一个循环中，q是上一个结点的地址
    }
     p->next=NULL;//最后一个结点当然没有指向，所以赋值为空
    deleteNode(head, target);
}

3、链表插入排序

//
struct ListNode {
      int val;
      ListNode *next;
  };
ListNode* insertionSortList(ListNode* head) {
	ListNode pull(0);
	ListNode* pre = &pull;
	pre->next = head;
	ListNode* cur = head;
	ListNode* temp = nullptr;  //初始化为nullptr空指针
	 //当前指针的下一个指针为空也就没有东西可比了
	while(cur != nullptr && cur->next != nullptr)
	{
		//升序排序 如果后面的节点值小于前面的节点值，
		if(cur-val > cur->next->val)
		{
			//cur = cur->next;
			//则将当前节点的下一个节点的值保存到临时变量中，
			temp = cur->next;
			cur->next = cur->next->next; ***//删除cur后面的节点***
			pre = &pull; //重新移动pre的位置到头节点的位置
			while(pre->next->val < cur->val)
			{
				pre = pre->next;
			}
			temp->next = pre->next;
			pre->next = temp;
		}
		else
			cur = cur->next; ***//移动cur指向下一个链表节点*
	}**
}

}

对于链表，我们要有这种思想，先写出自己的逻辑，然后判断极端情况，而这种极端情况大部分都是由头和尾异常引起的，我们多多思考这种测试用例进行画图，然后才是编写代码。