计算机考研_顺序表相关题目

最新推荐文章于 2022-09-14 20:40:44 发布
最新推荐文章于 2022-09-14 20:40:44 发布
阅读量431 收藏 4
点赞数 2
文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Boring_Firecar/article/details/116092232
版权

题目来自摘自《22王道考研的数据结构》， 仅用作本人复习参考用

题目1

  1. 从顺序表中删除具有最小值的元素(假设唯一), 并由函数返回被删元素的值.空出的位置由最后一个
    元素填补, 若顺序表为空,则显示出错信息并退出运行.
bool Del_Min(SqList &L, ElemType &value)
{
    if(!L.length) 
    {
        printf("error msg");
        return false;
    }

    int pos = 0;
    int min = L.data[0];
    for(int i = 0; i < L.length; ++i)
        if(min > L.data[i]) pos = i, min = L.data[i];

    value = min;
    if(pos != L.length - 1) L.data[pos] = L.data[L.length - 1];   // 这里的if可以不必进行判断,因为就算是最后一个元素,也会在下面--中被删除.
    L.length--;
    return true;
}

题目2

  1. 设计一个高效的算法,将顺序表L的所有元素逆置,要求算法的空间复杂度为O(1).
void Reverse(sqList &L)
{
    int i = 0, j = L.length - 1;
    while(j > i)
        swap(L.data[i++], L.data[j--]);
}

题目3

  1. 对长度为n的顺序表L,编写一个时间复杂度为O(n),空间复杂度为O(1)的算法,该算法删除线性表中所有值为x的数据元素 */
void del_x_1(Sqlist &L, Elemtype x)                       // 解法1   直接删除法
{
    int k = 0;
    for(int i = 0; i < L.length; ++i)   
        if(L.data[i] != x) L.data[k++] = L.data[i];
    L.length = k;
}


void del_x_2(Sqlist &L, Elemtype x)                      // 解法2    构建法 
{
    int k = 0;
    for(int i = 0; i < L.length; ++i)
        if(L.data[i] != x) L.data[i - k] = L.data[i];
        else ++k;
    L.length = L.length - k;
}

题目4

  1. 从有序顺序表删除其值在给定值s与t之间(要求s < t)的所有元素, 若s或t不合理或顺序表为空,则显示出错信息并退出运行

//注意:这里s和t不一定是顺序表中的元素, 只是给定的这个范围.

bool fun(Sqlist &L, Elemtype s, Elemtype t)
{
    int i, j;
    if(s >= t || !L.length) return false; 
    for(i = 0; i < L.length && L.data[i] < s; ++i);   // 寻找大于等于s的第一个元素. 
    if(i > L.length) return false;
    for(j = i; j < L.length && L.data[j] <= t; ++j);  // 寻找大于t的第一个元素
    while(j < L.length)  L.data[i++] = L.data[j++];
    L.length = i;
    return true;
}

题目5

  1. 从顺序表中删除其值在给定值s与t之间(包含s和t, 要求s<t)的所有元素,若s或t不合理或顺序表为空,则显示错误并退出 */
bool fun(Sqlist &L, Elemtype s, Elemtype t)
{
    if(!L.length || s >= t) return false;

    int k = 0;
    for(int i = 0; i < L.length; ++i)
        if(L.data[i] < s || L.data[i] > t) L.data[k++] = L.data[i];

    L.length = k;
    return true; 
}

题目6

  1. 从有序顺序表中删除所有其值重复的元素, 使表中所有元素均不相同(Lc26)*/
bool fun(Sqlist &L)
{
    if(!L.length) return false;
    int k = 0;

    for(int i = 0; i < L.length; ++i)
        if(!k || L.data[i] != L.data[k - 1]) L.data[k++] = L.data[i];
    L.length = k;
}

题目7

  1. 将两个有序顺序表合并为一个新的有序顺序表, 并由函数返回结果顺序表 */
