2024王道数据结构 大题01-线性表的顺序存储

于 2023-09-05 16:58:19 发布
阅读量108 收藏
点赞数
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53294028/article/details/132696120
版权 
//
// Created by Yue on 2023-08-31.
//

#ifndef INC_2_2_1_SQLLIST_H
#define INC_2_2_1_SQLLIST_H

#define MaxSize 50
typedef  int ElemType;
typedef struct {
    ElemType data[MaxSize];
    int length;
}SqlList;

// 插入一个新元素e, i 为位序
bool ListInsert(SqlList &L,int i, ElemType e)
{
    if(i < 1 || i>L.length+1){
        return false;
    }
    if (L.length >= MaxSize){
        return false;
    }
    // 依次往后移动元素
    for(int j=L.length;j>=i;j--){
        L.data[j] = L.data[j-1];
    }
    L.data[i-1] = e;
    L.length++;
    return true;
}

// 删除操作,给定位序i,删除对应位序i上的元素，并用e将值带回来
bool ListDelete(SqlList &L,int i,ElemType &e){
    if (i <= 1 || i >L.length)
        return false;
    e = L.data[i-1];
    for (int j=i-1;j<L.length-1;j++){
        L.data[j] = L.data[j+1];
    }
    L.length--;
    return true;
}
// 按值查找
int LocateElem(SqlList L,ElemType e){
    for(int i=0;i<L.length;i++){
        if(L.data[i] == e){
            return i+1;
        }
    }
    return 0;
}
// 按位查找
ElemType GetElem(SqlList L,int i){
    return L.data[i-1];
}
// 2.2.3 第1题 删除最小值的元素，并由函数返回被删除的值。空出的位置由最后一个元素填补
bool DeleteMin(SqlList &L,ElemType &value){
    if (L.length <= 0)
        return false;
    ElemType min=L.data[0];
    int minIndex=0;
    for(int i=1;i<L.length;i++){
        if (L.data[i] < min){
            min = L.data[i];
            minIndex = i;
        }
    }
    L.data[minIndex] = L.data[L.length-1];
    L.length--;
    value = min;
    return true;
}
// 第2题设置一个高效的算法，将顺序表L的所有元素逆置，要求空间复杂度为O(1)
void ListReverse(SqlList &L){
    for(int i=0;i<L.length/2;i++){
        ElemType temp = L.data[i];
        L.data[i] = L.data[L.length-1-i];
        L.data[L.length-1-i] = temp;
    }
}
// 第3题 删除线性表中所有值为x的元素,要求时间复杂度为O(n)
void ListDeleteElemX(SqlList &L,ElemType x){
    // 思路：扫描一遍有多少个x
    int count=0;
    for (int i =0;i<L.length;i++){
        if (L.data[i] == x){
            count++;
        }else{
            L.data[i-count] = L.data[i];
        }
    }
    L.length = L.length - count;
}
//第4题 从有序顺序表中删除其值在 s 与 t之间的所有元素
bool DeleteFromOrderedBetweenST(SqlList &L,ElemType s,ElemType t){
    if(L.length == 0 || s>=t)
        return false;
    int firstS=-1;
    int firstT=-1;
    for (int i = 0;i<L.length;i++) {
        if (L.data[i] >= s) {
            firstS = i;
            break;
        }
    }
    for(int j=firstS;j<L.length;j++){
        if(L.data[j] > t){
            firstT = j;
            break;
        }
    }
    if(firstS >= L.length)
        return false;
    int k = 0;
    for(int j = firstT;j<L.length;j++){
        L.data[firstS+k]= L.data[j];
        k++;
    }
    L.length = firstS+k; // 之前写的firstT-firstS+1想想什么问题
    return true;
}
// 第4题 王道书中给出的代码
bool DeleteFromOrderedBetweenST(ElemType s,ElemType t,SqlList &L) {
    // 删除有序顺序表L在给定值s与t之间的所有元素
    if(s >= t || L.length == 0)
        return false;
    int i,j;
    for(i=0; i<L.length && L.data[i] < s;i++); // 找的是第一个要删除的
    if(i >= L.length)
        return false;
    for(j=i;j<L.length && L.data[j] <= t;j++);  //找的是第一个不删除的
    for (;j<L.length;j++,i++)
        L.data[i] = L.data[j];
    L.length = i;
}
// 第5题  从顺序表中删除其值在给定值s 与 t之间(包含s和t,要求s<t)的所有元素
bool DeleteBetweenST(SqlList &L,ElemType s,ElemType t){
    if (L.length == 0 || s >= t)
        return false;
    // 沿用上一问的思路
    // 或者记录不处于这个区间的个数
    int count = 0;
    for (int i = 0;i<L.length;i++){
        if (L.data[i] < s || L.data[i] >t){
            count ++;
            L.data[count-1] = L.data[i];
        }
    }
    L.length = count;
}

