第二章 线性表
1.顺序表的增删查
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 50 //定义线性表的最大长度
typedef int ElemType;
//静态分配
typedef struct{
ElemType data[MaxSize];//顺序表的元素
int length;//当前顺序表中有多少个元素
}SqList; //顺序表的类型定义
//动态分配
#define InitSize 100 //表长度的初始定义
typedef struct{
ElemType *data; //指示动态分配数组的指针
int capacity;//动态数组的最大容量
int length;//当前个数
}SeqList;
/*
C的初始动态分配语句为:
L.data=(ElemType*)malloc(sizeof(ElemType)*InitSize)
申请是malloc,释放是free
*/
//i代表插入的位置(1<=i<=L.length+1),从1开始,e要插入的元素
bool ListInsert(SqList &L,int i,ElemType e)
{
if(i<1||i>L.length+1)//判断要插入的位置是否合法
return false;
if(L.length>=MaxSize)//存储空间已满,不能插入
return false;
for(int j=L.length;j>=i;j--)//移动顺序表中的元素
L.data[j]=L.data[j-1];
L.data[i-1]=e;//数组下标从零开始,插入第一个位置,访问的下标为0
L.length++;//顺序表长度加1
return true;
}
//删除第i(1<=i<=L.length)个位置的元素,使用元素e的引用的目的是拿出对应的值
bool ListDelete(SqList &L,int i,ElemType &e)
{
if(i<1||i>L.length)//如果删除的位置是不合法
return false;
e=L.data[i-1];//获取顺序表中对应的元素,赋值给e
for(int j=i;j<L.length;j++)
L.data[j-1]=L.data[j];
L.length--;//删除一个元素,顺序表长度减1
return true;
}
//按值查找成功,返回位置,位置从1开始,查找失败,返回0
int LocateElem(SqList L,ElemType e)
{
int i;
for(i=0;i<L.length;i++)
if(L.data[i]==e)
return i+1;//加1就是元素在顺序表中的位置
return 0;//退出循环,证明查找失败
}
/*按位查找:GetElem(L,i) 获取表中第i个位置的元素的值
return L.data[i-1];*/
//打印顺序表元素
void PrintList(SqList &L)
{
for(int i=0;i<L.length;i++)
{
printf("%4d",L.data[i]);
}
printf("\n");
}
int main()
{
SqList L;//顺序表的名称
bool ret;//查看返回值,布尔型是True,或者False
ElemType del;//要删除的元素
//首先手动在顺序表中赋值
L.data[0]=1;
L.data[1]=2;
L.data[2]=3;
L.length=3;//总计三个元素
ret=ListInsert(L,2,60);
if(ret)
{
printf("插入成功\n");
PrintList(L);
}else{
printf("插入失败\n");
}
ret=ListDelete(L,1,del);
if(ret)
{
printf("删除成功\n");
printf("删除元素值为 %d\n",del);
PrintList(L);
}else{
printf("删除失败\n");
}
ret=LocateElem(L,60);
if(ret)
{
printf("查找成功\n");
printf("元素位置为 %d\n",ret);
}else{
printf("查找失败\n");
}
system("pause");//停在控制台窗口
}
2.线性表的链式表示
强调这是一个单链表——使用LinkList
强调这是一个结点———使用LNode *
为什么我们需要在形参的地方使用引用?
在子函数中去给对应的形参赋值后,子函数结束,主函数中对应的实参就发生了变化
如果没有使用引用,那么在子函数中给形参赋值后,子函数结束,主函数中对应的实参不会变化的
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
typedef int ElemType;
typedef struct LNode {
ElemType data;
struct LNode* next;//指向下一个结点
}LNode, * LinkList;
//头插法新建链表:读入数据的顺序与生成链表中的元素的顺序是相反的
LinkList CreatList1(LinkList& L)//list_head_insert
{
LNode* s; int x;
L = (LinkList)malloc(sizeof(LNode));//创建头结点,带头结点的链表
L->next = NULL;//L->data里边没放东西,初始为空链表
scanf("%d", &x);//从标准输入读取数据
//3 4 5 6 7 9999
while (x != 9999) {
//输入9999表示结束
s = (LNode*)malloc(sizeof(LNode));//创建新结点,申请一个新空间给s,强制类型转换
s->data = x;//把读取到的值,给新空间中的data成员
s->next = L->next;//让新结点的next指针指向链表的第一个元素(第一个放我们数据的元素)
L->next = s;//让s作为第一个元素
scanf("%d", &x);//读取标准输入
}
return L;
}
//尾插法新建链表:读入数据的顺序与生成链表中的元素的顺序是一致的
LinkList CreatList2(LinkList& L)//list_tail_insert
{
int x;
L = (LinkList)malloc(sizeof(LNode));//带头节点的链表
LNode* s, * r = L;//LinkList s,r=L;也可以,r代表链表表尾结点,指向链表尾部
//3 4 5 6 7 9999
scanf("%d", &x);
while (x != 9999) {
s = (LNode*)malloc(sizeof(LNode));
s->data = x;
r->next = s;//让尾部结点指向新结点
r = s;//r指向新的表尾结点
scanf("%d", &x);
}
r->next = NULL;//尾结点的next指针赋值为NULL
return L;
}
/*习惯:只要是初始化单链表,都先把头指针指向NULL:L->next=NULL; */
//打印链表
void PrintList(LinkList L)
{
L = L->next;
while (L != NULL)//NULL是为了代表一张空的藏宝图
{
printf("%3d", L->data);//打印当前结点数据
L = L->next;//指向下一个结点
}
printf("\n");
}
//查找第几个结点的值
LNode *GetElem(LinkList L, int i)
{
int j = 1;
LNode *p = L->next;//让p指向第一个结点(头结点指针赋给p)
if (0 == i)
{
return L;//i是零就返回头结点
}
if (i < 1)
{
return NULL;//i是负值就返回空
}
while (p && j < i)
{
p = p->next;//让p指向下一个结点
j++;
}
return p;//返回第i个结点的指针,若i大于表长,则返回NULL
}
//按值查找
LNode *LocateElem(LinkList L, ElemType e)
{
LNode *p = L->next;
while (p != NULL && p->data != e)
{
p = p->next;
}
return p;//找到后返回该结点指针,否则返回NULL
}
//往第i个位置插入元素:先找前驱,再插入
bool ListFrontInsert(LinkList L, int i, ElemType e)
{
LinkList p = GetElem(L,i - 1);//拿到要插入位置的前一个位置的地址值
if (NULL == p)
{
return false;//i不对
}
LinkList s = (LinkList)malloc(sizeof(LNode));//给新结点申请空间
s->data = e;//要插入的值放入对应空间
s->next = p->next;//插入步骤
p->next = s;
return true;
}
//删除第i个位置的元素
bool ListDelete(LinkList L, int i)
{
LinkList p = GetElem(L, i - 1);//查找删除位置的前驱节点
if (NULL == p)
{
return false;//要删除的位置不存在
}
LinkList q = p->next;//令q指向被删除结点
if (NULL == q)
{
return false;//要删除的位置不存在
}
p->next = q->next;//断链
free(q);//释放对应结点的空间
q = NULL;//为了避免野指针
return true;
}
//2.3 线性表的链式表示
int main()
{
LinkList L;//链表头,是结构体指针类型
LinkList search;//用来存储拿到的某一个节点
//CreatList1(L);//输入数据可以为3 4 5 6 7 9999,头插法新建链表
CreatList2(L);//输入数据可以为3 4 5 6 7 9999
PrintList(L);//链表打印
search=GetElem(L,2);//查找链表第二个位置的元素值
if(search!=NULL)
{
printf("按序号查找成功\n");
printf("%d\n",search->data);
}
search=LocateElem(L,6);//按值查询
if(search!=NULL)
{
printf("按值查找成功\n");
printf("%d\n",search->data);
}
ListFrontInsert(L,2,99);//新结点插入第i个位置
PrintList(L);//链表打印
ListDelete(L,4);//删除第4个结点
PrintList(L);
return 0;
}
3.双向链表
#include <stdio.h>
#include <stdlib.h>
typedef int ElemType;
typedef struct DNode{
ElemType data;
struct DNode *prior,*next;//前驱,后继
}DNode,*DLinkList;
//双向链表头插法
DLinkList Dlist_head_insert(DLinkList &DL)
{
DNode *s;int x;
DL=(DLinkList)malloc(sizeof(DNode));//带头结点的链表,DL就是头结点
DL->next=NULL;//前驱指针和后继指针都填写为NULL
DL->prior=NULL;
scanf("%d",&x);//从标准输入读取数据
//3 4 5 6 7 9999
while(x!=9999){
s=(DLinkList)malloc(sizeof(DNode));//申请一个空间空间,强制类型转换
s->data=x;
s->next=DL->next;
if(DL->next!=NULL)//插入第一个结点时,不需要这一步操作
{
DL->next->prior=s;
}
s->prior=DL;//要插入的结点指向头结点
DL->next=s;
scanf("%d",&x);//读取标准输入
}
return DL;
}
//双向链表尾插法
DLinkList Dlist_tail_insert(DLinkList &DL)
{
int x;
DL=(DLinkList)malloc(sizeof(DNode));//带头节点的链表
DNode *s,*r=DL;//r代表尾指针
DL->prior=NULL;
//3 4 5 6 7 9999
scanf("%d",&x);
while(x!=9999){
s=(DNode*)malloc(sizeof(DNode));
s->data=x;
r->next=s;
s->prior=r;
r=s;//r指向新的表尾结点
scanf("%d",&x);
}
r->next=NULL;//尾结点的next指针赋值为NULL
return DL;
}
//按序号查找结点值
DNode *GetElem(DLinkList DL,int i)
{
int j=1;
DNode *p=DL->next;
if(i==0)
return DL;
if(i<1)
return NULL;
while(p&&j<i)
{
p=p->next;
j++;
}
return p;
}
//新结点插入第i个位置
bool DListFrontInsert(DLinkList DL,int i,ElemType e)
{
DLinkList p=GetElem(DL,i-1);//找前一个位置的地址
if(NULL==p)
{
return false;
}
DLinkList s=(DLinkList)malloc(sizeof(DNode));//为新插入的结点申请空间
s->data=e;
s->next=p->next;
p->next->prior=s;
s->prior=p;
p->next=s;
return true;
}
//删除第i个结点
bool DListDelete(DLinkList DL,int i)
{
DLinkList p=GetElem(DL,i-1);
if(NULL==p)
{
return false;
}
DLinkList q;
q=p->next;
if(q==NULL)//删除的元素不存在
return false;
p->next=q->next;//断链
if(q->next!=NULL)//q->next为NULL删除的是最后一个结点
{
q->next->prior=p;
}
free(q);//释放对应结点的空间
return true;
}
//链表打印
void PrintDList(DLinkList DL)
{
DL=DL->next;
while(DL!=NULL)
{
printf("%3d",DL->data);
DL=DL->next;
}
printf("\n");
}
//2.3.3 双链表增删查
int main()
{
DLinkList DL;
DLinkList search;
//Dlist_head_insert(DL);//头部插入
Dlist_tail_insert(DL);//尾部插入
//3 4 5 6 7 9999
PrintDList(DL);
search=GetElem(DL,2);
if(search!=NULL)
{
printf("按序号查找成功\n");
printf("%d\n",search->data);
}
DListFrontInsert(DL,3,99);
PrintDList(DL);
DListDelete(DL,2);
PrintDList(DL);
return 0;
}
三、栈和队列
栈
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 50
typedef int ElemType;
typedef struct{
ElemType data[MaxSize];//数组,存放栈中元素
int top;//栈顶指针
}SqStack;
//初始化栈
void InitStack(SqStack &S)
{
S.top=-1;//代表栈为空
}
//判断栈是否为空
bool StackEmpty(SqStack S)
{
if(S.top==-1)
return true;
else
return false;
}
//入栈
bool Push(SqStack &S,ElemType x)
{
if(S.top==MaxSize-1)//数组的大小不能改变,避免访问越界
{
return false;//栈满,报错
}
S.data[++S.top]=x;//指针先加1,再入栈
return true;
}
//出栈
bool Pop(SqStack &S,ElemType &x)
{
if(-1==S.top)
return false;
x=S.data[S.top--];//后减减,x=S.data[S.top];S.top=S.top-1;
return true;
}
//读取栈顶元素
bool GetTop(SqStack S,ElemType &x)
{
if(-1==S.top)//说明栈为空
return false;
/*另一种写法:
if(StackEmpty(S))//说明栈为空
{
return false;
}
*/
x=S.data[S.top];
return true;
}
//实现栈 可以用数组,也可以用链表,我们这里使用数组
int main()
{
SqStack S;//先进后出 FILO LIFO
bool flag;
ElemType m;//用来存放拿出的栈顶元素
InitStack(S);//初始化
flag=StackEmpty(S);
if(flag)
{
printf("栈是空的\n");
}
Push(S,3);//入栈元素3
Push(S,4);//入栈元素4
Push(S,5);
flag=GetTop(S,m);//获取栈顶元素,不删除栈顶元素,S.top值不变
if(flag)
{
printf("获取栈顶元素为 %d\n",m);
}
flag=Pop(S,m);//弹出栈顶元素,删除栈顶元素
if(flag)