链表（重点oj题）

最新推荐文章于 2023-03-18 16:28:53 发布

过过过.

最新推荐文章于 2023-03-18 16:28:53 发布

阅读量265

点赞数 1

文章标签：链表

本文链接：https://blog.csdn.net/qq_72766756/article/details/127987465

版权

1：链表的概念及结构

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表
中的指针链接次序实现的。

2：链表的分类

1：单向或者双:2：带头或者不带头3：循环或者非循环（常用：无头单向非循环链表，带头双向循环链表）

1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结
构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都
是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带
来很多优势，实现反而简单了，后面我们代码实现了就知道了

3：双向链表的实现

Test.c
# define _CRT_SECURE_NO_WARNINGS	
#include<stdio.h>
#include"List.h"


//带头双向循环链表

void TestList1()
{
	LTNode* phead = LTInit();
	LTPushBack(phead, 1);
	LTPushBack(phead, 2);
	LTPushBack(phead, 3);
	LTPushBack(phead, 4);
	LTPushBack(phead, 5);
	LTPrint(phead);


	LTPopBack(phead);
	LTPrint(phead);
	LTPopBack(phead);
	LTPrint(phead);
	LTPopBack(phead);
	LTPrint(phead);
	LTPopBack(phead);
	LTPrint(phead);
	LTPopBack(phead);
	LTPrint(phead);

	//LTPopBack(phead);
}
void TestList2()
{
	LTNode* phead = LTInit();
	LTPushFront(phead, 1);
	LTPushFront(phead, 2);
	LTPushFront(phead, 3);
	LTPushFront(phead, 4);
	LTPushFront(phead, 5);
	LTPrint(phead);

	LTPopFront(phead);
	LTPrint(phead);
	LTPopFront(phead);
	LTPrint(phead);
	LTPopFront(phead);
	LTPrint(phead);
	LTPopFront(phead);
	LTPrint(phead);
	LTPopFront(phead);
	LTPrint(phead);


}
void TestList3()
{
	LTNode* phead = LTInit();
	LTPushFront(phead, 1);
	LTPushFront(phead, 2);
	LTPushFront(phead, 3);
	LTPushFront(phead, 4);
	LTPushFront(phead, 5);
	LTPrint(phead);

	LTNode* pos = LTFind(phead, 3);
	if (pos)
	{
		pos->data *= 10;
	}
	LTPrint(phead);

	LTDestroy(phead);
	phead = NULL;
}
int main()
{
	//LTNode* phead=ListInit();
	TestList3();
	//TestList2();
	return 0;
}

List.h
# define _CRT_SECURE_NO_WARNINGS	
#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include <stdbool.h>

typedef int LTDataType;
typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;
	LTDataType data;
}LTNode;

LTNode* BuyListNode(LTDataType x);
LTNode* LTInit();

void LTPrint(LTNode* phead);
void LTPushBack(LTNode* phead, LTDataType x);
void LTPopBack(LTNode* phead);

void LTPushFront(LTNode* phead, LTDataType x);
void LTPopFront(LTNode* phead);

LTNode* LTFind(LTNode* phead, LTDataType x);
//在pos之前插入x
void LTInsert(LTNode* pos, LTDataType x);
//删除pos位置
void LTErase(LTNode* pos);

//探空
bool LTEmpty(LTNode* phead);
size_t LTSize(LTNode* phead);
//销毁链表
void LTDestroy(LTNode* phead);

List.c
# define _CRT_SECURE_NO_WARNINGS

#include"List.h"
LTNode* BuyListNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	node->data = x;
	node->next = NULL;
	node->prev = NULL;
	return node;
}

LTNode* LTInit()
{
	LTNode* phead = BuyListNode(-1);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}