// 第6题 从有序表中删除其值重复的元素，使表中所有元素的值均不同
bool DeleteRepeatValue(SqlList &L){
    if(L.length == 0)
        return false;
    if(L.length == 1)
        return true;
    int i,j;
    int count=1;
    for(i=1;i<L.length;i++){
        if(L.data[i-1] != L.data[i]){
            count++;
            L.data[count-1] = L.data[i];
        }
    }
    L.length = count;
    return true;
}
// 王道书中的代码，虽然不太懂，但是妙啊
bool DeleteSame(SqlList &L){
    if(L.length == 0)
        return false;
    int i,j;    // i存储第一个不相同的元素,j为工作指针
    for(i=0,j=1;j<L.length;j++){
        if(L.data[i] != L.data[j])  // 查找下一个与上一个元素值不同的元素
            L.data[++i] = L.data[j]; // 找到后将元素前移  // 相当于i保存了处理过的，在i之前的都是不重复的
    }
    L.length = i+1;
    return true;
}
// 第7题 两个有序顺序表合并成一个新的有序顺序表
bool MergeTwoSorted(SqlList M,SqlList N,SqlList &C){
    if (M.length + N.length > MaxSize){
        return false;
    }
    // 思想: 按顺序比较两个有序表中的元素，每次将较小的元素放入新的有序表里
    int i=0,j=0;
    int k=0;
    while(i<M.length && j <N.length){
        if (M.data[i] <= N.data[j]){
            C.data[k++] = M.data[i];
            i++;
        }else{
            C.data[k++] = N.data[j];
            j++;
        }
    }
    while(i<M.length){
        C.data[k++] = M.data[i++];
    }
    while(j<N.length){
        C.data[k++] = N.data[j++];
    }
    C.length = k;
    return true;
}
bool Merge(SqlList A,SqlList B,SqlList &C){
    if(A.length + B.length > MaxSize)
        return false;
    int i=0,j=0,k=0;
    while(i<A.length && j<B.length){
        if(A.data[i] <= B.data[j])
            C.data[k++] = A.data[i++];
        else
            C.data[k++] = B.data[j++];
    }
    while(i < A.length)
        C.data[k++] = A.data[i++];
    while(j < B.length)
        C.data[k++] = B.data[j++];
    C.length = k+1;
    return true;
}
// 第8题 已知在一维数组A[m+n]中依次存放两个线性表。编写一个函数将两个线性表的位置互换
// 先逆置所有的，再逆置前n个，再单独逆置后m个
void ReverseArrayA(ElemType A[],int m,int n){
    int i=0,j=m;
    for(int i=0;i<(m+n)/2;i++){
        ElemType temp = A[i];
        A[i] = A[m+n-1-i];
        A[m+n-1-i] = temp;
    }
    // 再逆置前n个
    for(int i=0;i<n/2;i++){
        ElemType temp = A[i];
        A[i] = A[n-1-i];
        A[n-1-i] = temp;
    }
    // 逆置后m个
    for(int i=n;i<=(2*n+m-1)/2;i++){
        ElemType temp = A[i];
        A[i] = A[2*n+m-1-i];
        A[2*n+m-1-i] = temp;
    }
}
typedef int DataType;
void Reverse(DataType A[],int left,int right,int arraysize){
    // 逆转
    if (left >= right || right >= arraysize)
        return;
    int mid = (left+right)/2;
    for(int i=0; i<= mid-left;i++){
        DataType temp = A[left+i];
        A[left+i] = A[right-i];
        A[right-i] = temp;
    }
}
void Exchange(DataType A[],int m,int n,int arraysize){
    Reverse(A,0,m+n-1,arraysize);
    Reverse(A,0,n-1,arraysize);
    Reverse(A,n,m+n-1,arraysize);
}
// 第9题 线性表递增有序，最少时间在表中查找值为x的元素。若找到，将其与后继元素位置相交换，若找不到，则将其插入表中并使表中元素仍然有序
void SearchAndInsert(SqlList &L,ElemType x){
    // 首先使用二分查找
    int low = 0,high = L.length-1,mid;
    while(low <= high){
        mid = (low+high) / 2;
        if(L.data[mid] == x) break;
        else if(L.data[mid] > x) high = mid -1;
        else if(L.data[mid] < x) low = mid +1;
    }
    if(low > high){
        // 未找到该元素,此时low一定指向第一个大于x的位置
        for(int i=L.length;i>low;i--){
            L.data[i] = L.data[i-1];
        }
        L.data[low] = x;
        L.length ++;
    }
    else if (mid != L.length-1){ // x不是最后一个元素，交换位置
        int temp = L.data[L.length-1];
        L.data[L.length-1] = x;
        L.data[mid] = temp;
    }
}
// 第10题 将数组循环左移p位
// 自己做不出来,看答案
void CircleMoveP(int p,int A[],int n){
    // 可以将问题视为将数组ab, 转换成数组ba
    // a 代表数组前p个元素,b 代表数组余下的n-p个元素
    // 首先将整个数组逆置,再分别对前n-p个元素 、后p个元素进行逆置
    // 即可得到数组ba
    int i=0;
    for(int i=0;i<n/2;i++){
        ElemType temp = A[i];
        A[i] = A[n-1-i];
        A[n-1-i] = temp;
    }
    // 再逆置前n-p个
    for(int i=0;i<(n-p)/2;i++){
        ElemType temp = A[i];
        A[i] = A[n-p-1-i];
        A[n-p-1-i] = temp;
    }
    // 逆置后p个
    for(int i=n-p;i<(2*n-p)/2;i++){
        ElemType temp = A[i];
        A[i] = A[2*n-p-1-i];
        A[2*n-p-1-i] = temp;
    }
}