Sqlist Merge(Sqlist &L1, Sqlist &L2)
{
    Sqlist L;
    int n1 = 0, n2 = 0, l_n = 0;

    while(n1 < L1.length && n2 < L2.length)
    {
        if(L1[n1] < L2[n2]) L[l_n++]  = L1[n1++];
        else  L[l_n++] = L2[n2++];
    }

    while(n1 < L1.length)  L[l_n++] = L1[n1];
    while(n2 < L2.length)  L[l_n++] = L2[n2];
    L.length = l_n;
    return L;
}

题目8

  1. 已知在一维数组A[m+n]中依次存放两个线性表(a1,a2,a3,…,am)和(b1,b2,b3,…,bn).试编写一个函数,将数组中两个顺序表的位置互换, 即将(b1,b2,b3,…,bn)放到(a1,a2,a3,…,am)的前面 .

相关题目: Acwing 77. 翻转单词顺序

void Reverse(int *Arr, int l, int r)
{
    int i = l, j = r;
    while(i < j) swap(Arr[i++], Arr[r--]);
}

void fun(int *arr, int m, int n)
{
    Reverse(arr, 0, m + n - 1);
    Reverse(arr, 0, n - 1);
    Reverse(arr, n, m + n - 1);
}

题目9

  1. 线性表(a1,a2,a3,…,an)中的元素递增有序切按顺序存储于计算机内.要求设计一个算法,完成用最少时间在表中查找数值为x的元素, 若找到,则将其与后继元素位置相交换, 若找不到则将其插入表中并使表中顺序仍然递增有序 */
void fun(Sqlist &L, Elemtype x)
{
    int l = 0, r = L.length - 1;

    if(x > L.data[r])                       // 特判, 若此时比最大一个元素大, 直接插入最后 
    {
        L.data[r + 1] = x;
        L.length++;
        return;
    }

    while(r > l)                             // 二分查找找到第一个大于等于x的元素 
    {
        int mid = (l + r) / 2;
        if(L.data[mid] >= x) r = mid;
        else l = mid + 1;
    }

    if(L.data[l] == x)                        // 找到
    {
        if(l == L.length - 1) return;          // 最后一个元素并无后继 
        swap(L.data[l], L.data[l + 1]);
    }
    else         // 找不到
    {
        for(int i = L.length; i > l; --i)  L.data[i] = L.data[i - 1];
        L.data[l] = x;
        L.length++;
    }
}

//关于二叉树
//二叉树的创建以及递归和非递归遍历
#include <iostream>
#include<iomanip>
#include<stack>
using namespace std;
typedef char TElemtType;

//二叉树的二叉链表存储表示
typedef struct BiTNode
{
    TElemtType data;          //结点数据域
    struct BiTNode *lchild,*rchild;   //左右孩子指针
}BiTNode,*BiTree;

