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

最新推荐文章于 2024-09-04 11:16:25 发布
最新推荐文章于 2024-09-04 11:16:25 发布
阅读量145 收藏
点赞数
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/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

数据结构-线性表-思维导图+小结
学习记录
11-12 2644
数据结构-线性表-思维导图+习题小结
考研系列-数据结构第二章、线性表
Nelson_hehe的博客
06-09 2374
本文是408考研付费专栏系列-数据结构线性表章节，本文章详细地总结了线性表的相关知识，其中包括：顺序表、链表（单链表、双链表、循环链表、静态链表等）的细节和重要知识点汇总。考研听课、复习的好帮手。
2024版王道《数据结构》编程题汇总_21年王道数据结构
最新发布
2401_86950546的博客
09-04 1289
又如A=（0,5,5,3,5,1,5,7），则A中没有主元素。,bn)原地逆置为(bnbn-1, n2,",D1,m,m-1,am-2, a1),再对前n个元素和后m个元素分别使用逆置算法,即可得到(b,b2, b3,…算法思想:注意是有序顺序表,值相同的元素一定在连续的位置上,用类似于直接插入排序的思想,初始时将第一个元素视为非重复的有序表.之后依次判断后面的元素是否与前面非重复有序表的最后一个元素相同,若相同则继续向后判断,若不同则插入到前面的非重复有序表的最后,直至判断到表尾为止.
数据结构之王道链表大题
weixin_43906877的博客
05-22 347
#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 368
顺序表 #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 190
#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 363
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
在王道数据结构课程中，顺序表作为一种基础的数据结构，其综合应用题往往能够考察学生对于线性表操作的理解和实际编程能力。而在王道操作系统课程中，PV操作的综合大题，则是对进程同步与互斥理解的深入检验。本文将...
王道数据结构考研课后习题（线性表）
2201_75825034的博客
08-26 317
int* data;int length;}SeqList;int pos;L.length--;return 0;
【王道数据结构】第二章 线性表
weixin_48434658的博客
07-16 748
线性表(LinearList)的定义线性表的基本操作什么时候要传入参数的引用**“&”**——对参数的修改结果需要“带回来”顺序表的实现——静态分布顺序表的实现——动态分配顺序表特点什么是单链表用代码定义一个单链表🎈结点的表示即后可写为🎈定义一个单链表获取第i位结点（带头结点）两种实现方式🎨不带头结点🎨带头结点🎨不带头结点V.S.带头结点。...
王道数据结构精选习题及解析
weixin_43757333的博客
03-25 2367
而为了记录最小值结点的前置结点，我们还需要一个结点，专门作为当前工作结点的前一个结点，工作结点后移一步的过程中，要保持该前置结点是工作结点的前一个结点。链表有一个头结点，我们初始化时也为其保留一个结点，也就是图上的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 667
王道数据结构编程题（链式存储线性表）
【数据结构应用题】线性表的顺序表示（含统考真题）
Obliviate的博客
01-20 1260
【数据结构应用题】线性表的顺序表示（含统考真题）
线性表的顺序表示相关真题
m0_48433051的博客
06-08 214
算法
第三节 线性表的顺序存储
陈Sir的博客
06-24 2851
一、顺序表 1、顺序表的定义 线性表的顺序存储又称为顺序表,它是用一组地址连续的存储单元，依次存储线性表中的数据元素。从而使得逻辑上相连的两个元素在物理上也是相邻的。表中元素的逻辑顺序与物理顺序相同。 2、线性表的顺序存储表示 3、线性表顺序存储类型描述 4、顺序表的特点 顺序表的主要特点是随机访问，即通过首地址和元素序号可以在O(1)的时间内找到指定元素。 顺序表的存储密度高，每个节点只存储数据元素。 顺序表逻辑上相邻的元素物理上也相邻，所以插入和删除...
稀疏矩阵的三元组顺序表存储表示（第五章 P98）
但行好事，莫问前程
03-24 5117
稀疏矩阵的三元组顺序表存储表示 三元组顺序表存储结构： 三元组存储稀疏矩阵示例： typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */ typedef int ElemType; #in...
《数据结构》习题刷刷刷2（第二章线性表的顺序表示）
qq_45926254的博客
10-06 859
0x7fffffff}(3)设n=（|S1|+|S2|+|S3|）,时间复杂度为O（n），空间复杂度为O（1）.
三元组顺序表
热门推荐
zuoyoukma的博客
01-13 1万+
三元组顺序表 假设以顺序存储结构存放三元组的线性表，则可得稀疏矩阵的一种存储压缩表示法-称之为三元组顺序表 实现矩阵转置的算法：                                                   1.“按需点菜”。由于T.data[ ]中
王道数据结构二叉树算法大题代码总结
qq_46264636的博客
07-28 1406
王道二叉树算法大题代码总结-看这一篇就够了
"王道数据结构：线性表顺序表综合应用题1-高效删除元素算法
以上是王道数据结构-线性表中顺序表的一些综合应用题的题目描述。这些题目都要求设计算法，满足特定的时间复杂度和空间复杂度，并且要求对顺序表进行特定的操作。 在第一道题中，要求设计一个时间复杂度为 O(n)，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值