阶段作业1 线性结构 编程题

最新推荐文章于 2022-10-28 23:00:10 发布
最新推荐文章于 2022-10-28 23:00:10 发布
阅读量639 收藏 4
点赞数 4
文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a924282761/article/details/127231549
版权

阶段作业1 线性结构 编程题

文章目录

【作业要求】

(1) 每个编程题均要求提交函数代码、测试代码及测试截图；

(2) 每组提交一份word文档。每个编程题要配备一个讲解视频。本次作业需提交1份word文档+6个讲解视频。如：线性结构作业.word，1.mp4，2.mp4等；

(3) 小组内每名成员至少完成2题，完成哪一题，就相应制作哪一题的讲解视频。

(4) 组长负责制。组长负责组织成员按时、按要求完成作业，负责提交作业。如遇到某个题目没有组员可以完成时，组长负责完成。

【说明】以下编程题可以使用实验课中给出的顺序表、单链表等相关实现文件。

  1. 在递增有序的顺序表中添加新接口bool ListInsert_Order(SqList &L, ElemType item)。实现插入新元素并保持有序性不变。说明你的算法的时间复杂度。（15分）

  2. 在单链表中添加接口Node * Find(Node *Head, int item)，实现在带头结点的单链表Head中查找值为item的结点，查找成功则返回其地址，如果不存在这样的结点，则返回NULL。 （10分）

  3. 单链表中添加接口实现删除单链表中所有与指定值相同的结点的功能。（20分）

  4. 编写函数，通过一趟遍历，将链表中所有结点的链接方向“原地”逆转，即利用原表的存储空间。说明此算法的空间复杂度。（20分）

  5. 编写函数，删除递增有序链表中值大于mink且小于maxk的所有元素（mink和maxk是给定的两个参数，其值可以与表中的元素相同，也可以不同 ）。（20分）

  6. 假设以I和O分别表示入栈和出栈操作。栈的初态和终态均为空，入栈和出栈的操作序列可表示为仅由I和O组成的序列，称可以操作的序列为合法序列，否则称为非法序列。（15分）

①下面所示的序列中哪些是合法的？

A. IOIIOIOO B. IOOIOIIO C. IIIOIOIO D. IIIOOIOO

②通过对①的分析，写出一个算法，判定所给的操作序列是否合法。若合法，返回true，否则返回false（假定被判定的操作序列已存入一维数组中）。

【第1题】

// NueXini
#include <iostream>
#include <cstdlib>
#include <ctime>

#define MaxSize 100
typedef int ElemType;

typedef struct
{
  int length;
  ElemType data[MaxSize];
} SqList;

//初始化顺序表
void InitList(SqList *&L)
{
  L->length = 0;
}

//输出线性表长度和元素
void ShowList(SqList *&L)
{
  std::cout << "表长度：" << L->length << "\n表元素：";
  for (int i = 1; i <= L->length; i++)
  {
    std::cout << L->data[i] << " ";
  }
  std::cout << std::endl;
}

//在有序表中加入一个数,使得表依然有序
bool InsertList(SqList *&L, ElemType insert)
{
  int i, j;
  if (L->length == MaxSize)
  {
    return false;
  }
  for (i = 0; i < L->length; i++)
  {
    if (insert >= L->data[i])
    {
      for (j = L->length; j >= i; j--)
        L->data[j + 1] = L->data[j]; // 结点后移
      L->data[i] = insert;
      L->length++;
      return 1;
    }
  }
  L->data[L->length++] = insert;
  return true;
}

int main()
{
  SqList *L = new SqList();
  InitList(L);
  ShowList(L);
  srand(time(0));
  for (size_t i = 0; i < 10; i++)
  {
    ElemType _a = rand() % 13;
    InsertList(L, i + _a);
  }
  ShowList(L);
  return 0;
}

【第2题】

// NueXini
#include <iostream>

typedef int ElemType;
typedef struct NNode
{
  ElemType data;
  struct NNode *next;
} Node;

void InitList(Node *&L)
{
  L->next = NULL;
}

