线性表

线性表分为顺序表和链表。

顺序表：空间大小固定，方便查找，当插入数据的时候要移动数据。

链表：在每一个数据元素中添加一个保存下一个数据的地址，在插入和删除数据的时候比较方便。

 单链表的查找删除原理图

1.设计数据元素的类型（设计链表节点类型）

typedef struct _LinkList{
    int data;//存储数据
    struct _LinkList *next;//保存下一个数据的地址
}LinkList;

（1）创建链表

LinkList *create_link();

（2）创建链表节点

LinkList *create_node(int data);

（3）销毁链表

bool destroy_link(LinkList *head);

（4）插入数据------头插法、尾插法

bool insert_link(LinkList *head);

（5）删除数据

bool delete_link(LinkList *head,int data);

（6）查找数据

LinkList *select_link(LinkList *head,int data);

（7）显示数据

void display_link(LinkList *head);

 下面是程序

顺序表

sqlist.h

#ifndef SQLIST_H
#define SQLIST_H

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <unistd.h>

//设计顺序表
#define SIZE 10
typedef struct _Sqlist
{
　　int data[SIZE];
　　int length;
}Sqlist;

//创建顺序表
Sqlist *create_sqlist();
//销毁顺序表
bool destroy_sqlist(Sqlist *sq);
//插入数据
bool inset_sqlist(Sqlist *sq,int data);//尾插法
//查找数据
int select_sqlist(Sqlist *sq,int data);
//删除数据
bool delete_sqlist(Sqlist *sql,int data);
//获取数据长度
int get_size(Sqlist *sq);
//显示数据
void display_sqlist(Sqlist *sq);

#endif

sqlist.c

#include "sqlist.h"

//创建顺序表
Sqlist *create_sqlist()
{
　　Sqlist *sq = (Sqlist*)malloc(sizeof(Sqlist));
　　if(sq == NULL)return NULL;
　　sq->length = 0;
　　return sq;
}

//销毁顺序表
bool destroy_sqlist(Sqlist *sq)
{
　　if(sq == NULL)return false;
　　free(sq);
　　sq == NULL;
}


//插入数据,尾插法
bool insert_sqlist(Sqlist *sq,int data)
{
　　//判断顺序表时空是空的，或者已经满了
　　if(sq == NULL)return false;
　　if(sq->length == SIZE-1)return false;
　　
　　sq->data[sq->length] = data;
　　sq->length+=1;
　　return ture;
}

//查找数据
int select_sqlist(Sqlist *sq,int data)
{
　　if(sq == NULL)return -1;
　　
　　for(int i = 0;i<sq->length;i++)
　　{
　　　　//返回data所在的位置
　　　　if(sq->data[i] == data)return i;
　　}
　　//没有查到就返回-1
　　return -1;
}