//先序创建二叉树
void CreateBiTree(BiTree &T)
{
    //按先序次序输入二叉树中结点的值（一个字符,创建二叉链表表示树T
   TElemtType ch;
   cin>>ch;
   if(ch=='#') T=NULL;      //递归结束，建空树
   else
   {
       T=new BiTNode;
       T->data=ch;        //生成根结点
       CreateBiTree(T->lchild);   //递归创建左子树
       CreateBiTree(T->rchild);   //递归创建右子树
   }
}
//二叉树的递归和非递归遍历
//先序递归遍历
void PreOrderTraverse(BiTree T)
{
    if(T)
    {
        cout<<setw(4)<<T->data;
        PreOrderTraverse(T->lchild);
        PreOrderTraverse(T->rchild);
    }
}
//先序非递归遍历
void PreOrder(BiTree T)
{
    stack<BiTree>S;
    BiTree p,q;
    p=T;
    q=new BiTNode;
    while(p||!S.empty())
    {
        if(p)          //p非空指针进栈，输出根结点，遍历左子树
        {
            cout<<setw(4)<<p->data;
            S.push(p);
            p=p->lchild;
        }
        else           //p空指针退栈，遍历右子树
        {
            q=S.top();
            S.pop();
            p=q->rchild;
        }
    }
}
//中序递归遍历
void InOrderTraverse(BiTree T)
{
    if(T)
    {
        InOrderTraverse(T->lchild);
        cout<<setw(4)<<T->data;
        InOrderTraverse(T->rchild);
    }
}
//中序非递归遍历
void InOrder(BiTree T)
{
    stack<BiTree>S;
    BiTree p,q;
    p=T;
    q=new BiTNode;
    while(p||!S.empty())
    {
        if(p)      //p非空指针进栈，遍历左子树
        {
            S.push(p);
            p=p->lchild;
        }
        else       //p空指针进栈，访问根节点，遍历右子树
        {
            q=S.top();
            S.pop();
            cout<<setw(4)<<q->data;
            p=q->rchild;
        }
    }
}
//后序递归遍历
void PostOrderTraverse(BiTree T)
{
    if(T)
    {
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        cout<<setw(4)<<T->data;
    }
}
//后序非递归遍历
void PostOrder(BiTree T)
{
    if(T==NULL)
        return;
    stack<BiTree>S;
    BiTree pCur,pLastVisit;
    //pCur :当前访问结点 pLastVisit:上次访问结点
    pCur=T;
    pLastVisit=NULL;
    //先把pCur移到左子树最下边
    while(pCur)
    {
        S.push(pCur);
        pCur=pCur->lchild;
    }
    while(!S.empty())
    {
        //走到这里，pCur都是空，并且已经遍历到左子树低底（看成扩充的二叉树，则空，也是某棵树的左孩子）
        pCur=S.top();
        S.pop();
        //一个根结点被访问的前提是 ，该结点无右子树或者右子树已经北方问过
        if(pCur->rchild==NULL||pCur->rchild==pLastVisit)
        {
            cout<<setw(4)<<pCur->data;
            //修改最近被访问的结点
            pLastVisit=pCur;
        }
            /*这里的else可以换成带条件的else if
            else if(pCur->lchild==pLastVisit) 若左子树刚刚被访问过，则需要先进入右子树(根结点需要再次入栈)*/
        else
        {
            //根结点再次入栈
            S.push(pCur);
        //进入右子树，且可以肯定右子树一定不为空
            pCur=pCur->rchild;
            while(pCur)
                {
                    S.push(pCur);
                    pCur=pCur->lchild;
                }
        }
    }
}
//层序遍历
void LevelTraverse(BiTree T)
{
    queue<BiTree>Q;
    Q.push(T);
    while(!Q.empty())
    {
        T=Q.front();
        Q.pop();
        cout<<setw(4)<<T->data;
        if(T->lchild)
            Q.push(T->lchild);
        if(T->rchild)
            Q.push(T->rchild);
    }
}

//非递归程序判断一个二叉树是否是完全二叉树
void IsCompleteTree(TreeNode* root)
{
    queue<TreeNode*>que;
    bool falg;//标志，判断层次遍历之后到该结点是否还能有子节点，true表示之后不能有子节点了
    TreeNode* tmp;
    que.push(root);
    while(!que.empty())
    {
        tmp=que.front();
        que.pop();
        if(flag&&tmp->lChild||tmp->rChild)
            return false;
        if(tmp->lChild)
            que.push(tmp->lChild);
        else
            flag=true;
        if(tmp->rChild)
        {
            if(flag)
                return false;
            else
                que.push(tmp->rChild);
        }
        else
            flag=true;
    }
    return true;
}

//计算叶子结点的个数
int leafCount=0;
void LeafCountBinaryCount(Node *node)
{
    if(node==NULL)
    {
        return ;
    }
    if(node->lChild==NULL&&node->rChild==NULL)
    {
        leafCount++;
    }
    LeafCountBinaryCount(node->lChild);
    LeafCountBinaryCount(node->rChild);
    return ;
}