void TraverseList(Node *L)
{
  Node *p = L->next;
  while (p)
  {
    std::cout << p->data << "  ";
    p = p->next;
  }
  std::cout << std::endl;
}

bool ListInsert(Node *L, int pos, ElemType item)
{
  Node *p = L;
  int i = 0;
  while (p && i != pos - 1)
  {
    p = p->next;
    i++;
  }
  if (p == NULL)
  {
    return false;
  }
  Node *t = new Node;
  t->data = item;
  t->next = p->next;
  p->next = t;
  return true;
}

Node *Find(Node *Head, ElemType item)
{
  {
    Node *p = Head->next;
    while (p && p->data != item)
    {
      p = p->next;
    }
    return p;
  }
}

int main()
{
  Node *a = new Node();
  InitList(a);
  for (size_t i = 0; i < 10; i++)
  {
    if (!ListInsert(a, i + 1, i))
    {
      std::cout << "false" << std::endl;
    }
  }
  TraverseList(a);
  std::cout << Find(a, 2) << std::endl;
  return 0;
}

【第3题】

leetcode: 203

// NueXini
#include <iostream>

typedef int ElemType;
typedef struct NNode
{
  ElemType data;
  struct NNode *next;
} Node;

void InitList(Node *&L)
{
  L->next = NULL;
}

void TraverseList(Node *L)
{
  Node *p = L->next;
  while (p)
  {
    std::cout << p->data << "  ";
    p = p->next;
  }
  std::cout << std::endl;
}

bool ListInsert(Node *L, int pos, ElemType item)
{
  Node *p = L;
  int i = 0;
  while (p && i != pos - 1)
  {
    p = p->next;
    i++;
  }
  if (p == NULL)
  {
    return false;
  }
  Node *t = new Node;
  t->data = item;
  t->next = p->next;
  p->next = t;
  return true;
}

Node *removeAllKeyItem(Node *L, ElemType item)
{
  if (L == NULL)
  {
    return L;
  }
  L->next = removeAllKeyItem(L->next, item);
  return L->data == item ? L->next : L;
}

int main()
{
  Node *a = new Node();
  InitList(a);
  for (size_t i = 0; i < 10; i++)
  {
    if (!ListInsert(a, i + 1, i))
    {
      std::cout << "false" << std::endl;
    }
  }
  for (size_t i = 0; i < 10; i++)
  {
    if (!ListInsert(a, i + 11, 2))
    {
      std::cout << "false" << std::endl;
    }
  }
  TraverseList(a);
  if (!removeAllKeyItem(a, 2))
  {
    std::cout << "false" << std::endl;
  }
  else
  {
    TraverseList(a);
  }

  return 0;
}

【第4题】

// NueXini
#include <iostream>

typedef int ElemType;
typedef struct NNode
{
  ElemType data;
  struct NNode *next;
} Node;

void InitList(Node *&L)
{
  L->next = NULL;
}

void TraverseList(Node *L)
{
  Node *p = L->next;
  while (p)
  {
    std::cout << p->data << "  ";
    p = p->next;
  }
  std::cout << std::endl;
}

bool ListInsert(Node *L, int pos, ElemType item)
{
  Node *p = L;
  int i = 0;
  while (p && i != pos - 1)
  {
    p = p->next;
    i++;
  }
  if (p == NULL)
  {
    return false;
  }
  Node *t = new Node;
  t->data = item;
  t->next = p->next;
  p->next = t;
  return true;
}

void ReverseList(Node *L)
{
  Node *q, *p = L->next;
  L->next = NULL;
  while (p)
  {
    q = p->next;
    p->next = L->next;
    L->next = p;
    p = q;
  }
}

int main()
{
  Node *a = new Node();
  InitList(a);
  for (size_t i = 0; i < 10; i++)
  {
    if (!ListInsert(a, i + 1, i))
    {
      std::cout << "false" << std::endl;
    }
  }
  TraverseList(a);
  ReverseList(a);
  TraverseList(a);
  return 0;
}

【第5题】