//删除数据
bool delete_sqlist(Sqlist *sq,int data)
{
　　//查找位置
　　int pos = select_sqlist(sq,data);
　　//要找的数据不再表中
　　if(pos == -1)return false;
　　printf("要删除的位置:%d
",pos};
　　for(int i = pos+1;i<sq->length;i++)
　　{
　　　　//移动数据
　　　　sq->data[i-11] = sq->data[i];
　　}
sq->length -=1;
return rtue;
}

//获取数据长度
int get_size(Sqlist *sq)
{
　　if(sq == NULL)return 0;
　　return sq->length;
}

//显示数据
void display_sqlist(Sqlist *sq)
{
　　if(sq == NULL)return;
　　for(int i = 0;i <sq->length;i++)
　　{
　　　　printf("%d	",sq->data[i];
　　}
　　printf("
");
}

1顺序表.c

#include <stdio.h>
#include "sqlist.h"

int main()
{
　　Sqlist *sq = create_sqlist();
　　
　　insert_sqlist(sq,100);
　　insert_sqlist(sq,200);
　　insert_sqlist(sq,300);
　　printf("size = %d",get_size(sq));
　　display_sqlist(sq);
　　delete_sqlist(sq,100);
　　display_sqlist(sq);

　　bool f = destroy_sqlist(sq);
　　return 0;
}

 下面是链表的代码

linklist.h

#ifndef LINKLIST_H
#define LINKLIST_H
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <unistd.h>

typedef int elemType;

typedef struct _LinkList{
　　elemType data;
　　struct _LinkList *next;
}LinkList;

//创建链表
LinkList *create_link();
//创建链表节点
LinkList *create_node(elemType data);
//销毁链表
bool destroy_link(LinkList *head);
//插入数据　　头插法、尾插法
bool insert_link(LinkList *head,elemType data);
bool insert_link_tail(LinkList *head,elemType data);
//删除数据
bool delete_link(LinkList *head,elemType data);
//查找数据
LinkList *select_link(LinkList *head,elemType data);
//显示数据
void display_link(LinkList *head);
#endif

linklist.c

#includeLinkList *create_link()
{
　　return create_node(0);
}

//创建链表节点
LinkList *create_node(elemType data)
{　　
　　//创建链表节点
　　LinkList *node = malloc(sizeof(LinkList));
　　if(node == NULL){
　　　　perror("create node fail");
　　　　return NULL;
　　}
　　//初始化节点
　　node->next = NULL;
　　node->data = data;
　　return node;
}

//销毁链表
bool destroy_link(LinkList *head)
{　　
　　if(head == NULL)return false;//判空
　　while(head->next != NULL)//当头结点不是链表的最后一个节点
　　{
　　　　LinkList *node = head->next;
　　　　head->next = node->next;
　　　　free(node);
　　　　node = NULL;
　　}
　　free(head);
　　head = NULL;
　　return ture;
}

//插入数据　　头插法、尾插法
bool insert_link(LinkList *head,elemType data)
{
　　if(head == NULL){
　　　　perror("链表不存在");
　　　　return false;
　　}
　　//创建一个新的节点
　　LinkList *node = create_node(data);
　　//把node节点添加到head后面
　　node->next = head->next;
　　head->next = node;
　　return true;
}

//尾插法
bool insert_link_tail(LinkList *head,elemType data)
{　　
　　if(head == NULL){
　　　　perror("链表不存在");
　　　　return false;
　　}
　　//创建一个新的节点
　　LinkList *node = create_node(data);
　　//遍历到链表的尾部
　　while(head->next != NULL)head = head->next;
　　//把node连接在head的后面
　　head->next = node;
　　return true;
}

//删除数据
bool delete_link(LinkList *head,elemType data)
{
　　LinkList *p =select_link(head,data);
　　if(p == NULL)return false;
　　LinkList *node = p->next;
　　p->next = node->next;
　　free(node);
　　node = NULL;
　　return true;
}

//查找数据
LinkList *select_link(LinkList *head,elemType data)
{
　　if(head == NULL)return NULL;
　　while(head->next != NULL)
　　{
　　　　if(head->next->data == data)
　　　　return head;
　　　　
　　　　//往后偏移
　　　　head = head->next;
　　}
　　return NULL;
}

//显示数据
void display_link(LinkList *head)
{
　　if(head == NULL)return;
　　if(head->next == NULL)return;
　　head = head->next;//跳过头结点
　　while(head != NULL)
　　{
　　　　printf("%d",head->data);
　　　　head = head->next;
　　}
　　printf("
");
}

1链表.c

#include <stdio.h>
#include "linklist.h"

int main()
{
　　LinkList *head create_link();
　　int i = 1;
　　for(i=1;i<10;i++)
　　{
　　　　insert_link(head,i);
　　}
　　display_link(head);
　　delete_link(head,i);
　　display_link(head);
　　return 0;
}

 下面是双向链表

双向链表的插入原理图

删除的原理图

dlinklist.h

#ifndef DLINKLIST_H
#define DLINKLIST_H
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <unistd.h>

typedef int elemType;

typedef struct _DlinkList{
　　elemType data;
　　struct _DLinkList *next;
　　struct _DLinkList *prev;
}DLinkList;

//创建链表
DLinkList *create_link();
//创建链表节点
DLinkList *create_node(elemType data);
//销毁链表
bool destroy_link(DinkList *head);
//插入数据　　头插法、尾插法
bool insert_link(DLinkList *head);
//删除数据
bool delete_link(DLinkList *head,elemType data);
//查找数据
DLinkList *select_link(DLinkList *head,elemType data);
//显示数据
void display_link(DLinkList *head);
#endif

dlinklist.c

#include "dlinklist.h"

//创建链表
DLinkList *create_link()
{
　　return create_node();
}

//创建链表节点
DLinkList *create_node(elemType data)
{　　
　　DLinkList *node = malloc(sizeof(DLinkList));
　　node->data = data;
　　node->prev = node->next = NULL;
　　return node;
}

//销毁链表
bool destroy_link(DLinkList *head){]
//插入数据　　头插法、尾插法
bool insert_link(DLinkList *head,elemType data)
{
　　//判断head->next是否是为NULL
　　DLinkList *node = create_node(data);
　　head->next = node;
　　head->precv = head;
　　
　　node->next = head->next;
　　node->prev = head;
　　head->next->prev = node;
　　head->next = node;
}

//删除数据
bool delete_link(DLInkList *head,elemType data){}

//查找数据
DLinkList *select_link(DLinkList *head,elemType data){]

//显示数据
void display_link(DLinkList *head){}

1双向链表.c

 PS：为了加深我自己的印象，因为太久没写数据结构了，里面的代码就没有用ctrl+c，所以可能有手打错的地方，如果有错误麻烦指出来，大家互相学习 0-0