//计算二叉树高度
int depth(TreeNode* root)
{
    if(!root)
        return 0;
    int left=depth(root->left);
    int right=depth(root->right);
    return max(left,right)+1;
}


//非递归求二叉树的高度


// 交换二叉树根结点的左右子树
TreeNode* InvertTree(TreeNode* root)
{
    if(!root)
        return NULL;
    TreeNode* temp_left=root->left;//保护现场，防止root->left修改后丢失
    root->left=InvertTree(root->right);
    root->right=InvertTree(temp_left);
    return root;
}


// 求解给定关键字在二叉树中所在层数
int searchBST(TreeNode* root,int val)
{
    int num=0;
    while(root)
    {
        num++;
        if(root->val==val)
            return num;
        else if(root->val>val)
        {
            if(!root->left)
                return 0;
            root=root->left;
        }
        else
        {
            if(!root->right)
                return 0;
            root=root->right;
        }
    }
    return 0;
}

// 计算二叉树的最大宽度
int treeWidth(BTNode *root)
{
    if(root==NULL)
        return 0;
    int nLastLevelWidth=0;//记录上一层的宽度
    int nCurLevelWidth=0;//记录当前层的宽度

    queue<BTNode*>Q;
    Q.push(root);//将根结点入队列
    int nWidth=1;//二叉树的宽度
    nLastLevelWidth=1;
    BTNode *pCur=NULL;
    while(!Q.empty())
    {
        while(nLastLevelWidth!=0)//nLastLevelWidth代表上一层的宽度，控制上一层所有结点的孩子进队
        {
            pCur=Q.front();//取出对头元素
            Q.pop();

            if(pCur->left!=NULL)
                Q.push(pCur->left);
            if(pCur->right!=NULL)
                Q.push(pCur->right);
            nLastLevelWidth--;
        }
        nCurLevelWidth=Q.size();//此时也是上一层所有的结点个数
        nWidth=nCurLevelWidth>nWidth?nCurLevelWidth:nWidth;
        nLastLevelWidth=nCurLevelWidth;
    }
    return nWidth;
}

// 将一棵二叉树自下向上，从右往左遍历输出
void InvertLevel(BTNode* root)
{
    stack<BTNode*>S;
    Queue<BTNode*>Q;
    BTNode* pCur;
    if(root!=NULL)
    {
         Q.push(root);  //树不空，根结点进队
         while(!Q.empty())  //队不空
         {
             pCur=Q.front(); //出队，进栈
             Q.pop();
             S.push(pCur);
             if(pCur->lChild)   //子女不空，就入队
                Q.push(pCur->lChild);
             if(pCur->rChild)
                Q.push(pCur->rChild);
         }
         while(!S.empty())
         {
             pCur=S.top();
             S.pop();
             cout<<pCur->data<<'\t';
         }
    }
}


// 计算一棵给定二叉树的所有的双分支结点的个数
int dsonNodes(TreeNode* root)
{
    if(root==NULL)
        return 0;
    else if(root->lChild!=NULL&&root->rChild!=NULL)
        return dsonNodes(root->lChild)+dsonNodes(root->rChild)+1;
    else
        return dsonNodes(root->lChild)+dsonNodes(root->rChild);
}

