C语言基础数据与结构 第二 三节课 不定顺序表 单链表 双链表

特点：
顺序表：逻辑相邻 物理不相邻 比较简单。（只记不定长）
随机访问时间复杂度：O（1）
插入时间复杂度：O （n） 尾插的时间复杂度：O(1)
删除的时间复杂度O（n） 尾删的时间复杂度 O（1）
查找search的时间复杂度 O(n)
单链表：逻辑相邻 物理不一定相邻。
随机访问的时间复杂度 O（n）
插入的时间复杂度O（1）不需要挪动数据 单纯的插入
删除的时间复杂度O（1）也不需要挪动数据

如果我经常访问节点 不经常插入和删除 则选择顺序表
如果我经常插入和删除 不经常访问 则选择 单链表。

不定长顺序表的编写：
图解如下：

其中 int*data 部分 是malloc来的；最后也是free这里；

DSQlist.h部分

#pragma once
//定长顺序表 简单 但不实用 sqlist=sequence list 即一系列的列表；

#define INIT_SIZE 10

typedef struct DSQlist
{
	int *data；//数据域 用来承接malloc申请的空间
	int length；//有效长度个数
	int listsize//总的空间大小（简单理解为总的格子个数）
}; DSQlist * PDSQlist;

//关于顺序表的增删该查
//初始化函数
void Init_list(PDSQlist ps);
//插入数据 按pos插入
bool Insert(PDSQlist ps, int pos, int val);
//删除数据 按位置删除pos
bool Del_val(PDSQlist ps, int pos);//bool类型来判断是否删除成功；

//按值删除val 第一次遇到的
bool Del_val(PDSQlist ps, int val);
//查找 找到值为val的第一个元素 返回其下标 没有找到 返回-1
int Search(PDSQlist ps, int val);
//判空
bool IsEmpty(PSDQlist ps);
//判满 涉及到扩容问题
bool IsFull(PDSQlist ps);
//扩容问题
void Inc(PDSQlist ps);
//清空
void Clear(PDSQlist ps);
//销毁
void Destriy(PDSQlist ps)；
//打印
void Show(PDSQlist ps);

DSQlist.cpp部分

#include <stdio.h>//输入 输出
#include <stdlib.h>//malloc
#include <assert.h>//断言
#include "DSQlist.h"//自己写的.h文件的传入

//关于顺序表的增删该查
//初始化函数
void Init_list(PDSQlist ps);
{
	assert(ps != NULL);//后面每个都要加断言
	if (ps == = NULL)
	{
		return;
	}
	ps->data = (int)*malloc(sizeof(int) * INIT_SIZE);//用来承接malloc申请的内存
	assert(ps->data != NULL);

	ps->length = 0;
	ps->listsize = INIT_SIZE;
}

//插入数据 按pos插入
bool Insert(PDSQlist ps, int pos, int val);
{
	assert(ps != NULL);
	if (ps == = NULL)
	{
		return;
	}
	if (pos<0 || pos>ps->length)//安全控制 判断插入位置的合法性
	{
		return flase；//bool类型返回假
	}
	if（Isfull(ps))//如果满了就扩容
	{
	Inc(ps);
    }
	//挪动数据 把插入位置空间 空出来
	for (int i = ps->length - 1; i >= pos; i--)//最后一个有效元素下标的前一位 
	{
		ps->data[i + 1] = ps->data[i];
	}
	//把值放进去
	ps->data[pos] = val;
	//有效长度length++
	ps->length++;
	return true;
}

//删除数据 按位置删除pos
bool Del_val(PDSQlist ps, int pos);//bool类型来判断是否删除成功；
{
	assert(ps != NULL);
	if (ps == = NULL)
	{
		return;
	}
	if (pos < 0 || pos >= ps->length)//判断删除位置pos的合法性
	{
		return false;
	}
	//如果空 就不允许删除操作
	//挪动数据 往前覆盖
	for (int i = pos; i + 1 < ps->length)
	{
		ps->data[i] = ps->data{ i + 1];
	}
	//有效长度 ps->length--
	ps->length--;
	return ture;
}
//按值删除val 第一次遇到的
bool Del_val(PDSQlist ps, int val);
{
	assert(ps != NULL);
	if (ps == = NULL)
	{
		return;
	}
	//通过search来找val的下标
	int i = search(ps, val);
	if (i == -1)//如果i==-1代表么找到 则直接退出
	{
		return false;
	}
	//找到 则直接调用 按位置pos删除函数 即可 ps->length不需要再减减 
	//因为函数本身调用时候已经减减过了
	Del_pos(ps, i);
	return true;
}


