动态顺序表的增删
顺序表: 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}
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);
}
}
}