// NueXini
#include <iostream>

typedef int ElemType;
typedef struct NNode
{
  ElemType data;
  struct NNode *next;
} Node;

void InitList(Node *&L)
{
  L->next = NULL;
}

void TraverseList(Node *L)
{
  Node *p = L->next;
  while (p)
  {
    std::cout << p->data << "  ";
    p = p->next;
  }
  std::cout << std::endl;
}

bool ListInsert(Node *L, int pos, ElemType item)
{
  Node *p = L;
  int i = 0;
  while (p && i != pos - 1)
  {
    p = p->next;
    i++;
  }
  if (p == NULL)
  {
    return false;
  }
  Node *t = new Node;
  t->data = item;
  t->next = p->next;
  p->next = t;
  return true;
}

Node *removeRangeItem(Node *L, ElemType mink, ElemType maxk)
{
  if (L == NULL)
  {
    return L;
  }
  L->next = removeRangeItem(L->next, mink, maxk);
  if (L->data > mink && L->data < maxk)
  {
    return L->next;
  }
  else
  {
    return L;
  }
}

int main()
{
  Node *a = new Node();
  ElemType min = 2;
  ElemType max = 6;

  InitList(a);
  for (size_t i = 0; i < 10; i++)
  {
    if (!ListInsert(a, i + 1, i))
    {
      std::cout << "false" << std::endl;
    }
  }
  TraverseList(a);
  if (!removeRangeItem(a, min, max))
  {
    std::cout << "false" << std::endl;
  }
  else
  {
    TraverseList(a);
  }

  return 0;
}

【第6题】

/*
假设以 I 和 O 分别表示入栈和出栈操作。栈的初态和终态均为空，入栈和出栈的操作序列可表示为
仅有 I 和 O 组成的序列，可以操作的序列为合法序列，否则称为非法序列。如 IOIIOIOO、IIIOOIOO 是
合法的；而 IOOIOIIO、IIIOIOIO 不合法。写出一个算法，判定给定的操作序列是否合法。若合法则返回 1，
否则返回 0（假定被判定的操作序列已存入一维数组 char 型数组 ch[] 中，操作序列以 "\0" 为结束符）。
*/
#include <stdio.h>

/**
 * 顺序栈最大存储的元素个数
 */
#define MAXSIZE 100

/**
 * 顺序栈结构体定义
 */
typedef struct
{
  /**
   * 数据域，数组，用来存储栈中元素
   */
  char data[MAXSIZE];
  /**
   * 指针域，表示栈顶指针，实际上就是数组下标
   */
  int top;
} SeqStack;

/**
 * 初始化顺序栈，即将栈顶指针指向 -1 表示空栈
 * @param stack 顺序栈
 */
void init(SeqStack *stack)
{
  // 设定让栈顶指针指向 -1 表示为栈空
  stack->top = -1;
}

/**
 * 判断顺序栈是否为空
 * @param stack 顺序栈
 * @return 如果顺序栈为空则返回 1，否则返回 0
 */
int isEmpty(SeqStack stack)
{
  // 只需要判断栈顶指针是否等于 -1 即可，如果是空栈则返回 1，不是空栈则返回 0
  if (stack.top == -1)
  {
    return 1;
  }
  else
  {
    return 0;
  }
}

/**
 * 将元素入栈
 * @param stack 顺序栈
 * @param ele 元素值
 * @return 如果栈满则返回 0 表示入栈失败；如果插入成功则返回 1
 */
int push(SeqStack *stack, char ele)
{
  // 1.参数校验，如果栈满则不能入栈元素
  if (stack->top == MAXSIZE - 1)
  {
    // 如果栈满，则返回 0，表示不能入栈
    return 0;
  }
  // 2.先将栈顶指针加一，指向新空数组位置
  stack->top++;
  // 3.将新元素值填充到新位置中
  stack->data[stack->top] = ele;
  return 1;
}

/**
 * 将元素出栈
 * @param stack 顺序栈
 * @param ele 用来保存出栈的元素
 * @return 如果栈空则返回 0 表示出栈失败；否则返回 1 表示出栈成功
 */
