SCAU数据结构实训实验1

已于 2024-06-08 01:33:07 修改
阅读量137 收藏 3
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 算法
于 2024-06-08 00:55:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80011650/article/details/139537575
版权

目录

顺序表基本操作

//初始化
int InitList_Sq(SqList& L)
{
	// 算法2.3，构造一个空的线性表L，该线性表预定义大小为LIST_INIT_SIZE
	// 请补全代码
	L.elem = new ElemType[LIST_INIT_SIZE];
	L.length = 0;
	L.listsize = LIST_INIT_SIZE;
	return OK;
}

int ListInsert_Sq(SqList& L, int i, int e)
{
	// 算法2.4，在顺序线性表L中第i个位置之前插入新的元素e
	// i的合法值为1≤i≤L.length +1
	// 请补全代码
	if (i<1 || i>L.length + 1) return ERROR;
	else if (L.length == LIST_INIT_SIZE)  return ERROR;
	else
	{
		for (int j = L.length - 1; j >= i - 1; j--)
		{
			L.elem[j + 1] = L.elem[j];
		}
		L.elem[i - 1] = e;
		L.length++;
		return OK;
	}

}

int ListDelete_Sq(SqList& L, int i, int& e)
{
	// 算法2.5,在顺序线性表L中删除第i个位置的元素，并用e返回其值
	// i的合法值为1≤i≤L.length
	// 请补全代码
	if (i<1 || i>L.length)//判断i位置是否合理
		return ERROR;
	e = L.elem[i - 1];
	for (int j = i - 1; j <= L.length - 1; j++)
	{
		L.elem[j] = L.elem[j + 1];//删除 
	}
	L.length--;//表长减一 
	return OK;
}

合并顺序表

#include <iostream>
using namespace std;
int a[100], b[100];
int ans[200];
int main()
{
	int n1, n2;
	
	cin >> n1;
	for (int i = 0; i < n1; i++)
		cin >> a[i];
	cin >> n2;
	for (int i = 0; i < n2; i++)
		cin >> b[i];
	int i = 0, j = 0;
	int k = 0;
	while (i < n1 && j < n2)
	{
		if (a[i] < b[j])
			ans[k++] = a[i++];
		else
			ans[k++] = b[j++];
	}
	while (i < n1)
	{
		ans[k++] = a[i++];
	}
	while (j < n2)
	{
		ans[k++] = b[j++];
	}
	cout << "List A:";
	for (int i = 0; i < n1; i++)
		cout << a[i] << ' ';
	cout << endl;
	cout << "List B:";
	for (int i = 0; i < n2; i++)
		cout << b[i] << ' ';
	cout << endl;
	cout << "List C:";
	for (int i = 0; i < k; i++)
		cout << ans[i] << ' ';
	cout << endl;
	return 0;
}

顺序表逆置

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#define Listsize 100
typedef struct
{
	int* elem;
	int length;
	int listsize;

}Sqlist;

int InitLIST(Sqlist* L)
{
	L->length = 0;
	L->listsize = Listsize;
	L->elem = (int*)malloc(sizeof(int) * Listsize);
	return 1;
}
int inserList(Sqlist* L, int i, int e)
{
	if (i<1 || i>L->length + 1)
		return 0;
	if (L->length >= L->listsize)
		return 0;
	for (int j = i - 1; j < L->length; j++)
		L->elem[j + 1] = L->elem[j];
	L->elem[i - 1] = e;
	L->length++;
	return 1;
}

void displaylist(Sqlist *L)
{
	for (int i = 0; i < L->length; i++)
		printf("%d ", L->elem[i]);
	printf("\n");
}
void mergelist_Sq(Sqlist *LA, Sqlist *LB, Sqlist* LC)
{
	int* pa = LA->elem;
	int* pb = LB->elem;
	LC->length = LA->length + LB->length;
	LC->elem = (int*)malloc(sizeof(int) * LC->length);
	int* pc = LC->elem;
	int* pa_last = pa + LA->length - 1;
	int* pb_last = pb+ LB->length - 1;
	while (pa <= pa_last && pb <= pb_last)
	{
		if (*pa <= *pb) {*pc = *pa;  pc++;pa++;}
		else {*pc = *pb; pc++;pb++;}
	}
	while (pa <= pa_last) {*pc = *pa;pc++;pa++;}
	while (pb <= pb_last) {*pc = *pb;pc++;pb++;}
}

