常用的数据结构的增删代码-c语言

动态顺序表的增删

顺序表: 1.有唯一的表名 2.内存单元连续 3.数据顺序存放

链表

逻辑上连续,物理上不一定连续.

每个节点包括数据域和指针域

只要通过链表的头结点可以通过指针遍历整条链表

typedef struct node{
ElemType data ;  //数据域
struct node * next ;//指向下一个节点

}LNode ,*LinkList ; //LNode 是别名, linkList是指向结构体地址的指针类型定义

编写程序,从终端输入一组整数(10个以上),以0作为结束标志,将这一组整数存放在一个链表中(结束标志0不包括在内),打印出该链表的值,然后删除该链表中第5个元素,打印出删除后的结果,最后在内存中释放掉该链表

代码

typedef int ElemType; //定义一个数据结构

typedef struct node{

ElemType data;

int length;

struct node *next;

} LNode ,*LinkList;

//创建链表 n-节点个数

LinkList createLingList (int n){

LinkList p,r,list=NULL;

ElemType e;

int i;

for(int i =0;i<=n ; i++){

scanf(“%d”,&e); //输入节点内容

p=(LinkList)malloc(sizeof(LNode)); //为节点分配空间

p->data=e; // 数据域赋值

p->next=NULL;

if(!list){ //链表不存在

list =p;

}else{

r->next =p; //r代表链表的最后一个节点

}

r =p;

}

return list;

}

//插入节点,q为插入节点的前一个节点 e为节点的值,

void insertList(LinkList *list ,LinkList q;ElemType e){

LinkList p;

p =(LinkList)malloc(sizeof(e)); //p节点开辟空间

p->data=e;

if(! *list){ //list指向的节点为空,即头结点为空,则插入的节点为头结点

*list =p;

p->list =NULL;

}else{

p->next = q->next; //把 p插在 q后边

q->next = p;

}

}

//删除元素 q

void delList(LinkList *list ,linkList q){

if(q ==*list){

// 这里的 *list 表示 list 地址对应的值

*list =q->next;

}else{

//遍历 list

for( LinkList r =*list ; r->next !=q;r=r->next){

}

if(r->next !=null){

r->next =q->next;

free(q); //释放掉这个元素

}

}

}

//销毁数据结果,做法是从头结点开始删除

void destoryLinkList(LinkList *list){

LinkList p,q;

p=*list;

while(p){

q= p->next;

free(p);

p=q;

}

}

栈

1.是一种先进后出的线性表,

2.只能从表尾进行入栈和出栈操作

3.表尾 称为栈顶(top) ,表头称为栈底(base)

一般栈采用顺序表存储,顺序栈结构如下

tepedef sruct{
Elemtype *top;
Elemtype *base;
int stacksize;  //栈的容量
}sqStack ;

//创建一个栈
initStack(sqStack *s ){
//开辟一段内存空间,首地址赋值给 s->base
s->base =(Elemtype *)mallor( 10 * sizeof(ElemType));
s->top=s->base;  //开始的时候,栈顶就是栈底
s-stacksize =10;
}