int pop(SeqStack *stack, char *ele)
{
  // 1.参数校验，栈空不能出栈
  if (stack->top == -1)
  {
    // 栈空，没有元素可出栈
    return 0;
  }
  // 2.用 ele 来保存顺序栈栈顶元素
  *ele = stack->data[stack->top];
  // 3.然后栈顶指针减一，表示出栈一个元素
  stack->top--;
  return 1;
}

/**
 * 获取栈顶元素，但不出栈
 * @param stack 顺序栈
 * @param ele 用来保存出栈元素
 * @return 如果栈空则返回 0 表示出栈失败；否则返回 1 表示出栈成功
 */
int getTop(SeqStack stack, char *ele)
{
  // 1.参数校验，如果栈空则不能出栈
  if (stack.top == -1)
  {
    // 栈空，没有元素可出栈
    return 0;
  }
  // 2.保存栈顶元素返回
  *ele = stack.data[stack.top];
  return 1;
}

/**
 * 判断指定操作序列是否合法
 * @param options 操作序列数组，由 I 和 O 组成
 * @param n 数组长度
 * @return 如果操作序列合法则返回 1，否则返回 0 表示不合法
 */
int isLegal(char options[], int n)
{
  // 0.声明栈并初始化栈，用来作为解题的辅助数据结构
  SeqStack stack;
  init(&stack);

  // 1.遍历字符数组 options 中所有字符
  for (int i = 0; i < n; i++)
  {
    // 局部变量，记录当前的数组元素
    char c = options[i];
    // 1.1 如果是 I 操作，则将其入栈
    if (c == 'I')
    {
      push(&stack, c);
    }
    // 1.2 如果是 O 操作，则需要根据不同情况进行处理
    else if (c == 'O')
    {
      // 1.2.1 如果是空栈，则表示此时 O 操作比 I 操作，那么一定不合法，返回 0
      if (isEmpty(stack))
      {
        return 0;
      }
      // 1.2.2 如果不是空栈，则将栈顶元素出栈，即 O 操作与 I 操作相互抵消一次
      else
      {
        char top;
        pop(&stack, &top);
      }
    }
  }

  // 2.循环结束后，判断栈中是否还有元素，如果还有元素则表示 I 操作比 O 操作多，不合法；如果栈空则表示合法
  if (isEmpty(stack))
  {
    return 1;
  }
  else
  {
    return 0;
  }
}

/**
 * 判断指定操作序列是否合法
 * @param options 操作序列数组，由 I 和 O 组成
 * @param n 数组长度
 * @return 如果操作序列合法则返回 1，否则返回 0 表示不合法
 */
int isLegal2(char options[], int n)
{
  int i = 0; // 表示 I 操作的个数
  int o = 0; // 表示 O 操作的个数

  for (int m = 0; m < n; m++)
  {
    if (options[m] == 'I')
    {
      i++;
    }
    else if (options[m] == 'O')
    {
      o++;
      // 如果出栈操作 O 的次数大于入栈操作 I 的次数，那么必然不是合法序列
      if (o > i)
      {
        return 0;
      }
    }
  }

  // 扫描完成后，比较 i 和 o 的次数，如果相等则表示序列合法，否则表示 I 操作的次数大于 O 操作的次数则不合法
  if (i != o)
  {
    return 0;
  }
  else
  {
    return 1;
  }
}

int main()
{
  int result;

  char arr1[] = "IOIIOIOO";
  int n1 = 8;
  result = isLegal(arr1, 8);
  printf("%s 是否是合法的操作序列：%d\n", arr1, result);

  char arr2[] = "IIIOOIOO";
  int n2 = 8;
  result = isLegal(arr2, 8);
  printf("%s 是否是合法的操作序列：%d\n", arr2, result);

  char arr3[] = "IOOIOIIO";
  int n3 = 8;
  result = isLegal(arr3, 8);
  printf("%s 是否是合法的操作序列：%d\n", arr3, result);

  char arr4[] = "IIIOIOIO";
  int n4 = 8;
  result = isLegal(arr4, 8);
  printf("%s 是否是合法的操作序列：%d\n", arr4, result);
}