// 第11题 求两个等长s升序序列的中位数
ElemType MediumOfTwoLinearList(SqlList M,SqlList N){
    if(M.length != N.length || M.length == 0)
        return -1;
    // 我的思路：按照归并思路的方式，当取到第中间位置的元素时就返回
    int i=0,j=0,count=0;
    int temp = 0;
    while(i<M.length && j<N.length){
        if (M.data[i] <= N.data[j]){
            temp = M.data[i];
            i++;
        }else{
            temp = N.data[j];
            j++;
        }
        count++;
        if (count == M.length){
            return temp;
        }
    }
}
// 王道书中的算法不理解

// 第12题 找主元素
// 思路: 第一遍扫描两两抵消掉不同的元素,最后留下的元素可能是主元
// 再第二遍扫描,计算是否大于n/2
bool FindPivotElement(int A[],int n,int &p){
    if (n == 1)
        return A[0];
    int pivot = A[0],i=1;
    int count = 1;
    for(;i<n;i++){
        if(A[i] == pivot){
            count++;
        }else{
            count--;
            if (count == 0){
                pivot = A[i];
                count = 1;
            }
        }
    }
    count = 0;
    // 再一遍扫描计算pivot的个数
    for(int i=0;i<n;i++){
        if(pivot == A[i]){
            count++;
        }
    }
    if(count > n/2){
        p = pivot;
        return true;
    }else{
        return false;
    }
}
// 暴力做法
bool FindPivotElement(int A[],int &p,int n){
    int *arr = (int *) malloc(sizeof (int)*n);
    for (int i=0;i<n;i++){
        int temp = A[i];
        int count = 0;
        for(int j=0;j<n;j++){
            if(A[j] == temp){
                count++;
            }
        }
        if(count > n/2){
            p = temp;
            return true;
        }
    }
    return false;
}

// 第13题 寻找最小未出现的正整数
// 在时间上尽可能高效————以空间换时间
int FindMinDisappear(int A[],int n){
    int *temparr = (int *) malloc(sizeof (int )*n);
    for(int i=0;i<n;i++)
        temparr[i] = 0;
    for(int i=0;i<n;i++){
        if(A[i]>0 && A[i] <= n)
            temparr[A[i]-1] = 1;
    }
    for(int i=0;i<n;i++){
        if(temparr[i] == 0){
            return i+1;
        }
    }
    return n+1;
}
// 暴力做法 时间复杂度 O(n^2) 空间复杂度O(1)
bool FindDisappearMinInt(int A[],int n,int &e){
    int temp = 1;
    while(true){
        bool appear = false;
        for(int i=0;i<n;i++){
            if(A[i] == temp){
                appear = true;
                break;
            }
        }
        if(appear == false){
            e = temp;
            return true;
        }else{
            temp++;
        }
    }
}

// 第14题 输出所有可能三元组中的最小距离
// 注意给的条件中S1，S2,S3都是升序的

