数据结构线性表，栈，队列的基本操作
数据结构线性表，栈，队列的基本操作
- 顺序表的基本操作
-
- 定义顺序表
- 初始化
- 打印顺序表
- 获取顺序表长度
- 创建一个顺序表，每个元素随机赋值
- 在指定位置处插入一个新的元素
- 获取顺序表中指定位置处的元素值
- 查找在线性表中是否含有指定元素
- 删除顺序表中指定位置处的元素
- 清空一个顺序表，将顺序表的length置为0；
- 说明
- 单链表的基本操作
-
- 定义单链表
- 初始化
- 创建一个单链表
- 获取链表的长度
- 打印整个链表
- 获取指定位置处的节点元素
- 插入节点
- 追加节点
- 删除节点
- 删除整个链表
- 顺序栈的基本操作
-
- 定义
- 初始化
- 入栈
- 判断栈是否为空
- 求栈长
- 获取栈顶元素
- 销毁队栈
- 清空栈
- 出栈
- 遍历栈
- 测试
- 链栈的基本操作
-
- 定义
- 初始化
- 销毁链栈
- 判断链栈是否为空
- 进栈
- 出栈
- 得到栈顶元素
- 输出链栈元素
- 顺序队列的基本操作
-
- 定义
- 初始化
- 入队
- 判断队列是否为空
- 求队长
- 获取队头元素
- 销毁队列
- 清空队列
- 出队
- 遍历队列
- 测试
- 链队列的基本操作
-
- 定义
- 初始化
- 入队
- 创建一个长度由自己决定的队列并初始化
- 销毁队列
- 遍历队列
- 求队列长度
- 出队
- 判断队列是否为空
- 菜单
- 测试
顺序表的基本操作
定义顺序表
typedef int ElemType;
typedef struct{ // 线性表中共有length个元素，是data[0]——data[length-1]
int data[MAXSIZE];
int length;
}SqList;
初始化
int initList(SqList *L)
{
L->length=0;
return 1;
}
打印顺序表
int printList(SqList L)
{
if(L.length==0)
{ printf(“链表为空\n”);
return 0;
}
int i;
for(i=0;i
}
printf("\n");
return 1;
}
获取顺序表长度
int getlength(SqList L){
return L.length;
}
创建一个顺序表，每个元素随机赋值
int createList(SqList *L,int length){
srand(time(0));
int i;
for(i=0;i
L->length++;
}
return 1;
}
在指定位置处插入一个新的元素
int insertList(SqList *L, int pos,ElemType elem){
int i;
if(pos<1 || pos>L->length)
{
printf(“插入的位置有误，无法插入数据\n”);
return 0;
}
for (i=L->length-1;i>=pos-1;i–)
{
L->data[i+1]=L->data[i];
}
L->data[pos-1] = elem;
L->length++;
return 1;
}
获取顺序表中指定位置处的元素值
int getElem(SqList L, int pos, ElemType *e){
if(pos<1 || pos>L.length)
{
printf(“查找位置有错误，无法获取指定位置的数据\n”);
*e=99999999;
return 0;
}
*e = L.data[pos-1];
return 1;
}
查找在线性表中是否含有指定元素
int locateElem(SqList L, ElemType e){
int i;
for(i=0;i
//printf(“在%d层循环…\n”,i);
if(L.data[i] == e)
{
printf(“在pos[%d]位置处，查找到了元素elem:%d\n”,i+1,e);
return 1;
}
}
return 0;
}
删除顺序表中指定位置处的元素
int deleteList(SqList *L, int pos,ElemType *elem){
int i;
if(pos<1 || pos>L->length)
{
printf(“删除的位置有误，无法从该位置删除数据\n”);
*elem=99999999;
return 0;
}
*elem = L->data[pos-1];
for(i=pos;ilength;i++){
L->data[i-1]=L->data[i];
}
L->length --;
return 1;
}
清空一个顺序表，将顺序表的length置为0；
int clearList(SqList L,SqList *pL){
printf(“In clearList function: %d\n”,&L);
printf(“In clearList function: %d\n”,pL);
L.length=0;
pL->length=0;
return 1;
}
说明
1、在上面顺序表操作函数中，有的入参是SqList类型的，有的是SqList*类型的，两者是有区别的，通过clearList()函数进行说明；
2、入参有两种类型，这是为了测试在函数内部，处理的顺序表在内存中的位置是什么，在函数内部，会把顺序表的位置以%d的方式打印出来；同时在调用函数之前，会把传入的入参顺序表L的地址打印出来；
通过测试发现，如果入参为SqList L，在函数内部地址同外部的顺序表L地址不相同，如果入参为SqList *pL，在函数内部地址同外部的顺序表L地址相同；当入参为SqList L时，执行L.length=0；无效，根本没有将顺序表的唱的长度置为0；
3、综上所述，如果要修改顺序表中的值（包括长度，以及各个元素的值），比如创建顺序表、插入元素、删除元素等等操作，是对顺序表内的数据有改动的，就要传入SqList *类型的入参，否则达不到修改的目的；【这其实就是函数的值传递和地址传递】
单链表的基本操作
定义单链表
typedef int ElemType;
typedef struct Node {
ElemType data;
struct Node * next;
}Node;
typedef struct Node* linkList;
初始化
int initList(linkList *L)
{
(*L) = (linkList)malloc(sizeof(Node));
(*L)->next = NULL;
printf(“链表初始化成功\n”);
return 1;
}
创建一个单链表
int createListHead(linkList *L,int n) {
linkList p;
int i = 0;
srand((int)time(0));
for (i = 0; i < n; i++)
{
p= (linkList)malloc(sizeof(Node));
p->data = rand() % 100;
printf(“testing:Node[%d]=%d\n”,i+1,p->data);
p->next = (*L)->next;
(*L)->next = p;
}
printf(“链表（头插法）创建成功\n”);
return 1;
}
int createListTail(linkList *L, int n) {
linkList p, temp;
temp = (*L);
int i;
srand((int)time(0));
for (i = 0; i < n;i++) {
p = (linkList)malloc(sizeof(Node));
p->data = rand() % 100;
printf(“testing:Node[%d]=%d\n”, i + 1, p->data);
p->next = NULL;
temp->next = p;
temp = p;
}
printf(“链表（尾插法）创建成功\n”);
return 1;
}
获取链表的长度
int getlength(linkList *L) {
linkList p;
int length=0;
p = (*L)->next;//p指向第一个节点；
while § {
length++;
p = p->next;
}
return length;
}
打印整个链表
int printList(linkList *L) {
linkList p;
int i = 0;
p = (*L)->next;//p指向第一个节点；
printf("-----------打印整个链表-----------\n");
if (p==NULL) {
printf(“这是一个空链表.\n”);
}
while § {
i++;
printf(“第%d个节点的数据data为=%d\n”,i,p->data);
p = p->next;
}
return 1;
}
获取指定位置处的节点元素
int getElem(linkList *L, int i, ElemType *getdata) {
linkList p;
p = (*L)->next;
if (p == NULL)
{
printf(“链表为空，请创建一个链表\n”);
*getdata = -1;
return 0;
}
if (i < 1)
{
printf(“您所查询的节点%d，应该大于0，请重新输入查询\n”,i);
*getdata = -1;
return 0;
}
int j = 1;
while (p&&j
p = p->next;
}
if (p == NULL)
{
printf(“您所查询的节点%d，已经超出了数组的长度\n”,i);
*getdata = -1;
return 0;
}
*getdata = p->data;
printf(“查询成功！\n”, i);
return 1;
}
插入节点
int insertList(linkList *L, int i, ElemType data)
{
linkList p;
linkList insNode;
p = (*L);
int j=0;
// 链表为空，在第1个位置插入一个新的节点；
if (p ->next == NULL) {
printf(“链表为空，默认在第一个位置插入一个节点.\n”);
insNode = (linkList)malloc(sizeof(Node));
insNode->data = data;
insNode->next = p->next;
p->next = insNode;
printf(“节点插入成功.\n”);
return 1;
}
// 链表非空的情况下，可以在i=1~length的位置插入节点，如果超过了链表的长度，就会提示错误；
// 其实如果在length+1的位置处插入一个新节点，就相当于在尾部追加一个节点，在本函数中会报错，可以单独实现一个函数；
while(p && j
j++;
p = p->next;
//printf(“j=%d\tp->data=%d\n”, j, p->data);
}
if (p->next==NULL) {
printf(“您要插入的位置，超过了链表的长度 %d，请重新操作！\n”,j);
return 0;
}
insNode = (linkList)malloc(sizeof(Node));
insNode->data = data;
insNode->next = p->next;
p->next = insNode;
printf(“节点插入成功\n”);
return 1;
}
追加节点
int insertListTail(linkList *L, ElemType data)
{
linkList temp;
linkList p=(*L);
while§ {
temp = p;
p = p->next;
}
p = (linkList)malloc(sizeof(Node));
p->data = data;
p->next = NULL;
temp->next = p;
printf(“节点插入成功\n”);
return 1;
}
删除节点
int deleteList(linkList *L, int i, ElemType *data)
{
linkList p,pnext;
int j = 0;
p = (*L);
if (p->next == NULL) {
printf(“链表为空，无法删除指定节点.\n”);
*data = -1;
return 0;
}
while (p->next && j
p = p->next;
//printf(“j=%d\t p->data=%d\n”,j,p->data);
}//条件最多定位到最后一个节点；
if ( p->next == NULL) {
printf(“您要删除的节点，超过了链表的长度 %d，请重新操作！\n”, j);
*data = -1;
return 0;
}
pnext = p->next;
p->next = pnext->next;
*data = pnext->data;
free(pnext);
printf(“节点删除成功\n”);
return 1;
}
删除整个链表
int clearList(linkList *L) {
linkList p, temp;
p = (*L)->next;//p指向第一个节点
while § {
temp = p;
p = p->next;
free(temp);
}
(*L)->next = NULL;
printf(“整个链表已经clear.\n”);
return 1;
}
顺序栈的基本操作
定义
#include
#include
#include
#define ERROR 0
#define OK 1
#define TRUE 1
#define FALSE 0
#define QUEUESIZE 10 //栈长度10
typedef int Status;
typedef int QElemtype;
typedef struct QNode{
QElemtype *base;
int top;
}SqQueue;
初始化
void InitQueue(SqQueue Q)
{
Q->base=(QElemtype)malloc(sizeof(QElemtype)*QUEUESIZE);
assert(Q->base!=NULL);
Q->top=0;
}
入栈
Status EnQueue(SqQueue *Q,QElemtype e)
{
if(Q->top==QUEUESIZE)
{
return ERROR;
}
Q->base[Q->top]=e;
Q->top++;
return OK;
}
判断栈是否为空
Status QueueEmpty(SqQueue *Q)
{
if(Q->top==0)
{
return TRUE;
}
return FALSE;
}
求栈长
Status QueueLength(SqQueue Q)
{
return Q.top;
}
获取栈顶元素
Status GetHead(SqQueue *Q,QElemtype *e)
{
if(Q->top==0)
{
return ERROR;
}
*e=Q->base[Q->top];
return OK;
}
销毁队栈
void DestoryQueue(SqQueue *Q)
{
if(Q->base) //栈Q存在
{
free(Q->base);
}
Q->base=NULL;
Q->top=0;
}
清空栈
void ClearQueue(SqQueue *Q)
{
Q->top=0;
}
出栈
Status DeQueue(SqQueue *Q,QElemtype *e)
{
if(Q->top==0)
{
return ERROR;
}
*e=Q->base[Q->top-1];
Q->top–;
return OK;
}
遍历栈
void QueueTraverse(SqQueue Q)
{
int i=0;
while(i!=Q.top)
{
printf("%d\t",Q.base[i]);
i++;
}
printf("\n");
}
测试
int main()
{
QElemtype i,e,d;
SqQueue Q;
InitQueue(&Q);
printf(“请输入栈列的%d个元素：\n”,QUEUESIZE);
for(i=0;i
scanf("%d",&d);
EnQueue(&Q,d);
}
printf(“栈的元素为:”);
QueueTraverse(Q);
printf(“栈长度为：%d\n”,QueueLength(Q));
int k=QueueLength(Q);
printf(“连续%d次出栈入栈:\n”,k/2);
for(i=0;i
DeQueue(&Q,&e);
printf(“出栈的元素是：%d,请输入入栈的元素：”,e);
scanf("%d",&d);
EnQueue(&Q,d);
}
printf(“新的栈元素为：\n”);
QueueTraverse(Q);
int n=GetHead(&Q,&e);
if(n)printf(“栈顶元素为：%d\n”,e);
else {
printf(“栈空!\n”); return -1;
}
ClearQueue(&Q);
DestoryQueue(&Q);
return 0;
}
链栈的基本操作
定义
typedef int ElemType;
typedef struct linknode
{
ElemType data;
struct linknode *next;
}LiStack;
初始化
void InitStack(LiStack* S)
{
S=(LiStack*)malloc(sizeof(LiStack));
S->next=NULL;
}
销毁链栈
void DestroyStack(LiStack* s)
{
LiStack *p=s->next,*q=s;
while(p!=NULL)
{
free(q);
q=p;
p=p->next;
}
free§;
}
判断链栈是否为空
int StackEmpty(LiStack* s)
{
if(s->next==NULL)
return 0;
else
return 1;
}
进栈
void Push(LiStack* s,ElemType e)
{
LiStack p;
p=(LiStack)malloc(sizeof(LiStack));
p->data=e;
p->next=s->next;
s->next=p;
}
出栈
int Pop(LiStack* s,ElemType e)
{
LiStack *p=s->next;
if(s->next!=NULL)
return 0;
else
{
e=p->data;
s->next=p->next;
free§;
return 1;
}
}
得到栈顶元素
int GetTop(LiStack* s,ElemType e)
{
LiStack *p=s->next;
if(s->next==NULL)
return 0;
e=p->data;
return 1;
}
输出链栈元素
void PrintStack(LiStack* s)
{
LiStack *p=s->next;
while(p!=NULL)
{
printf("%d ",p->data);
p=p->next;
}
}
顺序队列的基本操作
定义
#include
#include
#include
#define ERROR 0
#define OK 1
#define TRUE 1
#define FALSE 0
#define QUEUESIZE 10 //队列长度10,9元素为满
typedef int Status;
typedef int QElemtype;
typedef struct QNode{
QElemtype *base;
int front;
int rear;
}SqQueue;
初始化
void InitQueue(SqQueue Q)
{
Q->base=(QElemtype)malloc(sizeof(QElemtype)*QUEUESIZE);
assert(Q->base!=NULL);
Q->front=0;
Q->rear=0;
}
入队
Status EnQueue(SqQueue *Q,QElemtype e)
{
if((Q->rear+1)%QUEUESIZE==Q->front)
{
return ERROR;
}
Q->base[Q->rear]=e;
Q->rear=(Q->rear+1)%QUEUESIZE;
return OK;
}
判断队列是否为空
Status QueueEmpty(SqQueue *Q)
{
if(Q->front==Q->rear)
{
return TRUE;
}
return FALSE;
}
求队长
Status QueueLength(SqQueue Q)
{
return (Q.rear-Q.front)%10;
}
获取队头元素
Status GetHead(SqQueue *Q,QElemtype *e)
{
if(Q->front==Q->rear)
{
return ERROR;
}
*e=Q->base[Q->front];
return OK;
}
销毁队列
void DestoryQueue(SqQueue *Q)
{
if(Q->base) //队列Q存在
{
free(Q->base);
}
Q->base=NULL;
Q->front=Q->rear=0;
}
清空队列
void ClearQueue(SqQueue *Q)
{
Q->front=Q->rear=0;
}
出队
Status DeQueue(SqQueue *Q,QElemtype *e)
{
if(Q->front==Q->rear)
{
return ERROR;
}
*e=Q->base[Q->front];
Q->front=(Q->front+1)%QUEUESIZE;
return OK;
}
遍历队列
void QueueTraverse(SqQueue Q)
{
int i=Q.front;
while(i!=Q.rear)
{
printf("%d\t",Q.base[i]);
i=(i+1)%QUEUESIZE;
}
printf("\n");
}
测试
int main()
{
QElemtype i,e,d;
SqQueue Q;
InitQueue(&Q);
printf(“请输入队列的%d个元素：\n”,QUEUESIZE-1);
for(i=0;i
scanf("%d",&d);
EnQueue(&Q,d);
}
printf(“队列的元素为:”);
QueueTraverse(Q);
printf(“队列长度为：%d\n”,QueueLength(Q));
int k=QueueLength(Q);
printf(“连续%d次由对头删除元素，队尾插入元素:\n”,k/2);
for(i=0;i
DeQueue(&Q,&e);
printf(“删除的队列的元素是：%d,请输入插入的元素：”,e);
scanf("%d",&d);
EnQueue(&Q,d);
}
printf(“新的队列元素为：\n”);
QueueTraverse(Q);
int n=GetHead(&Q,&e);
if(n)printf(“队头元素为：%d\n”,e);
else {
printf(“队空!\n”); return -1;
}
ClearQueue(&Q);
printf(“清空队列后队列是否为空：%d\t(1:为空 ,0:不为空)\n”,QueueEmpty(&Q));
DestoryQueue(&Q);
printf(“销毁队列后:\nQ.base=%u\tQ.front=%d\tQ.rear=%d\t\n”,Q.base,Q.front,Q.rear);
return 0;
}
链队列的基本操作
定义
#include
#include
#include
#define OK 1
int yes=0;
typedef struct node
{
char data;
struct node *next;
}node,*queueptr;
typedef struct
{
queueptr front;
queueptr rear;
}linkqueue;
初始化
void initqueue(linkqueue q)
{
q->front=q->rear=(node)malloc(sizeof(node));
if(!(q->front))
exit(1);
q->front->next=NULL;
}
入队
void enqueue(linkqueue *q,char e)
{
queueptr p;
p=(queueptr)malloc(sizeof(node));
if(!p)exit(1);
p->data=e;
p->next=0;
q->rear->next=p;
q->rear=p;
}
创建一个长度由自己决定的队列并初始化
void creatqueue(linkqueue *q)
{
int i,length;
int num;
queueptr p;
printf(“请输入队列长度:\n”);
scanf("%d",&length);
printf(“请输入队列的元素:\n”);
for(i=0;i
p=(queueptr)malloc(sizeof(node));
if(!p)
exit(1);
scanf("%d",&num);
p->data=num;
p->next=0;
q->rear->next=p;
q->rear=p;
}
yes=1;
}
销毁队列
void destroyqueue(linkqueue *q)
{
if(!q)
{
printf(“链队列已经是空队列!\n”);
exit(1);
}
while(q->front)
{
q->rear=q->front->next;
free((q->front));
q->front=q->rear;
if(!q->rear)
free(q->rear);
}
free(q->front);
}
遍历队列
void disqueue(linkqueue *q)
{
node *r=q->front->next;
printf("此时的链队列输出:\n");
while(r)
{
printf("%d ",r->data);
r=r->next;
}
printf("\n");
}
求队列长度
void lenqueue(linkqueue *q)
{
node *r=q->front->next;
int s=0;
printf("此时的链队列长度为:\n");
while(r)
{
r=r->next;
s++;
}
printf("%d\n",s);
}
出队
char dequeue(linkqueue *q,int e)
{
node *p;
if(q->front==q->rear)
return -1;
p=q->front->next;
e=p->data;
q->front->next=p->next;
if(q->rear==p)
q->rear=q->front;
free(p);
return e;
}
判断队列是否为空
int queueempty(linkqueue *q)
{
if(q->front==q->rear)
return 1;
else
return 0;
}
菜单
void menu()
{
printf(" 链队列试验统一界面 \n");
printf("********************************************\n");
printf("1 建立链队列! *\n");
printf("2 链队列入队操作! *\n");
printf("3 链队列出队操作! *\n");
printf("4 求链队列长度! *\n");
printf("5 判断链队列是否为空! *\n");
printf("6 输出链队列! *\n");
printf("7 销毁链队列! *\n");
printf("0 退出! *\n");
printf("********************************************\n");
}
测试
int main(void)
{
linkqueue ptr;
int sel;
int num;
initqueue(&ptr);
while(1)
{
menu();
printf(“please input command:\n”);
scanf("%d",&sel);
switch(sel)
{
case 1:if(yes1)
{
printf(“此时表已创建!不能再次创建!\n”);
break;
}
else
creatqueue(&ptr);break;
case 2:if(yes0)
{
printf(“此时表未创建!不能入队!\n”);
break;
}
else
{
printf(“请输入队的元素值:”);
scanf("%d",&num);
enqueue(&ptr,num);
break;
}
case 3:if(yes0)
{
printf(“此时表为创建!不能出队!\n”);
break;
}
else
{
num=dequeue(&ptr,num);
printf(“目前出队的元素是%d”,num);
break;
}
case 4:if(yes0)
{
printf(“此时链队列未创建!不能求其长度!\n”);
break;
}
lenqueue(&ptr);
break;
case 5:if(yes0)
{
printf(“此时表未创建!不能判断是否为空!\n”);
break;
}
else
{
if(queueempty(&ptr))
printf(“此时队列为空队列!\n”);
else
printf(“此时队列为非空队列!\n”);
break;
}
case 6:if(yes0)
{
printf(“此时链队列未创建!不能输出!\n”);
break;
}
disqueue(&ptr);
break;
case 7:if(yes==0)
{
printf(“此时链队列未创建!不能销毁!\n”);
break;
}
destroyqueue(&ptr);
printf(“销毁成功\n”);
break;
case 0:exit(1);break;
default:printf(“输入命令错误!请重新输入:\n”);
break;
}
}
return OK;
}