//入栈操作
pushStack(sqStack *s ,Elemtype e){
if( s->top- s->base >= s->stacksize){ //栈的元素超过容量,需要重新分配空间
s->base =(Elemtype *)ralloc(s->base,(s->stacksize +10)sizeof(Elemtype));
if(!s->base ){
exit(0);  //分配空间失败,推出
}
s->top=s->base+ s->stacksize;  //这行我也不明白什么意思
s->stacksize +=10;    //设置栈的最大容量
s->top=e;
s->top++;  //top 始终指向栈顶元素的上一个空间
}
//弹出一个元素, 传入e的地址用来获得出栈的值
popStack(sqStack *s ,Elemtype *e){
if(s->top =s->base) return ;// 此时为空栈
s-top --; // 栈顶回退,指向最上边的元素
*e= *(s->top);
}

//清空栈,只需要把栈尾元素赋值给栈顶
clearStack(sqStack *s ){
s->top =s->base;
}
//销毁一个栈 , 意味着释放栈的空间
destoryStack(sqStack *s){
int size =s->stacksize;
int i;
for(i=0;i< size; i++ ){
free(s->base);  //释放栈底,栈向上一位
s->base ++;
}

s->base =s->top =NULL;
s->stacksize =0;
}

队列

1.队列是一种先进先出的线性表;

2.数据要从一端进入(队尾 rear),另一端离开(队头 front)

用链表实现的队列

typedef struct QNode{  //队列中的元素
QelemType data;    //存放数据的元素
struct QNode *next;
}QNde, *QueuePtr;

tepedef struct{
QueuePtr front;  //对头指针
QueuePtr rear;   //队尾指针
}LinkQueue ;

//创建队列

initQueue(LinkQueue *q){
//初始化一个空队列 ,对头队尾指向该节点
q->front=q->rear =(LinkQueue *)malloc(sizeof(QNode));
if(!q->front) exit(0);
q->front->next =NULL;  //头结点指针域置为NULL
}

//入队操作.从尾节点加入
enQueue(LinkQueue *q,ElemType e){
QueuePtr p;
p =(QueuePtr) mallor(sizeof(ElemType)); //创建节点,赋值
p->data=e;
p->next =NULL;
q->rear->next =p;  //尾节点指向p
q->rear =p;        //p称为新的尾节点
}

//出队操作,从对头出队,传入e的地址存放出队的数
deQueue(LinkQueue *q , ElemType *e){
if(q->front =q->rear ) return ; //队列为空
LinkQueuq p ;
*e =q->front->data;
p= q->front->next;
q->front->next =p->next;
//如果对头的下一个节点是队尾,修改队尾指针
if(q->rear ==p){
q->rear =q->front;
}
free(p);
}

//销毁一个队列
destoryQueue(LinkQueue *q){
while(q->front){  //q的队头不为空,
//此时把 q->rear 当作临时变量使用,队头不断出栈,直到队头为空
q->rear=q->front->next;
free(q->front){
q->front =q-rear;
}
}
}

循环队列

1.由顺序表实现,容量固定

2.空间可以循环使用,只要队列中还有空间未使用

3.约定,对头指针指向堆头元素,队尾指针指向队尾元素的下一个空间

#define MAXSIZE=10;
定义一个循环队列
typedef stuct {
Elemtype *base;  队列的内存分配基地址
int front; //队头
int rear;  //队尾
}cycleQueue ;

初始化循环队列
initcycleQueue(cycleQueue *q){
//分配十个单元的空间给循环队列
q->base =(cycleQueue *)mallor( MAXSIZE * siezeof(Elemtype);;//
if(! 1->base) exit(0);//分配空间失败
q->front =q->rear =0; //空队列,对头队尾指向0号单元
}

入队操作
void enqueue(cycleQueue *q ,Elemtype e){
//q->rear  和q->front 是数组的下标,当队列满时不能添加
if((q->rear +1)/MAXSIZE)=q->front; return ;
q->base[q->rear] =e;
q->rear=(q->rear +1)/MAXSIZE; //队尾指针加1
}
出队操作
void enqueue(cycleQueue * q,Enemtype *e){
if(q->front =q->rear) return ;
*e= q->base[q->front]; //取出对头元素,用e返回
q->front=(q->front +1)/MAXSIZE; //对头指向下一元素的位置
}

树结构

1.树只有一个根节点,

2.根节点的子节点又是一棵树

树的定义
#define MaxChild  10
typedef struct node{
dataType data;
struct node *child[MaxChild];
}

二叉树 它或者为空,或者由一个根节点加上两颗分别称为左子树,右子树的互不相交的二叉树组成.

结构定义
typeder srtuct BitNode{
ElemType data;  //数据域
struct BiTree lchild,rchild; //左子树 右子树
}BitNode ,*BiTree;

先序遍历:访问根节点,访问左子树,访问右子树
//传入根节点的地址 &t
preTree(BiTree t){
if(t){//遍历条件是节点不为空
viset(t->data);
preTree(t->lchild);
preTree(t->rchild);
}
}

中序遍历:先访问左子树,在访问根节点,在访问右子树
//此形参和上文的 BiTree t 意义相同,都代表接受一个 节点的地址
midTree(BitNode * t){
if(t){
preTree(t->lchild);
viset(t->data);
preTree(t->rchild);
}
}

后序遍历:先访问左子树,在访问右子树,在访问根节点
midTree(BitNode * t){
if(t){
preTree(t->lchild);
preTree(t->rchild);
viset(t->data);
}
}

图 由若干个顶点和顶点之间的边构成,若每条边都无序,称为无向图,每条边都有序称为有向图

1.图的存储方法,邻接矩阵存储法,临街表存储法

2:邻接矩阵: 用一个一位数组存储数据,一个二维数组存储定点间的相互关系,称为邻接矩阵,A[i][j] 定义如下

A[i][j]= { 1 当定点i 与顶点 j之间有边
{ 0 当定点i 与顶点 j之间无边

//数据域表示
int  vdata =[3,5,1,6];
//邻接矩阵表示如下
{0 1 0 1}
{0 0 1 0}
{0 0 0 1}
{0 0 0 0}

b41c
3.邻接矩阵:用一个链表存储顶点的数据信息,一个链表存储边的信息.

数组结构如下



vertex 表示顶点的数据.

next指向顶点对应的链表.

链表结构如下

weight 域表示权重,
adjvex 表示该边的另一端顶点在顶点数组中的位置
next  表示指向链接到该顶点的下一条边,通过next就把一个顶点的所有边连在了一起

邻接表的定义
#define MAX_NUM =20
tyepdef stuct ArcNode{
int adjvex  ; //该边的另一顶点在顺序表的位置
struct ArcNode *next ;//下一条边
infoType * weight ;//边的权重,可忽略
}ArcNode;

tyepdef stuct VNode{
VertexType data; //定点的数据信息
ArcNode * firstarc ;//指向第一条边
}VNode;
VNode G[MAX_NUM];

图的遍历
1.深度优先搜索:从某个顶点出发,访问该节点,在访问他的未被放过获得邻接点,继续深度优先递归搜索这个邻接点,直到所有邻接点都被搜索到,然后换一个未被访问的没有邻接的点继续递归深度优先搜索;

//v 表示顶点在顺序表中的坐标
//G[] 表示顶点v的顺序表
void DFS(VNode G[],int v){
int w;
visti(v); //访问该顶点
visited[v]=1;//将该顶点的访问状态值为已访问
w=fistAdj(G[],v) //找到v顶点的第一个邻接点,没有返回-1
while(w !=-1){
if(visited[w] ==0) //改顶点没被访问
DFS(G,w);
w=NextAdj(G,v); //找到下一个邻接点,没有返回-1
}
}
//visited 是标记数组, 标记每个顶点是否被访问
//n 为数组长度
void tarvel_dfs (VNode G[],int visited[],int n){
for( int  i=0;i< n;i++){
visited[i]=0;  //初始化所有定点为未访问
}
for( int i =0 ;i< n;i++){
if( visited[i]=0){  //找到没有访问的顶点,深度优先搜索
DFS(G,i);
}
}
}

广度优先搜索
从指定顶点v出发,先访问该顶点v,在访问v的未被访问的邻接点,再从邻接点出发,按同样规则访问他们未被访问的邻接点.直到v的所有邻接点都被访问,在换一个不邻接的顶点重复上述过程.
//v 表示要访问第几个顶点
//G[] 表示顶点数据的集合
void BFS(VNode G[] ,int v){
int w;
visit(v);  //将v 置为已访问
visited[v]=1;

enqueue(q,v); //将v入队列q中
while(!empty(q)){ //q不为空
dequeue(&q,&v)  // 在队列出队一个元素,放入v中
w=firstAdj(G,v);//得到v的第一个邻接点,没有返回-1
while(w!=-1){
if(visitde[w] ==0){ //w未被访问
vist(w);
enqueue(q,w); //w入栈
visited[w]=1;
}
//注意,这里是获取v的下一个邻接点,他与w是平级关系而不是找w的邻接点
w=nextAdj(G,v);
}
}
}
//g 顶点集合  visited 标记顶点是否被访问    n顶点个数
void travel_bfs(VNode G[],int visited[],int n){
int i;
for( i=0; i < n;i++){
visited[i]=0;
}
for( int i =0 ;i< n;i++){
if( visited[i]=0){  //找到没有访问的顶点,广度优先搜索
BFS(G,i);
}
}
}