//查找 找到值为val的第一个元素 返回其下标 没有找到 返回-1
int Search(PDSQlist ps, int val);
{
	assert(ps != NULL);
	if (ps == = NULL)
	{
		return;
	}
	for (int i = 0; i < ps->length; i++)
	{
		if (val == ps->data[i])
		{
			return i;
		}
	}
	return -1;//遍历没找到值为val的元素；
}

//判空
bool IsEmpty(PSDQlist ps);
{
	ps->length == 0;
}

//判满 涉及到扩容问题
bool IsFull(PDSQlist ps);
{
	ps->length == ps->listsize;
}

//扩容问题 按两倍扩容
static void Inc(PDSQlist ps);//malloc realloc calloc
{
	ps->data = (int*)realloc(ps->data, sizeof(int) * ps->listsize * 2);//扩容
	assert(ps->data != NULL);
	ps->listsize *= 2；//总的空间个数乘2
		
}

//清空
void Clear(PDSQlist ps);
{

	ps->length = 0;
}
//销毁
void Destriy(PDSQlist ps);
{
	free(ps->data);//1 释放动态内存空间
	ps->data = NULL;//2
	ps->length = 0;//3
	ps->listsize = 0;//4
}

//打印
void Show(PDSQlist ps);
{
	for (int i = 0; i < ps->length; i++)
	{
		printf("%d", ps->data[i]);

	}
	printf("\n");
}

带头结点单链表的编写：

步骤：按位置插入 1.assert 2.创建一个新节点 3.找到合适的插入位置 4.直接插入

list.h部分

#pragma once 

typedef int ELEMTYPE;

typedef struct Node
{
	ELEMTYPE data;//数据域  保存其数据本身
	struct Node* next;//指针域  指向下一个数据节点的地址
}Node, *PNode;

//增删改查

//初始化
void Init_list(Node * plist);//Node * == PNode

//头插
bool Insert_head(PNode plist, int val);

//尾插
bool Insert_tail(PNode plist, int val);

//按位置插入  pos  
bool Insert_pos(PNode plist, int pos, int val);

//按位置删除 pos 
bool Del_pos(PNode plist, int pos);

//按值删除 遇到值为val的第一个有效节点 删除掉 释放其内存
bool Del_val(PNode plist, int val);

//查找search 查找值我val的第一个节点，返回其地址
struct Node *Search(PNode plist, int val);

//寻找值为val的节点的前驱
Node *Get_prior(PNode plist, int val);

//寻找值为val的节点的后继
Node *Get_next(PNode plist, int val);

//判空
bool IsEmpty(PNode plist);

//判满
bool IsFull(PNode plist);

//获取其有效值长度
int Get_length(PNode plist);

//清空
void Clear(PNode plist);

//销毁
void Destroy(PNode plist);

//打印
void Show(PNode plist);

list.cpp部分

#include <stdio.h>
#include <assert.h>
#include <malloc.h>
#include "list.h"

//作业 to do  补全代码

//初始化
void Init_list(Node * plist)//Node * == PNode
{
	assert(plist != NULL);
	if(plist == NULL)
		return;

	//plist->data; 不需要初始化， 因为没有使用，直接浪费掉了
	plist->next = NULL;
}

//头插
bool Insert_head(PNode plist, int val)
{
	//assert 

	//申请新节点
	Node *pnewnode = (Node *)malloc(sizeof(Node) * 1);
	assert(pnewnode != NULL);
	pnewnode->data = val;
	//pnewnode->next = NULL; 这里不需要初始化， 因为接下来就会对其重新赋值

	//直接插入 1 2 顺序不能反
	pnewnode->next = plist->next;//1
	plist->next = pnewnode;//2
	return true;
}

//尾插
bool Insert_tail(PNode plist, int val)
{     
 //1.断言
	assert(plist != NULL);
	if (plist == NULL)
		return;
//2.创建新节点
	Node* pnewnode = (Node*)malloc(sizeof(Node));
	assert(pnewnode != NULL);
	pnewnode->data = val;
	//3.找到合适的插入位置
	Node* p = plist;
	for (p = plist; p->next != NULL; p = p->next);//让for循环跑完 p刚好指向最后一个有效节点
	//4.插入
	pnewnode->next = p->next;
	p->next = pnewnode;
}