void LTPrint(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	/*LTNode* newnode = BuyListNode(x);
	LTNode* tail = phead->prev;

	tail->next = newnode;
	newnode->prev = tail;

	newnode->next = phead;
	phead->prev = newnode;*/
	LTInsert(phead, x);

	
}
void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);//看空

	/*LTNode* tail = phead->prev;
	LTNode* tailPrev = tail->prev;

	tailPrev->next = phead;
	phead->prev = tailPrev;
	free(tail);*/
	LTErase(phead->prev);

}
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);

	/*LTNode* newnode = BuyListNode(x);
	newnode->next = phead->next;
	phead->next->prev = newnode;

	phead -> next = newnode;
	newnode->prev = phead;*/


	LTInsert(phead->next, x);
}
void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);
	/*LTNode* first = phead->next;
	LTNode* second = first->next;
	free(first);

	phead->next = second;
	second->prev= phead;*/
	LTErase(phead->next);
}
LTNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur!=phead)
	{
		if (cur->data==x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* newnode = BuyListNode(x);
	prev->next = newnode; 
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;


}
//删除pos位置
void LTErase(LTNode* pos)
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* next = pos->next;
	free(pos);

	prev->next = next;
	next->prev = prev;
}
bool LTEmpty(LTNode* phead)
{
	assert(phead);
	/*if (phead->next==phead)
	{
		return true;
	}
	else
	{
		return false;
	}*/
	return phead->next == phead;
		
}
size_t LTSize(LTNode* phead)
{
	assert(phead);

	size_t size = 0;
	LTNode* cur = phead->next;
		while (cur!=phead)
		{
			++size;
			cur = cur->next;
		}
		return size;
}
void LTDestroy(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);

}

4：oj题

4.1复制带随机指针的链表

思路：1 拷贝节点链接在源节点的后面 2 设置拷贝节点的random（if(cur->random) copy->random=cur->random->next) 3 拷贝节点解下来，链接组成拷贝链

实现：

struct Node* copyRandomList(struct Node* head) {
//1·拷贝节点链接到原节点后面    
struct Node*cur=head;
while(cur)
{
    struct Node*next=cur->next;
    struct Node*copy=(struct Node*)malloc(sizeof(struct Node));
    copy->val=cur->val;
    
    //插入链接
    cur->next=copy;
    copy->next=next;

    cur=next;
}
//2·置random
    cur=head;
    while(cur)
    {
        struct Node*copy=cur->next;

        if(cur->random==NULL)
        {
            copy->random=NULL;
        }
        else
        {
            copy->random=cur->random->next;
        }
        cur=cur->next->next;
    }
//3.解下来链接在一起
    cur=head;
    struct Node*copyHead=NULL,*copyTail=NULL;
    while(cur)
    {
        struct Node*copy=cur->next;
        struct Node*next=copy->next;

        cur->next=next;
        //尾插
        if(copyTail==NULL)
        {
            copyHead=copyTail=copy;
        }
        else 
        {
            copyTail->next=copy;
            copyTail=copyTail->next;

        }
        cur=next;
    }
    return copyHead;
}

4.2：环形链表

思路：用快慢指针，相遇则有环；

实现：

bool hasCycle(struct ListNode *head) {
  struct ListNode *slow=head,fast=head;
  while(fast&&fast->next)
  {
      slow=slow->next;
      fast=fast->next->next;

      if(lsow==fast)
      return ture;
  }
  return false;
  
}

4.3:环形链表 II

思路：一个指针从相遇点开始走，一个指针从起始点开始走；两个指针走到一起就是环点

实现：

struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode *slow=head,*fast=head;
  while(fast&&fast->next)
  {
      slow=slow->next;
      fast=fast->next->next;

      if(slow==fast)
    {
        struct ListNode*meet=slow;
        while(head!=meet)
        {
            head=head->next;
            meet=meet->next;
        }
        return meet;
    }
  }
  return NULL;

结论
让一个指针从链表起始位置开始遍历链表，同时让一个指针从判环时相遇点的位置开始绕环
运行，两个指针都是每次均走一步，最终肯定会在入口点的位置相遇。

证明：

过过过.

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
链表（重点oj题）

思路：1 拷贝节点链接在源节点的后面 2 设置拷贝节点的random（if(cur->random) copy->random=cur->random->next) 3 拷贝节点解下来，链接组成拷贝链。1：单向或者双:2：带头或者不带头3：循环或者非循环（常用：无头单向非循环链表，带头双向循环链表）概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表。1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。
复制链接

扫一扫