// D = 2*{max(a,b,c) - min(a,b,c)}
// 改变min(a,b,c) 是一个最优策略,因为往后遍历a b c 都只会往D增大的方向改变
#define INT_MAX 0x7fffffff

// 找到三个数中最小数的下标 如果最小的是a 返回1，最小的是b返回2...
int MinOfThreeNums(int a,int b,int c){
    if(a <= b && a <= c){       // 注意这里带 等号！ 否则死循环！！！
        return 1;
    }else if(b <= a && b <= c){
        return 2;
    }else{
        return 3;
    }
}

int MinDistanceOfTriTuple(int S1[],int m,int S2[],int n,int S3[],int p){
    int i=0,j=0,k=0;
    int D_min = INT_MAX;
    int D;
    while(i<m && j<n && k<p){
        D = abs(S1[i]-S2[j])+ abs(S1[i]-S3[k]) + abs(S2[j]-S3[k]);
        if(D < D_min){
            D_min = D;
            // 找到此时三个数中最小的数的下标,将最小的数的下标右移
            int min_index = MinOfThreeNums(S1[i],S2[j],S3[k]);
            if(min_index == 1) i++;
            else if(min_index == 2) j++;
            else k++;
        }
    }
    return D_min;
}

// 打印顺序表
void ListPrint(SqlList L){
    cout<<L.length<<endl;
    for (int i = 0;i < L.length;i++)
        cout<<L.data[i]<<"  ";
    cout<<endl;
}

#endif //INC_2_2_1_SQLLIST_H