//按位置插入  pos  
bool Insert_pos(PNode plist, int pos, int val)
{
	assert(plist != NULL);//判空

	if (plist == NULL)
	{
		return;
	}

	if (pos < 0 || pos >= ps->Get_length(plist))//安全控制 判断插入位置的合法性 且 "=" 的时候非法
	{
		return flase；//bool类型返回假
	}

	Node* pnewnode = (Node*)malloc(size of(Node) * 1);//创建一个新节点
	assert(pnewnode != NULL);
	pnewnode->data = val;
	//找到合适的插入位置 根据pos
	Node* p = plist;
	for (int i = 0; i < pos; i++)
	{
		p = p->next;
	}
	pnewnode->next = p->next;//新节点的next赋值为之前上一个节点的next域 保证剩余的节点不丢失
	p->next = pnewnode;//让前驱节点的next指向新节点 
	return ture//bool类型 返回 ture或者 false；
}
	//讨论这两种写法
   //for(p=plist;p->next!=NULL;p=p->next);先指向头结点 适用于插入和删除操作 需要前驱
   //for(p=plist->next;p!=NULL;p=p->next);先指向有效节点 不需要前驱 经常用来打印和查找操作
    


//按位置删除 pos 
bool Del_pos(PNode plist, int pos)
{
	assert(plist != NULL);//判空

	if (plist == NULL)
	{
		return;
	}

	if (pos<0 || pos>=ps->Get_length(plist))//安全控制 判断插入位置的合法性 且 "=" 的时候非法
	{
		return flase；//bool类型返回假
	}
	//1.找到删除节点的上一个节点 使删除节点的上一个节点 指向删除节点的下一个节点 再把要删除的节点free掉
	Node* p = plist;
	for (int i = 0; i < pos; i++)
	{
		p = p->next;
	}
	//2.删除要删除的节点
	Node* q = p->next;//申请一个新指针指向要删除的节点
	p->next = q->next;//或者p->next=p->next->next;//要删除的上一个节点的next指向删除节点的下一个节点
	free(q);//释放要删除的节点
	return ture;
	  
}

//按值删除 遇到值为val的第一个有效节点 删除掉 释放其内存
bool Del_val(PNode plist, int val)
{
	assert(plist != NULL);//判空

	if (plist == NULL)
	{
		return;
	}
	Node*p=Get_prior(plist,val)
		if (p == NULL)
		{
			return false;
		}
	Node* q = p->next;//申请一个新指针指向要删除的节点
	p->next = q->next;//要删除的上一个节点的next指向删除节点的下一个节点
	free(q);
	return ture;
}



//查找search 查找值我val的第一个节点，返回其地址
struct Node *Search(PNode plist, int val)
{
	assert(plist != NULL);//判空

	if (plist == NULL)
	{
		return;
	}
	//遍历一遍单链表 找值为val的节点 将其地址返回
	for (Node* p = plist->next; p != NULL; p = p->next)
	{
		if (p->next = val)
		{
			return p;
		}
	}
	return NULL;
}

//寻找值为val的节点的前驱
Node* Get_prior(PNode plist, int val)
{
	assert(plist != NULL);//判空

	if (plist == NULL)
	{
		return;
	}
	Node* p = plist;
	for (p; p->next != NULL; p = p->next)
	{
		if (p->next->data == val)
		{
			return p;
		}
	}
	return NULL;
}


//寻找值为val的节点的后继
Node* Get_next(PNode plist, int val)
{
	Node* p = search(plist, val);
	if (p == NULL)
	{
		return NULL;

	}
	return p->next;
}


//判空
bool IsEmpty(PNode plist)
{
	return plist-> == NULL;
}

//判满
//bool IsFull(PNode plist) 单链表不需要判满操作

//获取其有效值长度
int Get_length(PNode plist)
{
	int count = 0;
	for (Node* p = plist->next; p != NULL; p = p->next)
	{
		count++;
	}
	return count;
}

//清空//单链表的清空 销毁 的实现方式一致 都是吧malloc来的节点全部释放掉
void Clear(PNode plist)
{
Destroy(plist);	
}

//销毁 一致头删 简单 因为只使用了了一个临时指针
void Destroy(PNode plist)//一直头删
{
	assert(plist != NULL);//判空

	if (plist == NULL)
	{
		return;
	}
	while （plist->next != NULL;)//判断第一个有效节点是否存在
	{
	 Node *p = plist->next;
	 plist->next = p->next;
	 free(p);
     }
	plist->next = NULL;//此时没有有效节点 那么将plist->nexxt 置为NULL
}


//打印
void Show(PNode plist)
{
	for (Node* p = plist->next; p != NULL; p = p->next)//第二个for循环
	{
		printf("%d", p->data);
	}
	printf("\n");
}