//将给定的表达式二叉树转换为等价的中缀表达式
// 算法思想：除根结点和叶子结点外，遍历到其他结点时再遍历左子树之前加上括号，遍历完右子树加上括号
void BiTreeExp(TreeNode* root)
{
   BiTreeToExp(root,1);//根的高度为1
}
void BiTreeToExp(TreeNode* root,int depth)
{
    if(root==NULL)
        return;  //空结点返回
    else if(root->left==NULL&&root->right==NULL) //若为叶子结点
        cout<<root->data;       //输出操作数，不加括号
    else
    {
        if(deep>1)    //若又子表达式则加1层括号
            cout<<'(';
        BiTreeToExp(root->left,deep+1);
        cout<<root->data; //输出操作符
        BiTreeToExp(root->right,deep+1);  //若又子表达式则加1层括号
        if(deep>1)
            cout<<')';
    }
}
Boring_Firecar
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线性表相关问题
Gakki_qaq的博客
02-01 730
1.顺序存储定义 线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。 线性表（a1,a2,......,an）的顺序存储示意图如下： a1 a2 ... ai-1 ai ... an 2.顺序存储方式 线性表的顺序存储结构，说白了，和刚才的例子一样，就是在内存中找了块地儿，通过占位的形式，把一定内存空间给占了，然后把相同
数据结构——线性表系列问题
m0_63024980的博客
11-08 492
【代码】数据结构——线性表系列问题。
数据结构学习笔记（四）--关于线性表的一个小疑问
Qin_xian_shen的博客
09-19 408
int LocateElem_Sq(Sq_List L,ElemType e,Status(*compare)(ElemType,ElemType)) { int index = -1; // 没找到，返回-1；从0下标开始 Sql_List *ptr = &L; // 用于遍历的指针 while(ptr->next != NULL) // 停止遍历条件
线性表相关知识
qq_62898723的博客
06-23 134
数据结构
线性表10个问答
weixin_40458609的博客
10-26 453
线性表10个问答
N诺计算机考研机试攻略.rar
04-08
《N诺计算机考研机试攻略》是一份专为准备计算机考研机试的考生精心编纂的参考资料，旨在帮助考生在这一关键环节取得高分甚至满分。这份资源包含两部分：《计算机考研机试攻略 - 高分篇.pdf》和《计算机考研机试攻略...
计算机考研专业计算机考研专业课真题课真题
最新发布
01-29
计算机考研专业课真题主要考察了考生对计算机基础知识的掌握程度，涵盖了数据结构、操作系统、计算机组成原理等多个核心领域。以下是对题目涉及知识点的详细解释： 1. **栈的性质**：第一题和第二题涉及到栈的先进...
计算机考研408历年真题总结版
07-14
计算机考研408历年真题总结版是一份珍贵的学习资源，专门为准备计算机专业研究生入学考试（简称考研）的考生提供。这个压缩包包含了从2009年至2016年间，每年全国研究生考试计算机统考的数据结构部分的试题及答案，...
2013年计算机考研真题.docx
12-06
以上是对2013年计算机考研真题的部分内容的分析，涉及的知识点包括链表操作、栈的性质、平衡二叉树、三叉树、后序线索二叉树、二叉排序树、图的遍历、项目进度管理、B树、基数排序和浮点数表示。
历年云南大学计算机考研复试(整理).doc
11-15
"云南大学计算机考研复试题库" 云南大学计算机考研复试是一个重要的考试环节，对考生来说是一个挑战和考验。本资源汇总了云南大学历年计算机考研复试题，涵盖计算机软件与理论专业和计算机应用技术专业两个方向，...
博客作业2---线性表
weixin_30919429的博客
03-25 175
一、PTA实验作业 1.题目1：7-1 最长连续递增子序列 2. 设计思路（伪代码或流程图） 定义变量n存放顺序表长度,i,j=0控制循环,l=1存放子列长度,k,m,max存放最大子列长度,flag存放最长子列数组下标,sum=0求和; scanf("%d",&n); int a[n]存放母列 ，b[100000] 存放子列长度 for i=0 to n ...
7折半查找法
qq_43189330的博客
03-07 306
题目 线性表（a1,a2,a3…an）中的元素递增有序且按顺序存储于计算机内。 要求，设计一个算法，完成用时最少时间在表中查找数值为x的元素，若找到，则将其与后继元素位置相交换，若找不到 则将其插入表中并使表中元素任递增有序 算法思想：顺序存储的线性表递增有序，可以顺序查找，也可以折半查找。题目要求“用最少的时间在表中查找数值为X的元素” 应该用折半查找 #include<stdio.h> typedef int ElemType; void SearchExchangeInsert(Elem
已知在一维数组A[m+n]中依次存放两个线性表（a1,a2,a3,...,am）和（b1,b2,b3,...,bn）。试编写一个函数，将数组中两个顺序表的位置互换，即将线性表b放在线性表a前
qq_43687652的博客
03-25 1553
算法思想： 先将数组A[m+n]中的全部元素（a1,a2,a3,…,am,b1,b2,b3,…,bn）原地逆置为（bn,…,b3,b2,b1,am,…,a3,a2,a1），再对前n个元素和后m个元素分别使用逆置算法，即可得到（b1,b2,b3,…,bn,a1,a2,a3…,am），从而实现顺序表的位置互换。 本题代码如下： .........
【顺序表】从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删元素的值。空出的位置由最后一个元素填补，若顺序表为空，则显示出错信息并退出运行。
帅小柏的博客
07-06 514
从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删元素的值。空出的位置由最后一个元素填补，若顺序表为空，则显示出错信息并退出运行。
2.2.8 已知在一维数组A[m + n]中依次存放两个线性表（a1, a2, a3, a4....am）与（b1, b2, b3...bn）。试写函数将两顺序表的位置互换
weixin_45837835的博客
03-30 1803
已知在一维数组A[m + n]中依次存放两个线性表（a1, a2, a3, a4…am）与（b1, b2, b3…bn）。试写函数将两顺序表的位置互换，即将（b1, b2, b3…bn）放在（a1, a2, a3, a4…am）前面 思路1：既然是数组，我想的是把数组元素对换，比如：A[0]（a1）与A[m]（b1）对换，但这样就要考虑一对一对调之后就会有元素剩下的情况 思路2：把bn元素一个个插到a1前面，这样太麻烦了 思路3（参考算法思想）： void Reverse(DataType A[],in
已知一维数组A[M+N]中依次存放两个线性表（a1,a2,a3,a4....an与b1,b2,b3...bn）试写函数将两顺序表的位置互换
weixin_42803102的博客
05-13 7289
已知一维数组A[M+N]中依次存放两个线性表（a1,a2,a3,a4....an与b1,b2,b3...bn）试写函数将两顺序表的位置互换，即将b1,b2,b3...bn放在a1,a2,a3,a4....an前面 刚看这个题，想的第一种算法是 先将M，N进行比较，如果M大，则将b顺序表前移到表头 即 a1 a2 a3…an b1 b2 b3…bn 变成 b1 b2 b3…bn a(n+1) a...
实验一 线性表的顺序存储与实现_每日算法训练线性表(二)
weixin_39601657的博客
11-23 209
第一题从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不同。算法思想：注意是有序顺序表，值相同的元素一定在连续的位置上，用类似于直接插入排序的思想，初始时将第一个元素视为非重复的有序表。之后依次判断后面的元素是否与前面非重复有序表的最后一个元素相同。若相同则继续向后判断，若不同则插入到前面的非重复有序表的最后。直至判断到表尾为止。输入数据: {1,2,4,7,9,11,11,2...
王道2019数据结构第二章线性表综合应用题笔记
菜菜的博客
04-20 1282
#include using namespace std; #define MAXSIZE 50 typedef int ElemType; typedef struct { ElemType data[MAXSIZE]; int length; }SqList; //1、从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删除的元素的值，空出的位置由最后一个元素填补，若顺序表为空则
第二章 线性表作业
qq_45233034的博客
09-14 295
1、从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删除元素的值，空出的位置由最后一个元素填补，若顺序表为空，则显示出错并退出程序。5、从顺序表中删除其值在给定值s与t之间(包含s和t，要求s
2013年计算机考研真题与答案解析：降序链表合并
"2013年计算机考研真题及答案完整版，包含了计算机科学与技术学科联考的408计算机学科专业基础综合试题，包括...这些题目覆盖了计算机科学的基础知识，对于准备计算机考研的学生来说，这些都是需要理解和掌握的关键点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值