挑食的孩子不可爱
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
《数据结构》习题刷刷刷2（第二章线性表的顺序表示）
qq_45926254的博客
10-06 609
0x7fffffff}(3)设n=（|S1|+|S2|+|S3|）,时间复杂度为O（n），空间复杂度为O（1）.
数据结构之王道链表大题
weixin_43906877的博客
05-22 283
#include<stdio.h> #include<stdlib.h> typedef struct Node{ int data; struct Node *next; }Node,*PNode; //tips: //PNode temp=node->next; 这样是个指针，指向某个节点，free(temp)是释放temp所指向节点的内容 //PNode temp = (PNode) malloc(sizeof(Node)); 这样是先向系统申请了个no
王道数据结构顺序表大题练习
qq_41225895的博客
01-14 310
顺序表 #include<iostream> #include<string> #include<iomanip> #include<stdlib.h> using namespace std; typedef struct LNode { int data; //结点的数据域 struct LNode *next; //结点的指针域 }LNode, *LinkList; //LinkList为指向结构体LNode的指针类型 bool InitList
考研王道数据结构第一个大题（持续更新）
weixin_46144832的博客
07-16 158
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h> #define MaxSize 50 typedef int ElemType ; //定义顺序表 typedef struct{ ElemType data[MaxSize]; int length; }SqList; //初始化顺序表 void InitList(SqList &.
数据结构之王道二叉树大题
weixin_43906877的博客
05-28 308
notes: 1.global存了一些结构体,定义见后边 2.使用了队列，队列的操作的实现，见其他文章 3.使用了数学库，编译命令类似于 gcc -g tree.c -o tree -lm #include <stdio.h> #include <string.h> #include <stdlib.h> //global存了一些结构体 #include "Global.h" //使用了队列 #include "LinkQueue.c" //使用了数学库，编译命令类似于
王道数据结构-线性表中顺序表的一些综合应用题 王道操作系统-PV操作综合大题总结
12-31
顺序表是一种基本的数据结构，它在线性表中存储元素的方式是连续的内存空间。这里我们主要关注如何在顺序表中进行高效地删除操作。 首先，我们来看第一个问题：删除顺序表中所有值为x的元素。题目要求时间复杂度为O...
王道第二章 -线性表的操作
07-16
线性表是数据结构中的基础概念，它是一个包含相同数据类型的有限序列，具有明确的前后顺序。线性表的特点包括：表长n大于等于0，空表时n为0；每个元素除了第一个之外都有唯一的直接前驱，除了最后一个之外都有唯一的...
王道数据结构2023年版-顺序表（代码+批注+理解+C/C++代码）
10-21
《王道数据结构2023年版-顺序表》是针对考研408课程的一份资料，包含C/C++语言实现的代码示例和详细注释，旨在帮助学习者深入理解和掌握顺序表这一基本数据结构。顺序表是数据结构中的基础概念，它将元素按顺序存储...
2018王道数据结构课后习题代码
10-26
2018年王道数据结构课后习题代码是一个针对该课程学习者的重要资源，它包含了对数据结构概念的深入理解和实际编程实践。这份资料的提供者已经通过了考研，这意味着这些代码经过了实际检验，具有一定的权威性和实用性...
王道数据结构框架图的整理.pdf
12-06
"王道数据结构框架图的整理" 数据结构是计算机科学中的一门基础学科，研究的是计算机存储、处理和运算数据的方法和技术。数据结构是一个复杂的概念，包括逻辑结构、存储结构和数据的运算三个方面。 逻辑结构是指...
王道数据结构代码大题实现,可运行
m0_51185615的博客
08-29 416
第一题 从顺序表L中删除具有最小值的元素(假设唯一)并友函数返回被删元素的值。空出的元素由最后一个元素填补。 #include <bits/stdc++.h> using namespace std; #define Maxsize 100 typedef struct { int c[Maxsize]; int length; }Sqlist; //Sqlist Create01(int Maxsize, int length); bool DeleteMin(Sqlist &
王道数据结构精选习题及解析
最新发布
weixin_43757333的博客
03-25 2214
而为了记录最小值结点的前置结点，我们还需要一个结点，专门作为当前工作结点的前一个结点，工作结点后移一步的过程中，要保持该前置结点是工作结点的前一个结点。链表有一个头结点，我们初始化时也为其保留一个结点，也就是图上的a1，然后我们依次遍历a2及其后面的结点，将其在合适的位置插入。由于我们没有新建一个链表，而是在原来的l1的基础上去改箭头，所以我们需要一个多的指针去存储l1当前工作指针的下一个指针。还有就是最后一步，循环完毕时，最后一个结点是没有指向前一个结点的，因此不能忘记这一步操作！
王道数据结构编程题（链式存储线性表）
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
03-05 607
王道数据结构编程题（链式存储线性表）
【数据结构应用题】线性表的顺序表示（含统考真题）
Obliviate的博客
01-20 1164
【数据结构应用题】线性表的顺序表示（含统考真题）
第三节 线性表的顺序存储
陈Sir的博客
06-24 2718
一、顺序表 1、顺序表的定义 线性表的顺序存储又称为顺序表,它是用一组地址连续的存储单元，依次存储线性表中的数据元素。从而使得逻辑上相连的两个元素在物理上也是相邻的。表中元素的逻辑顺序与物理顺序相同。 2、线性表的顺序存储表示 3、线性表顺序存储类型描述 4、顺序表的特点 顺序表的主要特点是随机访问，即通过首地址和元素序号可以在O(1)的时间内找到指定元素。 顺序表的存储密度高，每个节点只存储数据元素。 顺序表逻辑上相邻的元素物理上也相邻，所以插入和删除...
稀疏矩阵的三元组顺序表存储表示（第五章 P98）
但行好事，莫问前程
03-24 4907
稀疏矩阵的三元组顺序表存储表示 三元组顺序表存储结构： 三元组存储稀疏矩阵示例： typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */ typedef int ElemType; #in...
三元组顺序表
热门推荐
zuoyoukma的博客
01-13 1万+
三元组顺序表 假设以顺序存储结构存放三元组的线性表，则可得稀疏矩阵的一种存储压缩表示法-称之为三元组顺序表 实现矩阵转置的算法：                                                   1.“按需点菜”。由于T.data[ ]中
王道数据结构二叉树算法大题代码总结
qq_46264636的博客
07-28 1245
王道二叉树算法大题代码总结-看这一篇就够了
第十二章 数据结构 数组和广义表 + 矩阵的存储 + 稀疏矩阵 + 三元组转置的代码实现
weixin_43960370的博客
04-19 979
数组 数组的定义，特点及顺序存储 线性表的推广- 数组 数组是我们熟悉的数据结构，可以把数组看作是线性表的推广。 数组的特点是结构中的元素本身可以是具有某种结构的数据， 但属于同一数据类型。 以一维数组为基础， 可以这样观察。 将二维数组看成数据元素是一维数组的一维数组。 将三维数组看成元素是二维数组的一维数组。 n维数组中， 每个数据元素受n个关系的约束。 一般来说， 在数组上不能做插入， 删...
"王道数据结构：线性表顺序表综合应用题1-高效删除元素算法
以上是王道数据结构-线性表中顺序表的一些综合应用题的题目描述。这些题目都要求设计算法，满足特定的时间复杂度和空间复杂度，并且要求对顺序表进行特定的操作。 在第一道题中，要求设计一个时间复杂度为 O(n)，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值