enjoy it ~

NueXini
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
浙大PTA 编程题 02-线性结构4 Pop Sequence
lzyhhhhh的博客
06-16 372
思路： 模拟堆栈输入输出，先存入第一个数据1，然后比较这个数据和用户要验证而输入的数据的第一个数据是否相等，相等则输出，然后再存入第二个数据2，以此类推，不相等则不输出直接存入。 这种方法存在两种情况，第一种是堆栈 ...
大二数据结构作业，习题
03-01
1. 链表：链表是一种动态数据结构，它的元素（节点）不按照线性顺序存储在内存中，而是通过指针相互链接。链表分为单向链表、双向链表和循环链表等类型。学习链表时，我们需要理解节点的构成（包括数据部分和指针...
弗兰西刷题日记-剑指offer-09-两个栈实现队列
尽人事，听天命
10-16 110
import java.util.*; class CQueue { private Stack<Integer> stack1; private Stack<Integer> stack2; public CQueue() { stack1 = new Stack<>(); stack2 = new Stack<>(); } public void appendTail(in
数据结构（二）线性结构 —— 编程作业 04 ：Pop Sequence
大彤小忆的博客
05-26 1779
  题目描述： 给定一个最多能保存M个数的堆栈。按1,2,3,…,N的顺序使得N个数字入栈，然后随机弹出，判断给定的数字序列是否可能是堆栈的pop序列。例如，如果M为5，N为7，我们可以从堆栈中得到1、2、3、4、5、6、7，但不能得到3、2、1、7、5、6、4。   输入格式： 每个输入文件包含一个测试用例。对于每种情况，第一行包含3个数字(都不超过1000)：M(堆栈的最大容量)、N (push序列的长度)和K(需要检查的pop序列的数量)。         然后是K行，每一行包含N个数字的pop序列
02-线性结构3-Reversing Linked List-编程题
Aruasg的博客
03-23 133
01-复杂度3-二分查找-函数题解题代码测试结果问题整理 解题代码 #include<stdio.h> #include<stdlib.h> typedef struct Array array; struct Array { int expon; int next; }; int main() { array a[100000]; int i, j, head, ...
02-线性结构4-Pop Sequence-编程题
Aruasg的博客
03-19 140
02-线性结构4-Pop Sequence-编程题解题代码测试结果问题整理 解题代码 #include<stdio.h> #include<stdlib.h> int main() { int M, N, num, i, j, l, k, isFirst = 1, *pstack, last; scanf("%d %d %d", &M, &N, &amp...
北京交通大学数据结构课件及习题
10-03
在这些基础知识之上，数据结构的学习还包括排序算法（如冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序等）和搜索算法（如线性搜索、二分搜索、广度优先搜索、深度优先搜索等）。理解这些算法的工作原理...
作业1.zip
最新发布
09-21
在解压并打开“作业1”后，我们可能会遇到具体的编程问题、逻辑分析题或是系统设计题目。通过解决这些问题，学生不仅可以巩固已学知识，还能培养解决问题的能力和创新思维。 总结来说，“作业1.zip”尽管看似简单，...
算法课程oj习题作业答案
07-06
这些文件名揭示了多个计算机科学和编程相关的算法知识点，主要涉及数据结构和算法设计策略。以下是对这些知识点的详细说明： 1. **分治法**： 分治法是一种常用的算法设计策略，它将大问题分解为若干个相同或相似...
清华大学本科数据结构ppt+作业
11-04
这份资料包含清华大学本科阶段的数据结构课程PPT和作业，对于想要深入理解和掌握数据结构的人来说是一份宝贵的资源。 1. **数据结构基本概念**：数据结构是数据的逻辑组织形式，包括数组、链表、栈、队列、树、图等...
线性结构总结和习题( 数据结构 )
06-16
对线性结构的总结，数据结构学习的很多资料，希望对大家有用
数据结构编程题目及答案
08-08
大学数据结构编程题目及答案 如下：1.写出在顺序存储结构下将线性表逆转的算法，要求使用最少的附加空间。 解：输入：长度为n的线性表数组A(1:n) 输出：逆转后的长度为n的线性表数组A(1:n)。 C语言描述如下（其中ET为数据元素的类型）......
数据结构---编程题 线性结构03
不停
10-07 145
#include<stdio.h> #include<iostream> #define MaxSize 100005 using namespace std; int main(){ int Data[MaxSize]; int Next[MaxSize]; int list[MaxSize]; int FirstAdd,N,K; scanf("%d %d %d...
数据结构（二）线性结构 —— 编程作业 01 ：两个有序链表序列的合并
大彤小忆的博客
05-25 2026
  本题要求实现一个函数，将两个链表表示的递增整数序列合并为一个非递减的整数序列。   函数接口定义： List Merge( List L1, List L2 );   其中List结构定义如下： typedef struct Node *PtrToNode; struct Node { ElementType Data; /* 存储结点数据 */ PtrToNode Next; /* 指向下一个结点的指针 */ }; typedef PtrToNode List; /* 定义单链表
数据结构（二）线性结构 —— 编程作业 03 ：Reversing Linked List
大彤小忆的博客
05-25 1704
  题目描述： 给定一个常数K和一个单链表L，把L上所有K个元素的链接都颠倒过来。例如，给定L为1→2→3→4→5→6，如果K=3，那么输出3→2→1→6→5→4；如果K=4，输出4→3→2→1→5→6。   输入格式： 每个输入文件包含一个测试用例。对于每种情况，第一行包含第一个结点的地址，结点的总数为NNN(⩽105\leqslant10^{5}⩽105)，要反转的子列表的长度为K(⩽N\leqslant N⩽N)。结点的地址为5位非负整数，NULL用-1表示。         接着是NNN行，每一行描
线性结构
Smile_Mr的博客
01-21 719
线性结构 1、顺序表 在程序中，经常需要将一组（通常是同为某个类型的）数据元素作为整体管理和使用，需要创建这种元素组，用变量记录它们，传进传出函数等。一组数据中包含的元素个数可能发生变化（可以增加或删除元素）。 对于这种需求，最简单的解决方案便是将这样一组元素看成一个序列，用元素在序列里的位置和顺序，表示实际应用中的某种有意义的信息，或者表示数据之间的某种关系。 这样的一组
线性表的完整操作
你的天堂，我的地狱
02-19 836
插入操作会改变原有链表，所以要用地址传递。函数设计如下： /* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */ /* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */ Status ListInsert(SqList *L,int i,ElemType e) { int k; if (L->length=MAXSIZE)/* 顺序线性表已经满 *
C语言！！能跑的！！！数据结构(C语言第2版) 课后习题答案之 第三章 栈和队列算法设计题C语言版
picktheshy的博客
10-28 1030
/栈顶和栈底指针//栈数组int m;//栈最大可容纳元素个数}DblStackint m;return 1;printf("栈号输入不对");return 0;printf("栈已满");return 0;break;printf("栈号输入错误");return 0;printf("栈号输入错误");return 0;printf("栈空");return 0;
习题2.4 递增的整数序列链表的插入
weixin_51929568的博客
04-11 487
函数接口定义： List Insert( List L, ElementType X ); 其中List结构定义如下： typedef struct Node *PtrToNode; struct Node { ElementType Data; /* 存储结点数据 */ PtrToNode Next; /* 指向下一个结点的指针 */ }; typedef PtrToNode List; /* 定义单链表类型 */ L是给定的带头结点的单链表，其结点存储的数据是递增有序的；函数Ins
数据结构与算法：线性结构练习题解析
"该资源是一份关于数据结构中线性结构的课后复习练习，包含多项选择题和填空题，涉及线性表的顺序存储结构、插入操作的平均移动次数、有序表的折半搜索以及程序执行次数的计算。" 在数据结构中，线性结构是一种基本...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值