线性表（C语言）

1.线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结
构，常见的线性表：顺序表、链表、栈、队列、字符串…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

2.顺序表

2.1概念及结构

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。
顺序表一般可以分为：

1. 静态顺序表：使用定长数组存储元素。
2. 动态顺序表：使用动态开辟的数组存储。

2.2接口实现

静态顺序表只适用于确定知道需要存多少数据的场景。
静态顺序表的定长数组：N定大了，空间浪费，开少了不够用。
现实中基本都是使用动态顺序表，根据需要动态的分配空间大小。

2.3代码实现

点击 码云SeqList 跳转获取代码

2.4练习题

1.移除元素（时间O(N)、空间O(1)）

int removeElement(int* nums, int numsSize, int val)
{
	int src = 0, dst = 0; 
	while (src < numsSize)
	{
	遍历数组 不是目标值 双指针后移
	直到找到目标值 src后移 dst不动 
	从找到目标值到下一次遇到非目标值 
	此时src指向下一个非目标值
	dst记录第一个目标值
	执行赋值操作后双指针后移
	以此循环
		if (nums[src] != val)
			nums[dst++] = nums[src++];
		else
			src++;
	}
	dst指向的是值的下一位即有效数组长度
	return dst;
}

2.删除重复项

1.C语言实现

int removeDuplicates(int* nums, int numsSize)
{
	int src = 1, dst = 0;
	while (src < numsSize)
	{
	dst=0 src=1 
	若相等 src后移
	若不相等 dst先后移一次 srd赋值后后移
	以此循环
		if (nums[src] == nums[dst])
			src++;
		else
			nums[++dst] = nums[src++];
	}
	若此时遍历完毕 dst指向最后一个值 数组长度==dst+1
	return dst + 1;
}

2.C++实现

直接粘贴C语言的代码—修改两个地方

加一条语句也能AC—修改了nums的size

3.合并两个有序数组

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2size, int n)
{
end1：数组1有效数据的下标
end2：数组2的有效数据的下标
end ：数组1的最后一个数据的下标
	int end1 = m - 1, end2 = n - 1;
	int end = m + n - 1;

	while (end1 >= 0 && end2 >= 0)
	{
	取大数放到数组1末尾
		if (nums1[end1] > nums2[end2])
			nums1[end--] = nums1[end1--];
		else
			nums1[end--] = nums2[end2--];
	}
	end1结束，end2未结束
	while (end2 >= 0)
		nums1[end--] = nums2[end2--];
}

2.5优缺点

1.优点

物理空间连续，可依靠下标进行随机访问

2.缺点

1.空间不够需要扩容，扩容有性能消耗，存在空间浪费。
2.头部/中间位置插入删除效率低下，需要挪动数据

3.改善

有没有一种结构，可以1.按需要申请/释放空间。2.头部或中间插入删除，不需要挪动数据–>链表

3.单链表

3.1图解

3.2代码

点击 SList（C） 跳转码云获取代码

3.图析

4.双向链表

4.1链表的分类

4.2模拟实现

点击 双向链表 跳转码云获取完整代码！

2.1尾插

2.2头插

4.3代码

List.c
#define _CRT_SECURE_NO_WARNINGS
#include "List.h"

//创建新结点 + 初始化
LTNode* CreatListNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

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

	return node;
}

//初始化1.0--二级指针
/*
void ListInit(LTNode** pphead)
{
	*pphead = CreatListNode(-1);
	(*pphead)->next = *pphead;
	(*pphead)->prev = *pphead;
}
*/
//初始化2.0--返回值
LTNode* ListInit()
{
	LTNode* phead = CreatListNode(-1);

	phead->prev = phead;
	phead->next = phead;

	return phead;
}

//打印
void ListPrint(LTNode* phead)
{
	assert(phead);

	//哨兵位的next结点为real头结点
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

//判空
bool ListEmpty(LTNode* phead)
{
	assert(phead);

	return phead->next == phead;
}

//尾插
void ListPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);

	/*
	LTNode* newnode = CreatListNode(x);
	//定位尾结点
	LTNode* tail = phead->prev; 头结点的prev就是尾结点空间地址
	//连接新结点
	//1.0尾结点后连新结点
	tail->next = newnode;
	//2.0新结点前连尾结点(注意：连接结点均为空间地址)
	newnode->prev = tail;
	//断旧指新
	newnode->next = phead;
	phead->prev = newnode;
	*/

	ListInsert(phead, x);
}

//头插1.0--需要注意顺序
/*
* void ListPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* newnode = CreatListNode(x);

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

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

//头插2.0
void ListPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);

	/*
	* LTNode* newnode = CreatListNode(x);

	LTNode* realhead = phead->next;  //记录realhead空间地址
	//哨兵位连接new
    phead->next = newnode;           //哨兵位的尾连接new的空间地址
	newnode->prev = phead;           //new的prev连接哨兵位
	//new连接realhead
	newnode->next = realhead;
	realhead->prev = newnode;
	*/

	ListInsert(phead->next, x);
}



//尾删
void ListPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);  //assert(!ListEmpty(phead));
	
	/*
	//定位尾结点空间地址
	LTNode* tail = phead->prev;
	//记录尾结点的prev的空间地址
	LTNode* tailPrev = tail->prev;
	//释放旧尾结点
	free(tail);
	//连接新尾结点
	tailPrev->next = phead; //前连后
	phead->prev = tailPrev; //后连前
	*/

	ListErase(phead->prev);
}

//头删
void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	ListErase(phead->next);
}

// 在pos位置之前插入x
void ListInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	
	LTNode* newnode = CreatListNode(x);
	
	// prve newnode pos

	//记录prev
	LTNode* prev = pos->prev;
	//prev连接new
	prev->next = newnode;
	newnode->prev = prev;
	//new连接pos
	newnode->next = pos;
	pos->prev = newnode;
}

//  删除pos位置的节点
void ListErase(LTNode* pos)
{
	assert(pos);
	//记录prev、next
	LTNode* prev = pos->prev;
	LTNode* next = pos->next;
	//prev和next相连
	prev->next = next;
	next->prev = prev;
	//释放pos
	free(pos);
}

5.顺序表和链表的比较