void converlist(Sqlist *L)
{
    int mid = L->length/2;
    for(int i=0;i<mid;i++)
    {
        int t = L->elem[i];
        L->elem[i] =L->elem[L->length-1-i];
        L->elem[L->length-1-i] = t;
    }
}
/*
int main()
{
    Sqlist La,Lb,Lc;
    int m;
    int i=1;
    int e;
    InitLIST(&La);
    InitLIST(&Lb);
    scanf("%d",&m);
    while(m>0)
    {
        scanf("%d",&e);
        inserList(&La,i,e);
        i++;
        m--;
    }
    i=1;
    int n;
    scanf("%d",&n);
    while(n>0)
    {
        scanf("%d",&e);
        inserList(&Lb,i,e);
        i++;
        n--;
    }
    mergelist_Sq(&La,&Lb,&Lc);
    printf("List A:");
    displaylist(&La);
    printf("List B:");
    displaylist(&Lb);
    printf("List C:");
    displaylist(&Lc);
    converlist(&Lc);
    displaylist(&Lc);
    return 0;
}
*/
int main()
{
    Sqlist L;
    InitLIST(&L);
    int n,e;
    scanf("%d",&n);
    int i=1;
    while(n>0)
    {
        scanf("%d",&e);
        inserList(&L,i,e);
        i++;
        n--;
    }
    printf("The List is:");
    displaylist(&L);
    printf("The turned List is:");
    converlist(&L);
    displaylist(&L);
    return 0;
}

链表基本操作

#include<stdio.h>
#include<malloc.h>
#define ERROR 0
#define OK 1
#define ElemType int

typedef struct LNode
{
 int data;
 struct LNode *next;
}LNode,*LinkList;

int CreateLink_L(LinkList &L,int n){
// 创建含有n个元素的单链表
  LinkList p,q;
  int i;
  ElemType e;
  L = (LinkList)malloc(sizeof(LNode));
  L->next = NULL;              // 先建立一个带头结点的单链表
  q = (LinkList)malloc(sizeof(LNode));
  q = L;
  for (i=0; i<n; i++) {
	 scanf("%d", &e);
    p = (LinkList)malloc(sizeof(LNode));  // 生成新结点
    // 请补全代码


    p->data=e;
    p->next=NULL;
    q->next=p;
    q=q->next;


  }
  return OK;
}

int LoadLink_L(LinkList &L){
// 单链表遍历
 LinkList p = L->next;
 if( p==NULL )printf("The List is empty!"); // 请填空
 else
 {
	 printf("The LinkList is:");
	 while(p!=NULL)    // 请填空
	 {
		printf("%d ",p->data);
		p=p->next;    // 请填空
	 }
 }
 printf("\n");
 return OK;
}

