数据结构上机实验
Posted wangzheming35
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了数据结构上机实验相关的知识，希望对你有一定的参考价值。
1、顺序表的各种基本运算操作
#include <stdio.h>
#include<stdlib.h>
#define MaxSize 50
typedef char ElemType;
typedef struct
{
ElemType elem[MaxSize];
int length;
} SqList;
//初始化 O(1)
void InitList(SqList *&L)
{
L=(SqList *)malloc(sizeof(SqList));
L->length=0;
}
//销毁 O(1)
void DestroyList(SqList *L)
{
free(L);
}
//判断是否为空 O(1)
int ListEmpty(SqList *L)
{
return(L->length==0);
}
//求长度 O(1)
int ListLength(SqList *L)
{
return(L->length);
}
//输出顺序表 O(n)
void DispList(SqList *L)
{
int i;
if (ListEmpty(L)) return;
for (i=0;i<L->length;i++)
printf("%c",L->elem[i]);
printf("
");
}
//获取第i个位置上的元素返回给e O(1)
int GetElem(SqList *L,int i,ElemType &e)
{
if (i<1 || i>L->length)
return 0;
e=L->elem[i-1];
return e;
}
//查找返回元素e的位置 O(n)
int LocateElem(SqList *L, ElemType e)
{
int i=0;
while (i<L->length && L->elem[i]!=e) i++;
if (i>=L->length)
return 0;
else
return i+1;
}
//把元素e插入到位置i O(n)
bool ListInsert(SqList *&L,int i,ElemType e)
{
int j;
if (i<1 || i>L->length+1)
return false;
i--; //将顺序表位序转化为elem下标
for (j=L->length;j>i;j--) //将elem[i]及后面元素后移一个位置
L->elem[j]=L->elem[j-1];
L->elem[i]=e;
L->length++;
return true;
}
//删除位置i上的元素 O(n)
bool ListDelete(SqList *&L,int i,ElemType &e)
{
int j;
if (i<1 || i>L->length)
return false;
i--; //将顺序表位序转化为elem下标
e=L->elem[i];
for (j=i;j<L->length-1;j++) //将elem[i]及后面元素前移一个位置
L->elem[j]=L->elem[j+1];
L->length--;
return true;
}
int main()
{
SqList *L;
ElemType e;
printf("(1)初始化顺序表L
");
InitList(L);
printf("(2)依次采用尾插法插入a,b,c,d,e元素
");
ListInsert(L,1,‘a‘);
ListInsert(L,2,‘b‘);
ListInsert(L,3,‘c‘);
ListInsert(L,4,‘d‘);
ListInsert(L,5,‘e‘);
printf("(3)输出顺序表L:");
DispList(L);
printf("(4)顺序表L长度=%d
",ListLength(L));
printf("(5)顺序表L为%s
",(ListEmpty(L)?"空":"非空"));
GetElem(L,4,e);
printf("(6)顺序表L的第4个元素=%c
",e);
printf("(7)元素a的位置=%d
",LocateElem(L,‘a‘));
printf("(8)在第3个元素位置上插入f元素
");
ListInsert(L,3,‘f‘);
printf("(9)输出顺序表L:");
DispList(L);
printf("(10)删除L的第4个元素
");
ListDelete(L,4,e);
printf("(11)输出顺序表L:");
DispList(L);
printf("(12)释放顺序表L
");
DestroyList(L);
}
2、单链表的各种基本运算算法
#include<stdio.h>
#include<stdlib.h>
typedef char ElemType;
typedef struct LNode
{
ElemType data;
struct LNode *next;
} LinkList;
//两种插入学习
//使用头插法
void CreateListF(LinkList *&L,ElemType a[],int n)
{
LinkList *s;
int i;
L=(LinkList *)malloc(sizeof(LinkList));
L->next=NULL;
for(i=0; i<n; i++)
{
s=(LinkList *)malloc(sizeof(LinkList));
s->data=a[i];
s->next=L->next;
L->next=s;
}
}
//使用尾插法
void CreateListR(LinkList *&L,ElemType a[],int n)
{
LinkList *s,*r;
int i;
L=(LinkList *)malloc(sizeof(LinkList));
r=L;
for(i=0; i<n; i++)
{
s=(LinkList *)malloc(sizeof(LinkList));
s->data=a[i];
r->next=s;
r=s;
}
r->next=NULL;
}
//初始化线性表 O(1)
void InitList(LinkList *&L)
{
L=(LinkList *)malloc(sizeof(LinkList));
L->next=NULL;
}
//销毁线性表 O(n)
void DestroyList(LinkList *&L)
{
LinkList *pre=L,*p=L->next;
while(p!=NULL)
{
free(pre);
pre=p;
p=pre->next;
}
free(pre);
}
//判断线性表是否为空表 O(1)
bool ListEmpty(LinkList *L)
{
return (L->next==NULL);
}
//求线性表的长度 O(n)
int ListLength(LinkList *L)
{
int n=0;
LinkList *p=L;
while(p->next!=NULL)
{
n++;
p=p->next;
}
return (n);
}
//输出线性表 O(n)
void DispList(LinkList *L)
{
LinkList *p=L->next;
while(p!=NULL)
{
printf("%c",p->data);
p=p->next;
}
printf("
");
}
//求线性表中某个数据元素值 O(n)
int GetElem(LinkList *L,int i,ElemType &e)
{
int j=0;
LinkList *p=L;
while(j<i&&p!=NULL) //题目中i默认大于0
{
j++;
p=p->next;
}
if(p==NULL)
return 0;
else
{
e=p->data;
return e;
}
}
//按元素值查找 O(n)
int LocateElem(LinkList *L,ElemType e)
{
int i=1;
LinkList *p=L->next;
while(p!=NULL&&p->data!=e)
{
p=p->next;
i++;
}
if(p==NULL)
return 0;
else
return i;
}
//插入数据元素 O(n)
bool ListInsert(LinkList *&L,int i,ElemType e)
{
int j=0;
LinkList *p=L,*s;
while(j<i-1&&p!=NULL)
{
j++;
p=p->next;
}
if(p==NULL)
return false;
else
{
s=(LinkList *)malloc(sizeof(LinkList));
s->data=e;
s->next=p->next;
p->next=s;
return true;
}
}
//删除数据元素 O(n)
bool ListDelete(LinkList *&L,int i,ElemType &e)
{
int j=0;
LinkList *p=L,*q;
while(j<i-1&&p!=NULL)
{
j++;
p=p->next;
}
if(p==NULL)
return false;
else
{
q=p->next;
if(q==NULL)
return false;
e=q->data;
p->next=q->next;
free(q);
return true;
}
}
int main()
{
LinkList *L;
char s[5]= {‘a‘,‘b‘,‘c‘,‘d‘,‘e‘};
char e;
int i,j;
printf("(1)初始化单链表L
");
InitList(L);
printf("(2)采用尾插法插入a,b,c,d,e元素");
CreateListR(L,s,5);
printf("
");
printf("(3)输出单链表L:");
DispList(L);
printf("(4)单链表L长度=%d
",ListLength(L));
i=ListEmpty(L);
if(i==0)
{
printf("(5)该单链表L非空
");
}
else
{
printf("(5)该单链表L为空
");
}
e=GetElem(L,3,e);
printf("(6)第三个元素为：%c
",e);
j=LocateElem(L,‘a‘);
printf("(7)元素a为第%d个元素
",j);
printf("(8)在第4个元素位置上插入f元素
");
ListInsert(L,4,‘f‘);
printf("(9)输出单链表L:");
DispList(L);
printf("(10)删除L的第3个元素
");
ListDelete(L,3,e);
printf("(11)输出单链表L:");
DispList(L);
printf("(12)释放单链表L
");
DestroyList(L);
}
3、双链表的各种基本运算算法
#include <stdio.h>
#include <stdlib.h>
typedef char ElemType;
typedef struct DNode
{
ElemType data;
struct DNode *prior; //指向前驱结点
struct DNode *next; //指向后继结点
}DLinkNode;//声明双链表结点类型;
//尾插法建立双链表
void CreateListR(DLinkNode *&L,ElemType a[],int n)
{
DLinkNode *s,*r;
//创建头结点
L=(DLinkNode *)malloc(sizeof(DLinkNode));
L->prior=L->next=NULL;
r=L; //r始终指向终端结点,开始时指向头结点
for (int i = 0; i < n; i++)
{
//创建新结点
s=(DLinkNode *)malloc(sizeof(DLinkNode));
//数据域
s->data=a[i];
//将节点s插入到节点r之后
r->next=s;
s->prior=r;
r=s;
}
r->next=NULL; //尾结点next域置空
}
//初始化双链表
void InitList(DLinkNode *&L)
{
L=(DLinkNode *)malloc(sizeof(DLinkNode));
L->prior=L->next=NULL;
}
//销毁双链表
void DestroyList(DLinkNode *&L)
{
DLinkNode *pre=L, *p=pre->next;
while(p!=NULL)
{
free(pre);
//pre,p同步后移一个节点
pre=p;
p=pre->next;
}
free(p);
}
//判断是否为空
bool ListEmpty(DLinkNode *L)
{
return(L->next==NULL);
}
//求长度
int ListLength(DLinkNode *L)
{
DLinkNode *p=L;
int i=0; //p指向头结点 i设置为0
while(p->next!=NULL)
{
i++;
p=p->next;
}
return i;
}
//输出线性表
void DispList(DLinkNode *L)
{
DLinkNode *p=L->next;
while(p!=NULL)
{
printf("%c",p->data);
p=p->next;
}
printf("
");
}
//求线性表中第i个元素值
int GetElem(DLinkNode *L,int i,ElemType &e)
{
int j=0;
DLinkNode *p=L;
//查找第i个结点p
while(j<i&&p!=NULL)
{
j++;
p=p->next;
}
if (p==NULL)
return 0;
else //找到了
{
e=p->data;
return e;
}
}
//按元素值查找
int LocateElem(DLinkNode *L,ElemType e)
{
int i=1;
DLinkNode *p=L->next;
while(p!=NULL&&p->data!=e)
{
i++; //i对应结点p的序号
p=p->next;
}
if (p==NULL)
return 0;
else
return i;
}
//插入数据元素
bool ListInsert(DLinkNode *&L,int i,ElemType e)
{
int j=0;
DLinkNode *p=L,*s; // p指向头结点,j设置为0
while(j<i-1&&p!=NULL)
{
j++;
p=p->next;
}
if (p==NULL)
return false;
else //找到第i-1个结点p
{
//创建新结点s
s=(DLinkNode *)malloc(sizeof(DLinkNode));
s->data=e;
//将节点s插入到节点p之后
s->next=p->next;
if(p->next!=NULL)
p->next->prior=s;
s->prior=p;
p->next=s;
return true;
}
}
//删除数据元素
bool ListDelete(DLinkNode *&L,int i,ElemType &e)
{
int j=0;
DLinkNode *p=L,*q; //p指向头结点,j设置为0
while(j<i-1&&p!=NULL)
{
j++;
p=p->next;
}
if(p==NULL)
return false;
else //找到第i-1个结点p
{
q=p->next; //q指向第i个结点
//当不存在第i个结点时返回false
if(q==NULL)
return false;
e=q->data;
//从双链表中删除结点q
p->next=q->next;
//若p结点存在后继结点,修改其前驱指针
if(p->next != NULL)
p->next->prior = p;
//释放q结点
free(q);
return true;
}
}
int main()
{
DLinkNode *h;
ElemType e;
printf("(1)初始化双链表h
");
InitList(h);
printf("(2)依次采用尾插法插入a,b,c,d,e元素
");
ListInsert(h, 1, ‘a‘);
ListInsert(h, 2, ‘b‘);
ListInsert(h, 3, ‘c‘);
ListInsert(h, 4, ‘d‘);
ListInsert(h, 5, ‘e‘);
printf("(3)输出双链表h:");
DispList(h);
printf("(4)双链表h长度:%d
", ListLength(h));
printf("(5)双链表h为%s
", (ListEmpty(h) ? "空" : "非空"));
GetElem(h, 3, e);
printf("(6)双链表h的第3个元素:%c
", e);
printf("(7)元素e的位置:%d
", LocateElem(h, ‘e‘));
printf("(8)在第4个元素位置上插入f元素
");
ListInsert(h, 4, ‘f‘);
printf("(9)输出双链表h:");
DispList(h);
printf("(10)删除h的第3个元素
");
ListDelete(h, 3, e);
printf("(11)输出双链表h:");
DispList(h);
printf("(12)释放双链表h
");
DestroyList(h);
}
4、循环单链表的各种基本运算操作
#include <stdio.h>
#include <malloc.h>
//学习自CSDN作者-静能生悟，循环单链表主要看插入和删除操作的代码实现即可
typedef char ElemType;
typedef struct LNode // 定义循环单链表结点类型
{
ElemType data; // 数据域
struct LNode *next; // 指针域
}CLinkList;
//初始化
void InitList(CLinkList *&L) // 指针的引用
{
L = (CLinkList *)malloc(sizeof(CLinkList)); //创建头结点
L->next = L;
}
//销毁循环单链表L
void DestroyList(CLinkList *&L)
{
CLinkList *p = L;
CLinkList *q = p->next;
while(q != L)
{
free(p);
p = q;
q = p->next;
}
free(p);
}
//判断是否为空表
int ListEmpty(CLinkList *L)
{
return (L->next == L);
}
//求长度
int ListLength(CLinkList *L)
{
int i = 0;
CLinkList *p = L;
while(p->next != L)
{
i++;
p = p->next;
}
return i;
}
//输出循环单链表L
void DispList(CLinkList *L)
{
CLinkList *p = L->next;
while(p != L)
{
printf("%c ", p->data);
p = p->next;
}
printf("
");
}
//获取循环单链表L中的第i个元素
int GetElem(CLinkList *L, int i, ElemType &e)
{
int j = 0;
CLinkList *p;
if(L->next != L) // 单链表为非空表时
{
if(i == 1)
{
e = L->next->data; // 提取元素
return 1;
}
else // i不为1时
{
p = L->next;
while((p != L) && (j < i - 1))
{
j++;
p = p->next;
}
if(p == L)
return 0;
else // 找到第i个元素
{
e = p->data;
return e;
}
}
}
else // 单链表为空表时
return 0;
}
//在循环单链表L中查找元素e
int LocateElem(CLinkList *L, ElemType e)
{
int n = 1;
CLinkList *p = L->next;
while((p != L) && (p->data != e))
{
p = p->next;
n++;
}
if(p == L)
return 0;
else
return n;
}
//在循环单链表L中第i个位置上插入元素e
int ListInsert(CLinkList *&L, int i, ElemType e)
{
int j = 0;
CLinkList *p = L, *s;
if((i == 1) || (p->next == L)) // 原单链表为空表或i=1时
{
s = (CLinkList *)malloc(sizeof(CLinkList)); // 创建新结点s
s->data = e;
s->next = p ->next; // 将s插入到p之后
p->next = s;
return 1;
}
else
{
p = L->next;
while((p != L) && (j < i - 2)) // 查找第i-1个结点
{
j++;
p = p->next;
}
if(p == L) // 未找到第i-1个结点
return 0;
else // 找到第i-1个结点
{
s = (CLinkList *)malloc(sizeof(CLinkList)); // 创建新结点s
s->data = e;
s->next = p->next; // 将s插入到p之后
p->next = s;
return 1;
}
}
}
//在循环单链表L中删除第i个元素
int ListDelete(CLinkList *&L, int i, ElemType &e)
{
int j = 0;
CLinkList *p = L, *q;
if(p->next != L) // 原单链表不为空表时
{
if(i == 1) // i=1时
{
q = L->next; // 删除第1个结点
e = q->data;
L->next = q->next;
free(q);
return 1;
}
else // i不为1时
{
p = L->next;
while((p != L) && (j < i - 2)) // 查找第i-1个结点
{
j++;
p = p->next;
}
if(p == L) // 未查找到第i-1个结点
return 0;
else // 查找到第i-1个结点
{
q = p->next; // q指向要删除的结点
e = q->data; // 提取元素
p->next = q->next; // 从单链表中删除q结点
free(q); // 释放q结点
}
}
}
else
return 0;
}
int main()
{
CLinkList *h;
ElemType e;
printf("(1)初始化循环单链表h
");
InitList(h);
printf("(2)依次采用尾部插入法插入a,b,c,d,e元素
");
ListInsert(h, 1, ‘a‘);
ListInsert(h, 2, ‘b‘);
ListInsert(h, 3, ‘c‘);
ListInsert(h, 4, ‘d‘);
ListInsert(h, 5, ‘e‘);
printf("(3)输出循环单链表h:");
DispList(h);
printf("(4)循环单链表h长度=%d
", ListLength(h));
printf("(5)循环单链表h为%s
", (ListEmpty(h) ? "空" : "非空"));
GetElem(h, 3, e);
printf("(6)循环单链表h的第3个元素=%c
", e);
printf("(7)元素a的位置=%d
", LocateElem(h, ‘a‘));
printf("(8)在第4个元素位置上插入f元素
");
ListInsert(h, 4, ‘f‘);
printf("(9)输出循环单链表h:");
DispList(h);
printf("(10)删除h的第3个元素
");
ListDelete(h, 3, e);
printf("(11)输出循环单链表h:");
DispList(h);
printf("(12)释放循环单链表h
");
DestroyList(h);
}
5、循环双链表的各种基本运算操作
#include <stdio.h>
#include <malloc.h>
//学习自CSDN作者-静能生悟，循环双链表主要看插入和删除操作的代码实现即可
typedef char ElemType;
typedef struct DNode // 定义循环双链表结点类型
{
ElemType data; // 数据域
struct DNode *prior; // 指向直接前驱结点
struct DNode *next; // 指向直接后继结点
}CDLinkList;
//初始化
void InitList(CDLinkList *&L) // 指针的引用
{
L = (CDLinkList *)malloc(sizeof(CDLinkList)); // 创建头结点
L->prior = L->next = L;
}
//销毁循环双链表L
void DestroyList(CDLinkList *&L)
{
CDLinkList *p = L;
CDLinkList *q = p->next;
while(q != L)
{
free(p);
p = q;
q = p->next;
}
free(p);
}
//判断循环双链表L是否为空表
int ListEmpty(CDLinkList *L)
{
return (L->next == L);
}
//求长度
int ListLength(CDLinkList *L)
{
int i = 0;
CDLinkList *p = L;
while(p->next != L)
{
i++;
p = p->next;
}
return i;
}
//输出循环双链表L
void DispList(CDLinkList *L)
{
CDLinkList *p = L->next;
while(p != L)
{
printf("%c ", p->data);
p = p->next;
}
printf("
");
}
//获取循环双链表L中第i个元素
int GetElem(CDLinkList *L, int i, ElemType &e)
{
int j = 0;
CDLinkList *p;
if(L->next != L) // 循环双链表为非空表时
{
if(i == 1)
{
e = L->next->data; // 提取元素
return 1;
}
else // i不为1时
{
p = L->next;
while((p != L) && (j < i - 1))
{
j++;
p = p->next;
}
if(p == L)
return 0;
else
{
e = p->data;
return 1;
}
}
}
else // 循环双链表为空表时
return 0;
}
//在循环双链表L中查找元素e
int LocateElem(CDLinkList *L, ElemType e)
{
int n = 1;
CDLinkList *p = L->next;
while((p != L) && (p->data != e))
{
n++;
p = p->next;
}
if(p == NULL)
return 0;
else
return n;
}
//在循环双链表L中第i个位置上插入元素e
int ListInsert(CDLinkList *&L, int i, ElemType e)
{
int j = 0;
CDLinkList *p = L, *s;
if(p->next == L) // 原双链表为空表时
{
s = (CDLinkList *)malloc(sizeof(CDLinkList)); // 创建新结点s
s->data = e;
p->next = s; s->next = p;
p->prior = s; s->prior = p;
return 1;
}
else if(i == 1) // 原双链表不为空表但i=1时
{
s = (CDLinkList *)malloc(sizeof(CDLinkList)); // 创建新结点s
s->data = e;
// 将s插入到结点p之后
s->next = p->next;
p->next = s;
s->next->prior = s;
s->prior = p;
return 1;
}
else
{
p = L->next;
while((p != L) && (j < i - 2))
{
j++;
p = p->next;
}
if(p == L) // 未找到第i-1个结点
return 0;
else // 找到第i-1个结点p
{
s = (CDLinkList *)malloc(sizeof(CDLinkList)); // 创建新结点s
s->data = e;
// 将s插入到结点p之后
s->next = p->next;
if(p ->next != NULL)
p->next->prior = s;
s->prior = p;
p->next = s;
return 1;
}
}
}
//在循环双链表L中删除第i个元素e
int ListDelete(CDLinkList *&L, int i, ElemType &e)
{
int j = 0;
CDLinkList *p = L, *q;
if(p->next != L) // 原双链表不为空表时
{
if(i == 1) // i=1时
{
q = L->next; // 删除第1个结点
e = q->data;
L->next = q->next;
q->next->prior = L;
free(q);
return 1;
}
else // i不为1时
{
p = L->next;
while((p != NULL) && (j < i - 2))
{
j++;
p = p->next;
}
if(p == NULL) // 未找到第i-1个结点
return 0;
else // 找到第i-1个结点p
{
q = p->next; // q指向要删除的结点
if(q == NULL) // 不存在第i个结点
return 0;
e = q->data;
// 从链表中删除q结点
p->next = q->next;
if(p->next != NULL)
p->next->prior = p;
free(q);
return 1;
}
}
}
else // 原双链表为空表时
return 0;
}
int main()
{
CDLinkList *h;
ElemType e;
printf("(1)初始化循环双链表h
");
InitList(h);
printf("(2)依次采用尾插入法插入a,b,c,d,e元素
");
ListInsert(h, 1, ‘a‘);
ListInsert(h, 2, ‘b‘);
ListInsert(h, 3, ‘c‘);
ListInsert(h, 4, ‘d‘);
ListInsert(h, 5, ‘e‘);
printf("(3)输出循环双链表h:");
DispList(h);
printf("(4)循环双链表h长度=%d
", ListLength(h));
printf("(5)循环双链表h为%s
", (ListEmpty(h) ? "空" : "非空"));
GetElem(h, 3, e);
printf("(6)循环双链表h的第3个元素=%c
", e);
printf("(7)元素a的位置=%d
", LocateElem(h, ‘a‘));
printf("(8)在第4个元素位置上插入f元素
");
ListInsert(h, 4, ‘f‘);
printf("(9)输出循环双链表h:");
DispList(h);
printf("(10)删除h的第3个元素
");
ListDelete(h, 3, e);
printf("(11)输出循环双链表h:");
DispList(h);
printf("(12)释放循环双链表h
");
DestroyList(h);
}
6、将单链表按基准划分
#include <stdio.h>
#include <malloc.h>
typedef int ElemType;
typedef struct LNode
{
ElemType data; //数据域
struct LNode *next; //指向后继结点
}LinkNode; // 声明单链表结点类型
//尾插法建立单链表
void CreateListRear(LinkNode *&L,ElemType a[],int n)
{
LinkNode *s,*r;
int i;
L=(LinkNode *)malloc(sizeof(LinkNode)); //创建头结点
r=L; //r始终指向尾结点，开始时指向头结点
for (int i = 0; i < n; i++)
{
//创建新结点s
s=(LinkNode *)malloc(sizeof(LinkNode));
s->data=a[i];
r->next=s; //将s插入r之后
r=s;
}
r->next=NULL; //尾结点next域置为NULL
}
//输出单链表
void DispList(LinkNode *L)
{
LinkNode *p=L->next; //p指向首节点
while(p!=NULL)
{
printf("%d",p->data ); // p不为NULL,输出p结点的数据域
p=p->next; // p移向下一个结点
}
printf("
");
}
//销毁单链表
void DestroyList(LinkNode *L)
{
LinkNode *pre=L,*p=L->next; //pre指向头结点，p指向首节点
while(p!=NULL)
{
free(pre);
pre=p;
p=pre->next; // pre、p同步后移一个结点
}
free(pre); // 此时p为NULL,pre指向尾结点,释放它
}
//将L中所有数据结点按e进行划分 【本题核心代码】
void split(LinkNode *&L,ElemType e)
{
LinkNode *p=L->next,*q,*r; //p指向首节点
//L变为空表
L->next=NULL;
// r是新链表的尾结点指针
r=L;
while(p!=NULL)
{
if(p->data<e) // 若p结点值小于e,将其插入到开头
{
q=p->next;
p->next=L->next;
L->next=p;
// 若p结点是第一个在开头插入的结点,则它是尾结点
if(p->next==NULL)
r=p;
p=q;
}
else // 若p结点值大于或等于e,将其插入到末尾
{
r->next=p;
r=p;
p=p->next;
}
}
r->next=NULL;
}
int main()
{
LinkNode *L;
//ElemType a[] = {1,2,3,5,6,7,8,9};
ElemType a[] = {1,9,8,6,5,3,7,2};
int n = 8;
CreateListRear(L,a,n);
printf("单链表L:");
DispList(L);
ElemType x = 4;
printf("以%d进行划分
", x);
split(L,x);
printf("单链表L:");
DispList(L);
DestroyList(L);
}
7、将两个单链表合并成一个单链表
//注意空间复杂度O(1) 即不能开辟新的辅助空间
#include <stdio.h>
#include <malloc.h>
typedef int ElemType;
typedef struct LNode
{
ElemType data; //数据域
struct LNode *next; //指向后继结点
}LinkNode; // 声明单链表结点类型
//尾插法建立单链表
void CreateListRear(LinkNode *&L,ElemType a[],int n)
{
LinkNode *s,*r;
int i;
L=(LinkNode *)malloc(sizeof(LinkNode)); //创建头结点
r=L; //r始终指向尾结点，开始时指向头结点
for (int i = 0; i < n; i++)
{
//创建新结点s
s=(LinkNode *)malloc(sizeof(LinkNode));
s->data=a[i];
r->next=s; //将s插入r之后
r=s;
}
r->next=NULL; //尾结点next域置为NULL
}
//输出单链表
void DispList(LinkNode *L)
{
LinkNode *p=L->next; //p指向首节点
while(p!=NULL)
{
printf("%d ",p->data ); // p不为NULL,输出p结点的数据域
p=p->next; // p移向下一个结点
}
printf("
");
}
//销毁单链表
void DestroyList(LinkNode *L)
{
LinkNode *pre=L,*p=L->next; //pre指向头结点，p指向首节点
while(p!=NULL)
{
free(pre);
pre=p;
p=pre->next; // pre、p同步后移一个结点
}
free(pre); // 此时p为NULL,pre指向尾结点,释放它
}
//合并
void MergeList(LinkNode *L1,LinkNode *L2,LinkNode *&L3)
{
LinkNode *p = L1->next;
LinkNode *q = L2->next;
LinkNode *r;
L3=L1;
// r指向新建单链表L3的尾结点
r=L3;
//释放L2头结点
free(L2);
while(p!=NULL&&q!=NULL)
{
r->next=p;
r=p;
p=p->next;
r->next=q;
r=q;
q=q->next;
}
r->next=NULL;
if(q!=NULL)
p=q;
r->next=p;
}
int main()
{
LinkNode *L1, *L2, *L3;
ElemType a[] = {1,2,3,4,5,6,7,8};
int n = 8;
CreateListRear(L1,a,n);
printf("单链表L1:");
DispList(L1);
ElemType b[] = {20,19,18,17};
n = 4;
CreateListRear(L2,b,n);
printf("单链表L2:");
DispList(L2);
printf("L1和L2合并产生L3
");
MergeList(L1,L2,L3);
printf("单链表L3:");
DispList(L3);
DestroyList(L3);
}
8、求集合（用单链表表示）的并集、交集、差集运算
#include <stdio.h>
#include <stdlib.h>
//重点题型，掌握并集、交集、差集的实现
typedef int ElemType;
typedef struct LNode
{
ElemType data;
struct LNode *next;
}LinkList;
/* 单链表的初始化 */
void InitList(LinkList *&L)
{
L = (LinkList *)malloc(sizeof(LinkList));
L->next=NULL;
}
//向单链表中插入数据元素
bool ListInsert(LinkList *&L,int x,char e)
{
int j = 0;
LinkList *p = L, *s;
while(p!=NULL && j<x-1)
{
p = p->next;
j++;
}
if(p==NULL)
{
return false;
}
else
{
s = (LinkList *)malloc(sizeof(LinkList));
s->data = e;
s->next = p->next;
p->next = s;
return true;
}
}
//输出单链表
void DispList(LinkList *L)
{
LinkList *p = L->next;
while(p!=NULL)
{
printf("%d ",p->data);
p = p->next;
}
printf("
");
}
// 求单链表的长度
int ListLength(LinkList *L)
{
LinkList *p = L->next;
int i = 0;
while(p!=NULL)
{
i++;
p = p->next;
}
return i;
}
// 查看单链表是否为空
bool ListEmpty(LinkList *L)
{
return L->next==NULL;
}
//求单链表中某个数据元素值
bool GetElem(LinkList *L,int i, ElemType &e)
{
LinkList *p = L;
int j = 0;
while(p!=NULL && j < i)
{
p=p->next;
j++;
}
if(p==NULL)
{
return false;
}
else
{
e = p->data;
return true;
}
}
// 在单链表中查找元素
int LocateElem(LinkList *L,ElemType e)
{
LinkList *p = L;
int i = 0;
while(p!=NULL && p->data!=e)
{
p = p->next;
i++;
}
if(p==NULL)
{
return 0;
}
else
{
return i;
}
}
//删除单链表中第 i 个元素
bool ListDelete(LinkList *&L,int i,ElemType &e)
{
int j = 0;
LinkList *p = L, *q;
while(p!=NULL && j < i - 1)
{
p = p->next;
j++;
}
if(p==NULL)
return false;
else
{
q = p->next;
if(q==NULL)
return false;
e = q->data;
p->next = q->next;
free(q);
return true;
}
}
//销毁单链表
void DestroyList(LinkList *&L)
{
LinkList *p = L;
LinkList *q = p->next;
while(q!=NULL)
{
free(p);
p = q;
q = p->next;
}
free(p);
}
//将集合 a 和 b 中的元素添加到顺序表 ha 和 hb 中
void CreateListR(LinkList *&L,ElemType e[],int n)
{
InitList(L);
int i;
for(i = 0;i < n; ++i)
{
if(!LocateElem(L,e[i]))
ListInsert(L,i+1,e[i]);
}
}
//选择排序
void sort(LinkList *&L)
{
LinkList *p , *pre, *q, *k;
InitList(p);
int i = 0;
int c;
while(!ListEmpty(L))
{
pre = L ->next;
c = pre->data;
while(pre!=NULL)
{
if(c>=pre->data)
c = pre->data;
pre = pre->next;
}
ListInsert(p,++i,c);
int tag = LocateElem(L,c);
ListDelete(L,tag,c);
}
L = p;
}
//并集
void Union(LinkList *a,LinkList *b,LinkList *&c)
{
InitList(c);
LinkList *p = a->next;
LinkList *q = b->next;
int k = 0;
while(p!=NULL && q!=NULL)
{
if(p->data < q->data)
{
ListInsert(c,k+1,p->data);
p = p->next;
k++;
}
else if(p->data == q->data)
{
ListInsert(c,k+1,p->data);
p = p->next;
q = q->next;
k++;
}
else
{
ListInsert(c,k+1,q->data);
q = q->next;
k++;
}
}
while(p!=NULL)
{
ListInsert(c,k+1,p->data);
p = p->next;
k++;
}
while(q!=NULL)
{
ListInsert(c,k+1,q->data);
q = q->next;
k++;
}
}
//交集 a中元素一个个取出，通过LocateElem函数看b中是否出现，出现则copy至c
void InsterSect(LinkList *a,LinkList *b,LinkList *&c)
{
DestroyList(c);
InitList(c);
LinkList *p = a->next;
int i = 0;
while(p!=NULL)
{
if(LocateElem(b,p->data))
ListInsert(c,++i,p->data);
p = p->next;
}
}
//差集 a中元素一个个取出，通过LocateElem函数看b中是否出现，不出现则copy至c
void Subs(LinkList *a,LinkList *b,LinkList *&c)
{
DestroyList(c);
InitList(c);
LinkList *p = a->next;
int i = 0;
while(p!=NULL)
{
if(!LocateElem(b,p->data))
ListInsert(c,++i,p->data);
p = p->next;
}
}
int main( )
{
LinkList *ha, *hb, *hc;
ElemType a[]={1,2,3,4};
ElemType b[]={10,4,22,5,81,2};
printf("集合的运算如下
");
CreateListR(ha,a,4);
CreateListR(hb,b,6);
printf("原 集 合 A: "); DispList(ha);
printf("原 集 合 B: "); DispList(hb);
sort(ha);
sort(hb);
printf("有序集合A："); DispList(ha);
printf("有序集合B："); DispList(hb);
Union(ha,hb,hc);
printf("集合的并C："); DispList(hc);
InsterSect(ha,hb,hc);
printf("集合的交C："); DispList(hc);
Subs(ha,hb,hc);
printf("集合的差C："); DispList(hc);
DestroyList(ha);
DestroyList(hb);
DestroyList(hc);
}
9、求两个多项式的相加运算
#include<stdio.h>
#include<stdlib.h>
//学习自CSDN作者-man_zuo
typedef struct
{
float coef; //系数
int expn; //指数
}Term;
typedef struct Ploynomial
{
Term term;
Ploynomial *next;
}Ploynomial,*LinkList;
//初始化单链表
void InitList(LinkList &L)
{
L= (Ploynomial*)malloc(sizeof(Ploynomial));//头结点
L->term.coef=0.0;
L->term.expn=-1;
L->next=NULL;
}
//比较结点的系数大小函数
int cmp(Term a,Term b)
{
if (a.expn>b.expn) return -1;
else if(a.expn==b.expn) return 0;
else return 1;
}
//将结点插入多项式链表的适当位置，可以同时起到创建链表和多项式相加的功能
void insertNode(LinkList &L,Term e)
{
Ploynomial *q=L;
while(q->next!=NULL)
{ //如果当前结点q的下一个结点的指数 大于 要插入的结点的指数
if (cmp(q->next->term,e)<0)
{
q=q->next;
}
else break; //此时， q.term.expn>e.expn >=q->next->term.expn
}
if (q->next!=NULL&&cmp(q->next->term,e)==0)
{ //指数相同，系数相加
q->next->term.coef+=e.coef;
}
else
{
Ploynomial *node = (Ploynomial *)malloc(sizeof(Ploynomial));
node->term.coef=e.coef;
node->term.expn=e.expn;
if(q->next==NULL)
node->next=NULL; //如果q结点为尾结点，则node的指针域设为NULL
else
node->next=q->next; //否则node的指针域指向q的下一个结点
q->next=node;//将node结点插入链表中
}
}
//输入m项的系数和指数，建立表示一元多项式的有序链表L，演示功能，无需学习
void CreatePolyn(LinkList &L,int n)
{
Term e;
InitList(L);
for (int i = 1; i <= n; i++)
{
printf("
第%d项的系数和指数：",i);
scanf("%f%d",&e.coef,&e.expn);
insertNode(L,e);
}
}
//用L返回L1+L2的结果
void addPolyn(LinkList &L,LinkList L1,LinkList L2)
{
Ploynomial *q;
for (q=L1->next; q!=NULL; q=q->next)
{
insertNode(L,q->term); //将L1的每一项插入到L中
}
for (q=L2->next; q!=NULL; q=q->next)
{
insertNode(L,q->term); //将L2的每一项插入到L中
}
}
//以类数学表达式的形式打印输出一元多项式L,演示功能，无需学习
void visitList(LinkList L)
{
Ploynomial *q=L;
int flag;
while(q->next!=NULL)
{
q=q->next;
flag=1;
if(q->term.coef==0) continue;//系数为0 不输出
if(q->term.expn==0&&flag==1) //指数为1
{
if(q->term.coef>0)
printf("+%.2f",q->term.coef);
else
printf("%.2f",q->term.coef);
flag=0;
}
if((q->term.coef==1||q->term.coef==-1)&&flag==1)//系数为1
{
if(q->term.expn==1){
if(q->term.coef==1)
printf("+X");
else
printf("-X");
}else{
if(q->term.coef==1)
printf("+X^%d",q->term.expn);
else
printf("-X^%d",q->term.expn);
}
flag=0;
}
if(flag==1)
{
if(q->term.coef>0)
printf("+%.2fX^%d",q->term.coef,q->term.expn);
else
printf("%.2fX^%d",q->term.coef,q->term.expn);
}
}
printf("
");
}
int main()
{
LinkList L1,L2;
int n1,n2;
printf("请输入多项式L1的项数：");
scanf("%d",&n1);
CreatePolyn(L1,n1);
printf("请输入多项式L2的项数：");
scanf("%d",&n2);
CreatePolyn(L2,n2);
printf("
多项式L1: ");
visitList(L1);
printf("
多项式L2: ");
visitList(L2);
LinkList add;
InitList(add);
addPolyn(add,L1,L2);
printf("
L1 + L2: ");
visitList(add);
}
10、求两个多项式的相乘运算
//用L返回L1*L2的结果
//将该方法加入第九题中即可，书写主方法即可
void multiplyPolyn(LinkList &L,LinkList L1,LinkList L2)
{
Ploynomial *p,*q;
Term term;
term.coef=0.0;
term.expn=0;
for(q=L1->next; q!=NULL; q=q->next)
{
for(p=L2->next; p!=NULL; p=p->next)
{
term.coef=(q->term.coef)*(p->term.coef);//系数相乘
term.expn=(q->term.expn)+(p->term.expn);// 指数想加
insertNode(L,term);
}
}
}
11、用单链表实现两个大整数的相加运算
#include <stdio.h>
#include <malloc.h>
#include <string.h>
#define MAX_SIZE 50
//学习于CSDN作者-静能生悟，本题重点在于学习add操作，以及为什么要reverse
typedef struct node
{
int data;
struct node *next;
}NodeType;
//创建整数单链表
void createList(NodeType *&h,char a[],int n)
{
NodeType *p,*r;
int i=0;
//创建头结点
h=(NodeType *)malloc(sizeof(NodeType));
r=h; //r指向新创建的头结点
while(i<n)
{
//创建新结点p
p=(NodeType *)malloc(sizeof(NodeType));
p->data=a[n-i-1]-‘0‘;
//将p插入r之后
r->next=p;
//r指向新结点
r=p;
i++;
}
r->next=NULL;
}
//输出单链表
void dispList(NodeType *h)
{
NodeType *p = h->next; // p指向整数单链表的第一个数据结点
while(p != NULL)
{
printf("%d ", p->data);
p = p->next;
}
printf("
");
}
//销毁单链表
void destoryList(NodeType *&h)
{
NodeType *pre=h; // pre指向整数单链表的头结点
NodeType *p=pre->next; // p指向整数单链表的第一个数据结点(首节点)
while(p!=NULL)
{
free(pre);
pre=p; //pre,p同步后移一个结点
p=p->next;
}
free(pre);
}
//两整数单链表h1和h2相加得到h
void addList(NodeType *h1,NodeType *h2,NodeType *&h)
{
NodeType *p1=h1->next; //p1指向单链表h1中的第一个数据结点
NodeType *p2=h2->next; //p2指向单链表h2中的第一个数据结点
NodeType *p,*r;
int carry = 0;
//创建头结点
h=(NodeType *)malloc(sizeof(NodeType));
// r指向新创建头结点
r=h;
while(p1!=NULL&&p2!=NULL)
{
//创建新结点p
p=(NodeType *)malloc(sizeof(NodeType));
p->data=(p1->data+p2->data+carry)%10; // 求余
// 将新结点p插入到r指向的头结点之后
r->next=p;
// r后移一个结点
r=p;
carry=(p1->data+p2->data+carry)/10; //求商
// p1和p2指向下一个结点
p1 = p1->next;
p2 = p2->next;
}
if(p1!=NULL)
p1=p2;
while(p1!=NULL)
{
p=(NodeType *)malloc(sizeof(NodeType));
p->data=(p1->data+carry)%10; // 数据域
// 将新结点p插入到r指向的头结点之后
r->next=p;
// r后移一个结点
r=p;
carry=(p1->data+carry)/10;
p1=p1->next;
}
// 最后carry不为0时,创建一个结点存放它
if(carry>0)
{
p=(NodeType *)malloc(sizeof(NodeType));
p->data=carry;
// 将新结点p插入到r指向的头结点之后
r->next = p;
// r后移一个结点
r = p;
}
r->next=NULL;
}
//逆置整数单链表h
void reverseList(NodeType *&h)
{
NodeType *p=h->next,*q;
h->next=NULL;
while(p!=NULL)
{
q=p->next;
p->next=h->next;
h->next=p;
p=q;
}
}
//求整数单链表h的中间位
/**
* 算法设计思路:
* 定义快指针quick和慢指针slow,初始时都指向头结点,当快指针没有
* 扫描完整数单链表h时,每次让慢指针slow前进一个结点,快指针quick前进两个
* 结点.当快指针到达链表尾时,慢指针slow指向的结点就是中间结点.
*/
int midList(NodeType *h)
{
NodeType *slow=h; //定义慢指针
NodeType *quick=h; //定义快指针
while(quick!=NULL&&quick->next!=NULL)
{
slow=slow->next; // 慢指针slow前进一个结点
quick=quick->next->next; // 快指针quick前进两个结点
}
return slow->data;
}
int main(int argc, char const *argv[])
{
NodeType *h1,*h2,*h;
char s[MAX_SIZE],t[MAX_SIZE];
printf("(1)输入大整数a: ");
scanf("%s", s);
printf("(2)输入大整数b: ");
scanf("%s", t);
createList(h1,s,strlen(s));
createList(h2,t,strlen(t));
printf("(3)整数单链表a: ");
dispList(h1);
printf("(4)整数单链表b: ");
dispList(h2);
addList(h1,h2,h);
printf("(5)结果单链表c: ");
dispList(h);
reverseList(h);
printf("(6)对应的整数c: ");
dispList(h);
printf("(7)中间位: %d", midList(h));
destoryList(h);
destoryList(h1);
destoryList(h2);
return 0;
}
以上是关于数据结构上机实验的主要内容，如果未能解决你的问题，请参考以下文章