链表的概念及结构
链表的分类
实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：
带头或者不带头
循环或者非循环
链表的实现
SList.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLTDataType;
typedef struct SListNode
{
SLTDataType data;
struct SListNode* next;
}SLTNode;
void SListPrint(SLTNode* phead);
void SListPushBack(SLTDataType** phead, SLTDataType x);
void SListPushFront(SLTDataType** phead, SLTDataType x);
void SListPopBack(SLTNode** pphead);
void SListPopFront(SLTNode** pphead);
SLTNode* BuySListNode(SLTDataType x);
SLTDataType* SListFind(SLTNode* phead, SLTDataType x);
void SListModify(SLTNode* phead, SLTDataType x, SLTDataType y);
void SListFrontPush(SLTNode** pphead, SLTDataType x, SLTDataType y);
void SListBackPush(SLTNode** pphead, SLTDataType x, SLTDataType y);
void SListPop(SLTNode** pphead, SLTDataType x);
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
void SListErase(SLTNode** pphead, SLTNode* pos);
SList.c
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include"SList.h"
void SListPrint(SLTNode* phead)
{
SLTNode* cur = phead;
while (cur != NULL)
{
printf("%d->", cur->data);
cur = cur->next;
}
printf("null\n");
}
void SListPushBack(SLTDataType** pphead, SLTDataType x)
{
assert(pphead);
SLTNode* newnode = BuySListNode(x);
if (*pphead == NULL)
{
*pphead = newnode;
}
else
{
SLTNode* tail = *pphead;
while (tail->next != NULL)
{
tail = tail->next;
}
tail->next = newnode;
}
}
SLTNode* BuySListNode(SLTDataType x)
{
SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
assert(newnode);
newnode->data = x;
newnode->next = NULL;
return newnode;
}
void SListPushFront(SLTDataType** pphead, SLTDataType x)
{
assert(pphead);
SLTNode* newnode = BuySListNode(x);
newnode->next = *pphead;
*pphead = newnode;
}
void SListPopBack(SLTNode** pphead)
{
assert(pphead);
assert(*pphead);
if ((*pphead)->next == NULL)
{
free(*pphead);
*pphead = NULL;
}
else
{
SLTNode* tail = *pphead;
/*SLTNode* tailPrev = NULL;
while (tail->next != NULL)
{
tailPrev = tail;
tail = tail->next;
}
free(tail);
tailPrev->next = NULL;*/
while (tail->next->next != NULL)
{
tail = tail->next;
}
free(tail->next);
tail->next = NULL;
}
}
void SListPopFront(SLTNode** pphead)
{
assert(pphead);
assert(*pphead);
SLTNode* next = (*pphead)->next;
free(*pphead);
*pphead = next;
}
SLTDataType* SListFind(SLTNode* phead, SLTDataType x)
{
SLTNode* cur = phead;
while (cur)
{
if (cur->data == x)
{
return cur;
}
cur = cur->next;
}
return NULL;
}
void SListModify(SLTNode* phead, SLTDataType x, SLTDataType y)
{
SLTNode* ret = SListFind(phead, x);
if (ret)
{
ret->data = y;
}
}
void SListFrontPush(SLTNode** pphead, SLTDataType x, SLTDataType y)
{
assert(pphead);
assert(*pphead);
SLTNode* pos = SListFind(*pphead, x);
if (pos)
{
SListInsert(pphead, pos, y);
}
}
void SListBackPush(SLTNode** pphead, SLTDataType x, SLTDataType y)
{
assert(pphead);
assert(*pphead);
SLTNode* pos = SListFind(*pphead, x);
if (pos)
{
if (pos == *pphead)
{
SListPushBack(pphead, x);
}
else
{
SLTNode* newnode = BuySListNode(x);
newnode->next = pos->next;
pos->next = newnode;
newnode->data = y;
}
}
}
void SListPop(SLTNode** pphead, SLTDataType x)
{
assert(pphead);
assert(*pphead);
SLTNode* pos = SListFind(*pphead, x);
if (pos)
{
SListErase(pphead, pos);
}
}
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
assert(pos);
assert(pphead);
if (pos == *pphead)
{
SListPushFront(pphead, x);
}
else
{
SLTNode* prev = *pphead;
while (prev->next != pos )
{
prev = prev->next;
}
SLTNode* newnode = BuySListNode(x);
prev->next = newnode;
newnode->next = pos;
}
}
void SListErase(SLTNode** pphead, SLTNode* pos)
{
assert(pphead);
assert(pos);
if (*pphead == pos)
{
SListPopFront(pphead);
}
else
{
SLTNode* prev = *pphead;
while (prev->next != pos)
{
prev = prev->next;
}
prev->next = pos->next;
free(pos);
}
}Frist.c
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include"SList.h"
#include<assert.h>
void menu()
{
printf("*****************************************************************\n");
printf("1、尾插 2、头插\n");
printf("3、尾删 4、头删\n");
printf("5、前面插 6、后面插\n");
printf("7、任意删 8、修改\n");
printf("9、打印 -1、退出\n");
printf("*****************************************************************\n");
}
void TestSList1()
{
SLTNode* n1 = NULL;
/*SLTNode* n1 = (SLTNode*)malloc(sizeof(SLTNode));
assert(n1);*/
//SLTNode* n2 = (SLTNode*)malloc(sizeof(SLTNode));
//assert(n2);
//SLTNode* n3 = (SLTNode*)malloc(sizeof(SLTNode));
//assert(n3);
//SLTNode* n4 = (SLTNode*)malloc(sizeof(SLTNode));
//assert(n4);
//n1->data = 1;
//n2->data = 2;
//n3->data = 3;
//n4->data = 4;
//n1->next = n2;
//n2->next = n3;
//n3->next = n4;
//n4->next = NULL;
SListPushFront(&n1, 1);
SListPushBack(&n1, 5);
SListPushBack(&n1, 2);
SListPushFront(&n1, 1);
SListPrint(n1);
SLTNode* a = SListFind(n1, 5);
SListModify(n1, 1, 6);
SListPrint(n1);
SListFrontPush(&n1, 1, 2);
SListPrint(n1);
SListPrint(n1);
}
int main()
{
SLTNode* n1 = NULL;
int option;
do {
menu();
if (scanf("%d", &option) == EOF)
{
printf("scanf输入错误\n");
break;
}
int val, pos;
switch (option)
{
case -1:
printf("退出\n");
exit(0);
break;
case 1:
printf("请连续输入你要尾插的数据，以0结束：\n");
scanf("%d", &val);
while (val != 0)
{
SListPushBack(&n1, val);
scanf("%d", &val);
}
break;
case 2: {
printf("请连续输入你要头插的数据，以0结束：\n");
scanf("%d", &val);
while (val != 0)
{
SListPushFront(&n1, val);
scanf("%d", &val);
}
break;
}
case 3:
SListPopBack(&n1);
break;
case 4:
SListPopFront(&n1);
break;
case 5:
{
int y;
int x;
printf("请输入你要的被插入的,和插入的值\n");
scanf("%d%d", &x, &y);
SListFrontPush(&n1, x, y);
break;
}
case 6:
{
int y;
int x;
printf("请输入你要的被插入的,和插入的值\n");
scanf("%d%d", &x, &y);
SListBackPush(&n1, x, y);
break;
}
case 7:
{
int x;
printf("请输入你要删除的值\n");
scanf("%d", &x);
SListPop(&n1, x);
}
case 8:
{
int y;
int x;
printf("请输入你要修改的位置,和修改后的值\n");
scanf("%d%d", &x, &y);
SListModify(n1, x, y);
break;
}
case 9:
SListPrint(n1);
break;
default:
exit(-1);
break;
}
} while (option != -1);
return 0;
}
链表面试题
【LeetCode】203. 移除链表元素的三种方法_江湖第一深情的博客-CSDN博客
给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
【LeetCode】206. 反转链表—力扣_江湖第一深情的博客-CSDN博客
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
【LeetCode】876. 链表的中间结点—力扣_江湖第一深情的博客-CSDN博客
给定一个头结点为 head 的非空单链表，返回链表的中间结点。
如果有两个中间结点，则返回第二个中间结点。
(3条消息) 剑指offer--链表中倒数第k个结点（jz22）_笨笨同学的博客-CSDN博客
输入一个链表，输出该链表中倒数第k个结点。
(3条消息) 【2016校招真题】OR36 链表的回文结构_笨笨同学的博客-CSDN博客
对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是否为回文结构。
给定一个链表的头指针A，请返回一个bool值，代表其是否为回文结构。保证链表长度小于等于900。
(3条消息) 【程序员面试宝典】CM11 链表分割_笨笨同学的博客-CSDN博客
现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。
(3条消息) 【LeetCode】21. 合并两个有序链表—力扣_笨笨同学的博客-CSDN博客
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
(3条消息) 【LeetCode】160. 相交链表—力扣_笨笨同学的博客-CSDN博客
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。
(3条消息) 【LeetCode】141. 环形链表—力扣_笨笨同学的博客-CSDN博客
给你一个链表的头节点 head ，判断链表中是否有环。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。
如果链表中存在环 ，则返回 true 。 否则，返回 false 。
(3条消息) 【LeetCode】142. 环形链表 II—力扣_笨笨同学的博客-CSDN博客
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
不允许修改 链表。
(3条消息) 【LeetCode】138. 复制带随机指针的链表—力扣_笨笨同学的博客-CSDN博客
给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。
构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。
例如，如果原链表中有 X 和 Y 两个节点，其中 X.random --> Y 。那么在复制链表中对应的两个节点 x 和 y ，同样有 x.random --> y 。
返回复制链表的头节点。
用一个由 n 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 [val, random_index] 表示：
val：一个表示 Node.val 的整数。
random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为 null 。
你的代码 只 接受原链表的头节点 head 作为传入参数。
扫一扫
1685
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