int LinkInsert_L(LinkList &L,int i,ElemType e){
// 算法2.9
// 在带头结点的单链线性表L中第i个位置之前插入元素e
// 请补全代码

    LinkList p=L;
    int j=1;//初始化，指针指向第一个结点
    while(p && j<i)//顺时针查找，直到p指向第i个元素或p为空
    {
        p=p->next;
        j++;
    }
    if(!p|| j>i) return ERROR;//第i个元素不存在
    LinkList s;
    s=(LinkList)malloc(sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return OK;
}

int LinkDelete_L(LinkList &L,int i, ElemType &e){
// 算法2.10
// 在带头结点的单链线性表L中，删除第i个元素，并用e返回其值
// 请补全代码
    LinkList p=L;
    int j=0;
    while(p->next && j<i-1)
    {
        p=p->next;
        ++j;
    }//找到第i-1个元素，标号为i-2
    if(!(p->next) || j>i-1) return ERROR;
    LinkList q=p->next;//第i个元素给q
    p->next=q->next;
    e=q->data;
    free(q);
    return OK;
}

int main()
{
 LinkList T;
 int a,n,i;
 ElemType x, e;
 printf("Please input the init size of the linklist:\n");
 scanf("%d",&n);
 printf("Please input the %d element of the linklist:\n", n);
 if( CreateLink_L(T,n))     // 判断链表是否创建成功，请填空
 {
	 printf("A Link List Has Created.\n");
	 LoadLink_L(T);
 }
 while(1)
	{
		printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n");
		scanf("%d",&a);
		switch(a)
		{
			case 1: scanf("%d%d",&i,&x);
				  if(!LinkInsert_L(T,i,x)) printf("Insert Error!\n"); // 判断i值是否合法，请填空
				  else printf("The Element %d is Successfully Inserted!\n", x);
				  break;
			case 2: scanf("%d",&i);
				  if(!LinkDelete_L(T,i,e)) printf("Delete Error!\n"); // 判断i值是否合法，请填空
				  else printf("The Element %d is Successfully Deleted!\n", e);
				  break;
			case 3: LoadLink_L(T);
				  break;
			case 0: return 1;
		}
	}
}

合并链表

#include<stdio.h>
#include<malloc.h>
#define ERROR 0
#define OK 1 
#define ElemType int

typedef int Status;
typedef struct LNode
{
    int data;
    struct LNode* next;
}LNode, * LinkList;


Status ListInsert_L(LinkList& L, int i, ElemType e) {  // 算法2.9
    // 在带头结点的单链线性表L的第i个元素之前插入元素e
    LinkList p, s;
    p = L;
    int j = 0;
    while (p && j < i - 1) {  // 寻找第i-1个结点
        p = p->next;
        ++j;
    }
    if (!p || j > i - 1) return ERROR;      // i小于1或者大于表长
    s = (LinkList)malloc(sizeof(LNode));  // 生成新结点
    s->data = e;  s->next = p->next;      // 插入L中
    p->next = s;
    return OK;
} // LinstInsert_L

Status ListDelete_L(LinkList& L, int i, ElemType& e) {  // 算法2.10
    // 在带头结点的单链线性表L中，删除第i个元素，并由e返回其值
    LinkList p, q;
    p = L;
    int j = 0;
    while (p->next && j < i - 1) {  // 寻找第i个结点，并令p指向其前趋
        p = p->next;
        ++j;
    }
    if (!(p->next) || j > i - 1) return ERROR;  // 删除位置不合理
    q = p->next;
    p->next = q->next;           // 删除并释放结点
    e = q->data;
    free(q);
    return OK;
} // ListDelete_L

Status LoadLink_LA(LinkList& L)
{
    LinkList p = L->next;
    {
        printf("List A:");
        while (p)
        {
            printf("%d ", p->data);
            p = p->next;
        }
    }
    printf("\n");
    return OK;
}
Status LoadLink_LB(LinkList& L)
{
    LinkList p = L->next;
    {
        printf("List B:");
        while (p)
        {
            printf("%d ", p->data);
            p = p->next;
        }
    }
    printf("\n");
    return OK;
}

Status CreatLink_L(LinkList& L, int n)
{
    LinkList p, q;
    int i;
    ElemType e;
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    q = (LinkList)malloc(sizeof(LNode));
    q = L;
    for (i = 0; i < n; i++)
    {
        scanf("%d", &e);
        p = (LinkList)malloc(sizeof(LNode));
        p->data = e;
        p->next = NULL;
        q->next = p;
        q = q->next;
    }
    return OK;
}

int main()
{
    int n, m;
    scanf("%d", &n);
    LinkList L1;
    CreatLink_L(L1, n);
    scanf("%d", &m);
    LinkList L2;
    CreatLink_L(L2, m);
    LoadLink_LA(L1);
    LoadLink_LB(L2);
    LinkList p, q;
    p = L1, q = L2;
    p = p->next; q = q->next;
    printf("List C:");
    while (q && p)
    {
        if (p->data > q->data)
        {
            printf("%d ", q->data);
            q = q->next;
        }
        else
        {
            printf("%d ", p->data);
            p = p->next;
        }
    }
    while (q)
    {
        printf("%d ", q->data);
        q = q->next;
    }
    while (p)
    {
        printf("%d ", p->data);
        p = p->next;
    }
    return 0;
}

逆置链表

void reverseList(LNode*& L)
{
	LNode* p, * next;
	p = L->next;
	L->next = NULL;
	while (p)
	{
		next = p->next;
		p->next = L->next;
		L->next = p;
		p = next;
	}
}
华农第一蒟蒻
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
scau归并排序 SCAU数据结构年期末复习
07-05
SCAU数据结构年期末复习 本资源摘要信息涵盖了SCAU数据结构年期末复习的主要知识点，包括数据结构的概念、时间复杂度、算法设计、表的顺序存储结构、链式存储结构、栈的实现、队列的实现等。 数据结构的概念： * ...
数据结构习题1答案
01-03
数据结构课后习题1答案
SCAU程序设计在线实训平台_实验_数据结构_实验1
YelloooBlue's Blog
03-22 3149
8576 顺序线性表的基本操作 Description 编写算法，创建初始化容量为LIST_INIT_SIZE的顺序表T，并实现插入、删除、遍历操作。本题目给出部分代码，请补全内容。 #include<stdio.h> #include<malloc.h> #define OK 1 #define ERROR 0 #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #define ElemType int typedef s
8580 合并链表
Hunter_Kevin的博客
06-11 498
Description 线性链表的基本操作如下： #include<stdio.h> #include<malloc.h> #define ERROR 0 #define OK 1 #define ElemType int typedef int Status; typedef struct LNode { int data; struct LNode *next; }LNode,*LinkList; Status ListInsert_L(LinkList &L, int
8579 链式线性表的基本操作
Hunter_Kevin的博客
06-10 476
Description 编写算法，创建一个含有n个元素的带头结点的单链表L并实现插入、删除、遍历操作。本题目提供部分代码，请补全内容。 #include<stdio.h> #include<malloc.h> #define ERROR 0 #define OK 1 #define ElemType int typedef struct LNode { int data; struct LNode *next; }LNode,*LinkList; int CreateLink_L(L
scau数据结构实验
weixin_73094970的博客
06-08 5555
scau 数据结构实验
2021SCAU数据结构复习(实验1-实验3)
weixin_50340097的博客
06-02 4219
题1:8576 顺序线性表的基本操作 题目描述 Description 编写算法，创建初始化容量为LIST_INIT_SIZE的顺序表T，并实现插入、删除、遍历操作。本题目给出部分代码，请补全内容。 #include<stdio.h> #include<malloc.h> #define OK 1 #define ERROR 0 #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #define ElemType int typed
SCAU数据结构实训实验7
2301_80011650的博客
06-13 418
【代码】SCAU数据结构实训实验7。
SCAU数据结构实训实验3
2301_80011650的博客
06-13 421
【代码】SCAU数据结构实训实验3。
SCAU数据结构实训实验4
2301_80011650的博客
06-11 432
【代码】SCAU数据结构实训实验4。
SCAU数据结构实训实验5
2301_80011650的博客
06-12 392
这道题有几处错误导致提交时warning，下面是AC代码。
SCAU数据结构-STL详解-20210609.pptx
06-25
《SCAU数据结构——STL详解》 STL（Standard Template Library，标准模板库）是C++编程语言中不可或缺的一部分，它提供了丰富的数据结构和算法，极大地提升了开发效率。SCAU（华南农业大学）在此主题中深入讲解了...
SCAU 汇编 实验题 华农 课本
06-13
1. **指令集**：汇编语言的指令集对应于计算机硬件的机器语言，每条指令通常执行一个特定的操作，如数据加载、存储、算术运算或逻辑操作。例如，`MOV`用于数据传输，`ADD`用于加法，`SUB`用于减法，`JMP`用于跳转等...
SCAU数电实验：自动售饮料机.rar
07-15
《SCAU数电实验：自动售饮料机》 在SCAU（华南农业大学）的数字逻辑与电路设计课程中，学生们会遇到一项具有挑战性的期末综合性实验——设计并实现一个自动售饮料机。这个实验旨在检验学生对数字逻辑、电路设计以及...
数据结构（初阶3.单链表）
最新发布
2401_83968713的博客
07-14 499
一、单链表1.1概念与结构1.2结点1.3链表的性质1.4链表的打印二、实现单链表SList.hSList.c申请新节点尾插头插尾删头删在指定位置之前插入数据在指定位置之后插入数据删除指定位置结点删除指定位置之后的结点销毁结点test.c。
数据结构【顺序表】
qq_67578580的博客
07-12 1209
我们需要创建一个seqlist.h头文件，seqlist.c文件存放函数，还有一个.c的测试文件。
数据结构之顺序表
m0_73634434的博客
07-10 430
线性表(List)由零个或多个数据组成的有限数列，线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表，链表，栈，队列，字符串。
SCAU OJ 数据结构 综合性实验
06-11
在SCAU OJ的综合性实验中，你会遇到各种复杂的数据结构问题，比如链表、树（如二叉搜索树、AVL树、红黑树等）、图、堆、队列、栈、哈希表、并查集、优先队列等。这些题目可能涉及基本操作（如查找、插入、删除），也...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值