【嵌入式学习】数据结构-Day3&4-链表
链表
链表：线性表的链式存储，称为链表
逻辑结构：线性结构(一对一)
存储结构：链式存储(使用任意一段存储空间实现的存储形式)
链表特点：逻辑相邻，物理不一定相邻
链表分类：单向链表、单向循环链表、双向链表、双向循环链表
引入目的：顺序表的插入和删除时间复杂度是O(n),需要移动大量元素，效率低，
并且顺序表存在满的情况，引出链表，插入和删除不需要移动元素。
1> 单链表的概念
1.单向链表：链表只可以单向遍历
2.认识节点：
单向链表的节点：数据域、指针域
数据域：存储数据元素
指针域：节点之间的关系(下一个节点的地址)
3.头节点和头指针
4.插入和删除
2> 单链表的操作
1.单向链表节点创建
typedef int datatype;
//创建节点结构体
typedef struct Node {
datatype data;
struct Node* next;
}*linklist;
/*
* function: 链表的创建
* @param [ in
* @param [out]
* @return
*/
linklist creat_node(){
linklist p=(linklist)malloc(sizeof(struct Node));
if(NULL == p)
return NULL;
p->data=0;
p->next=NULL;
return p;
}
2.单向链表头插
/*
* function: 头删
* @param [ in] list
* @param [out]
* @return
*/
linklist delete_head(linklist list){
if(NULL==list)
return list;
linklist del=list;
list=list->next;
free(del);
del=NULL;
return list;
}
3.单向链表尾插
/*
* function: 尾插
* @param [ in]
* @param [out]
* @return
*/
linklist insert_rear(linklist list,datatype element){
linklist p=creat_node();
if(NULL==p){
return list;
}
p->data=element;
if(NULL==list){
list=p;
}else{
linklist temp=list;
while(temp->next!=NULL){
temp=temp->next;
}
temp->next=p;
}
return list;
}
4.单向链表头删
/*
* function: 头删
* @param [ in] list
* @param [out]
* @return
*/
linklist delete_head(linklist list){
if(NULL==list)
return list;
linklist del=list;
list=list->next;
free(del);
del=NULL;
return list;
}
5.单向链表尾删
/*
* function: 尾删
* @param [ in]
* @param [out]
* @return
*/
linklist delete_rear(linklist list){
if(NULL==list)
return NULL;
if(list->next==NULL){
free(list);
list=NULL;
return list;
}else{
linklist p=list;
while(p->next->next!=NULL){
p=p->next;
}
free(p->next);
p->next=NULL;
}
return list;
}
6.单向链表遍历
/*
* function: 计算linklist长度
* @param [ in]
* @param [out]
* @return
*/
int len_linklist(linklist list){
int count=0;
while(list!=NULL){
list=list->next;
count++;
}
return count;
}
7.单向链表任意位置插入+计算长度
/*
* function: 任意位置插入
* @param [ in]
* @param [out]
* @return 头
*/
linklist insert_pos(linklist list,int pos,datatype element){
if(pos<1 || pos>len_linklist(list)+1){
return list;
}
if(pos==1){
return insert_head(list,element);
}
linklist p=list;
for (int i = 1; i < pos-1; i++) {
p=p->next;
}
linklist s=creat_node();
if(NULL==s)
return list;
s->data=element;
s->next=p->next;
p->next=s;
return list;
}
8.单向链表任意位置删除
/*
* function: 位置删除
* @param [ in]
* @param [out]
* @return
*/
linklist delete_pos(linklist list,int pos){
if(NULL==list||pos<1 || pos>len_linklist(list)){
return list;
}
if(pos==1){
return delete_head(list);
}
linklist p = list;
for (int i = 1; i < pos-1; i++) {
p=p->next;
}
linklist del=p->next;
p->next=del->next;
free(del);
del=NULL;
return list;
}
9.单向链表任意位置修改
/*
* function: 位置修改
* @param [ in] list,pos,element
* @param [out]
* @return
*/
void update_pos(linklist list,int pos,datatype element){
if(NULL==list||pos<1||pos>len_linklist(list)){
return;
}
linklist p=list;
for (int i = 1; i < pos; i++) {
p=p->next;
}
p->data=element;
}
10.单向链表任意位置查找
/*
* function: 位置查找
* @param [ in] list,pos
* @param [out]
* @return data
*/
datatype find_pos(linklist list,int pos){
if(NULL==list||pos<1||pos>len_linklist(list)){
return error;
}
linklist p=list;
for (int i = 1; i < pos; i++) {
p=p->next;
}
return p->data;
}
11.单向链表任意元素查找
//按元素查找
datatype search_data(linklist head,datatype element_data){
if(head==NULL)
return 0;
linklist h=head;
while(h!=NULL)
{
if(element_data==h->data)
{
return h->data;
}else{
h=h->next;
}
}
}
12.单向链表任意元素修改
//按元素修改
linklist change_data(linklist head,datatype element_data,datatype element_ch){
if(head==NULL)
return head;
linklist h=head;
while(h!=NULL)
{
if(element_data==h->data)
{
h->data=element_ch;
return head;
}else{
h=h->next;
}
}
}
13.单向链表任意元素删除
14.单向链表逆置(面试)
/*
* function: 单向链表逆置
* @param [ in] list
* @param [out]
* @return list
*/
linklist invert(linklist list){
if(NULL==list || NULL==list->next)
return list;
linklist p=list->next;
list->next=NULL;
while(p!=NULL){
linklist temp=p;
p=p->next;
temp->next=list;
list=temp;
//p=p->next;
//printf("p=%p\n",p);
}
return list;
}