408线性表——顺序表

已于 2023-01-12 22:16:50 修改
阅读量165 收藏
点赞数
分类专栏： 408考研数据结构笔记 文章标签： c++ Powered by 金山文档
于 2023-01-07 16:57:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51711089/article/details/128592640
版权

顺序表的考察范围覆盖多指针， 排序， 散列表, 二分， 顺序表逆置算法

1.顺序表删除元素

题目：顺序表删除元素x

思路：

方法1：

双指针

遇到一个等于x就停下来，此时k的值即为要删除元素下标，直到元素去替代他的位置，非x与非x之间始终相差k个单位，然后k++更新， 顺序表的长度即为k的个数， 因为k是遇到一个非k的数++, 因为k的个数就是非x的个数。

代码：

#include<iostream>
#define ElemType int
using namespace std;

const int Maxn = 50;

struct SqList {
    int length; 
    ElemType data[Maxn] = {1, 2, 2, 3, 4, 5, 5, 6};
};
//方法1
void DeleteElem(SqList &l, int x) {
    int  i = 0, k = 0;
    while(i < l.length) {
        if(l.data[i] != x) {
            l.data[k] = l.data[i];
            k++;
        }
        i++;
    }
    l.length = k;
}
  

int main () {
    SqList l;
    l.length = 8;
    int x;
    x = 2;
    DeleteElem(l, x);
    for(int i = 0; i < l.length; i++)
        cout << l.data[i] << " ";
     
        return 0;
}

方法2：

双指针

遇到一个x就记出来k++， 直到遇到不是x的元素，将后面不为k的元素整体往前推k个单位就想当于删除x了，k为x 的个数。

代码：

#include<iostream>
#define ElemType int
using namespace std;

const int Maxn = 50;

struct SqList {
    int length; 
    ElemType data[Maxn] = {1, 2, 2, 3, 4, 5, 5, 6};
};
//方法2
void DeleteSameElem(SqList &l, int x) {
    int  i = 0, k = 0;
    while(i < l.length) {
    while(i < l.length) {
        if(l.data[i] == x) {
            k++;
        } else {
            l.data[i - k] = l.data[i];
        }
        i++;
    }
    l.length = l.length - k;
    }
}
  

int main () {
    SqList l;
    l.length = 8;
    int x;
    x = 2;
    DeleteSameElem(l, x);
    for(int i = 0; i < l.length; i++)
        cout << l.data[i] << " ";
     
        return 0;
}

//我更喜欢方法2

如果是有序表删除满足范围[s, t]内的元素， 就直接找到第一个大于t的元素， 把t前面的元素整体删除即可

2.删除有序顺序表相同的元素

题目：删除有序顺序表的相同元素， 只保留一个

思路：因为是有序顺序表， 所以相同的元素肯定是连续的，关键就是找到两个数不同的时候的临界点， 用两个指针， 都从左边走，i指向第一个相同元素， j往右边跑，当j和i指向元素不同的时候， 就可以让a[j]后面的元素往前移动了， 移动到i指向的元素后面一个的位置，因为要将相同元素删只剩一个。

代码：

#include<iostream>
#define ElemType int
using namespace std;

const int Maxn = 50;

struct SqList {
    int length; 
    ElemType data[Maxn] = {1, 2, 2, 2, 2, 3, 3, 3, 4, 4, 5};
};

void DeleteSame(SqList &l) {
    int i = 0, j = 0;
    for(i,j; i < l.length && j < l.length; j++) {
        if(l.data[j] != l.data[i]) {//相同就不管他， 让j接着往前走直到两个不同的时候就可以换到i后面了, 绕过相同的元素; 
            l.data[++i] = l.data[j];
        }
    }
    l.length  = i + 1; //i都是指向要剩下的哪个唯一数， 因此i+1就是最终元素的个数; 
}



int main () {
    SqList l;
    l.length = 11;
    DeleteSame(l);
    for(int i = 0; i < l.length; i++)
        cout << l.data[i] << " ";
     
        return 0;
}

//感觉顺序表删除都是用双指针比较多, 时间和空间复杂度最低, 其实和哪个删除满足某个范围内的数的那题很像， 只不过是将范围内的数换成了相同的数;

3.归并排序

题目：将两个有序顺序表合并为一个有序顺序

代码：

#include<iostream>
#define ElemType int
using namespace std;

const int Maxn = 50;

struct SqList {
    int length; 
    ElemType data[Maxn];
};

//两个有序序列合并为一个有序序列; 
void Merge(SqList &a, SqList &b, SqList &c) {
    int i = 0 , j = 0, k = 0;
    while(i < a.length && j < b.length) {
        if(a.data[i] < b.data[j])//不能写成while,写成while就成死循环了，其中一个数组会一直往右边走，因为0肯定比另一个数组的正整数小；
            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;
}


int main () {
    SqList a, b, c;
    int n = 3;
    int m = 4;
    a.length = 3;
    b.length = 4;

/*
测试数据 
1 3 5
2 4 5 6
*/
    for(int i = 0; i < n; i++) cin >> a.data[i];
    for(int i = 0; i < m; i++) cin >> b.data[i];
    Merge(a, b, c);
    for(int i = 0; i < c.length; i++)
        cout << c.data[i] << " ";
     
        return 0;
}

//归并排序是一个先分再合并的排序， 合并后的区间是有序的， 最后实现整个数组有序;

4.

二分

题目：

在有序的顺序表找x并和后面的数交换，如果x是最后一个元素不用交换， 不存在就插入顺序表，插入后仍是有序的

思路：有序顺序表找某个元素，第一个应该想到使用二分法找到该元素的下标，

代码：

#include<iostream>
#define ElemType int
using namespace std;

const int Maxn = 50;

struct SqList {
    int length; 
    ElemType data[Maxn] = {1, 2, 4, 5, 6};
};

//两个有序序列合并为一个有序序列; 
void FindElem(SqList &l, int x, int n) {
    int left = 0, right = n - 1, mid, temp;
    while(left <= right) {
        mid = (left + right) / 2;
        if(l.data[mid] == x) {
            if(mid != n - 1) {
            temp = l.data[mid];
            l.data[mid] = l.data[mid + 1];
            l.data[mid + 1] = temp;                
            }
            break;
        }
        if(l.data[mid] < x) {
            left = left + 1;    
        } else {
            right = right - 1;
        }
    }
    if(left > right) {
        for(int i = n - 1; i >= left; i--) {//left的位置就是x应该插入的位置， 这个位置要腾出来给x， 因此是要包括Left的; 
            l.data[i + 1] = l.data[i];
        } 
        l.data[left] = x;
        l.length++;
    }
}

int main () {
    SqList c;
    c.length = 5;
    int x;
    cin >> x;
    FindElem(c, x, c.length);
    
    for(int i = 0; i < c.length; i++)
        cout << c.data[i] << " ";
     
        return 0;
}

5.

顺序表逆置算法，时间复杂度为O(n), 空间复杂度为O(1)

题目：

有一个序列, 里面存放两个序列，分别是a和b，长度分别是n, m, 要求原来a在b前面改成b在a前面

思路:

1.将整个数组反转, a1a2变成a2a1

  1. 区间a2逆转变正序

  1. 区间a1变成正序

最后变成a2正序a1正序 

#include<iostream>
#define ElemType int
using namespace std;
const int Asize = 50;


//将所有元素倒置，考元素逆置的时候也可以使用;
bool Reverse(ElemType A[], int left, int right, int Asize) {
    if(left >= right || right >= Asize)
        return false;
    int mid = (left + right)/2;//求mid是为了求交换次数; 
    for(int i = 0; i <= mid - left; i++) {//mid - left才是真正的交换次数，这是要等于; 
                                        //mid - left = (right - left)/2; 
                                        //序列个数为偶数两两交换, 奇数最后一次自己跟自己交换； 
        ElemType temp = A[left + i];
        A[left + i] = A[right - i]; 
        A[right - i] = temp; //上面三行的left, right加减i是为了限制区间; 
    }
}
void ReverseList(ElemType A[], int m, int n) {
    Reverse(A, 0, n + m - 1, Asize);//让整个数组内的元素反转; 
    Reverse(A, 0, n - 1, Asize);//让序列a2反转变成正序;
    Reverse(A, n, n + m - 1, Asize);//让序列a1反转变成正序; 
}

int main () {
    int m = 5;
    int n = 3;
    int a1[m]  = {1, 2, 3, 4, 5};
    int a2[n] = {6, 7, 8};
    int A[Asize] = {0};
    int k = 0;
    for(int i = 0; i < m; i++)
        A[k++] = a1[i];
    for(int i = 0; i < n; i++)
        A[k++] = a2[i];
    
    for(int i = 0; i < k; i++)
        cout << A[i]; 
    cout << "\n";
    ReverseList(A, m , n);
    for(int i = 0; i < k; i++)
        cout << A[i];      

    return 0;
} 
//该算法的时间复杂度为O(n), 空间复杂度为O(1);

6.

二分法求两个长度相同的有序顺序表合并后的有序顺序表的中位数， 时间复杂度为O(log n ), 空间复杂度为O(1)

题目： 求两个长度相同的有序顺序表的中位数（2011统考真题）

思路：

不断求两个序列的中位数，通过两个中位数的值来缩小序列的范围大小，最后两种情况

  1. 当当前两个序列的中位数相等，则为合并后的序列的中位数。

  1. 两个缩小的序列都只剩最后一个元素，小的哪个就是合并后序列的中位数。

代码：

#include<iostream>

using namespace std;

int MidSearch(int a[], int b[], int n) {
    int s1 = 0, s2 =0, d1 = n - 1, d2 = n - 1;
    int m1, m2;
    while(s1 != d1 && s2 != d2) {//序列只剩一个元素的时候就结束，小的哪个就是中位数; 
        m1 = (s1 + d1) / 2;
        m2 = (s2 + d2) / 2;
        if(a[m1] == b[m2]) //两序列的中位数相等， 则该点上的中位数即为大序列的中位数; 
            return a[m1];
        if(a[m1] < b[m2]) {//小的不要左侧，大的不要右侧 
            if((s1 + d1) % 2 == 0) {//如果为奇数的时候， m1, m2都有可能是中位数; 
                s1 = m1;
                d2 = m2;
            } else { //偶数的时候，小的mid不可能是中位数; 
                s1 = m1 + 1;
                d2 = m2;
            }
        } else {
            if((s1 + d1) % 2 == 0) {
                d1 = m1;
                s2 = m2;
            } else {
                d1 = m1;
                s2 = m2 + 1;
            }
        }
    }
    return a[s1] < b[s2] ? a[s1] : b[s2];//不是返回mid，因为mid是上次遍历的mid
}
 
int main() {
    int n = 5;
    int a[n] = {11, 13, 15, 17, 19};
    int b[n] = {2, 4, 6, 8, 20};//中位数为4
    int mid = MidSearch(a, b, n);
    cout << mid;
    return 0; 
}

//难点不是很理解序列的中位数和合并后的序列的中位数有啥关系？？

//因为是升序序列， 可以使用归并排序， 成一个新序列， 然后返回其中位数，时间复杂是O(n), 空间复杂度为O(1), 因为整理出来得哪个数组是要返回得， 不属于辅助数组。

这不是一般人想得出来得， 两个有序序列合并为一个有序序列， 我们应该想到归并排序

代码：

#include<iostream>

using namespace std;

//返回第i个元素，使用得是向上取整，向上取整就是9/2 = 4/5 = 5
//对付向上取整可以用最后一个元素的下标/2得到就是第i个元素得下标; 
int Merge(int a[], int b[], int c[], int n, int m) {
    int i = 0, j = 0, k = 0;
    while(i < n && j < m) {
        if(a[i] < b[j])
            c[k++] = a[i++];
        else
            c[k++] = b[j++]; 
    }
    while(i < n) c[k++] = a[i++];
    while(j < m) c[k++] = b[j++];
    return c[(k-1)/2];
}

int main() {
    int n = 5, m = 5;
    int a[n] = {11, 13, 15, 17, 19};
    int b[m] = {2, 4, 6, 8, 20};
    int c[m + n] = {0};
    int num = Merge(a, b, c, m, n);
    for(int i = 0; i < m + n; i++) {
        if(i != 0)
            cout << " ";
        cout << c[i];
    }
    cout << "\n" << num;
    return 0;
}

7.

多指针求多个数组的元素的组合满足某个特征值

题目:给出3个递增序列，3个数列分别取一个值记作a, b, c，求d = abs(a - b) + abs(b - c) + abs(c - a)最小的d

思路：

利用三个指针指向三个数组最左侧

//分析

核心思想：

数轴上若a < b < c,则d1 = 2Lac, 若b < a < c， 则d2 =2Lbc

若 c < b < a， 则d3 = 2Lca等等等

可以看出d的值即为最大值和最小值之间的距离, 当且仅当最小值向右移动的时候d才有可能变小

如若 a < b < c, a最为最小值, 我们称a, b, c为一个组合， 在数轴上表示出来为组合结构

1. 如果a在a,b之间移动，a还是最小值， 没有改变结构还是a < b < c, 此时d肯定比上一次小;

2. 如果a在b, c之间移动，改变了结构，变成了 b < a < c, 最小值变成了b, 然后b再往右边移动看看，看看d有没有变小，但不一定比上一个结构的d小；

3. 如果a在b, c之间移动，和2同理；

因此只需要不断改变最小值，不断更新组合结构并找到其Dis，才能找到最小的Dis；

疑问：为什么遍历的边界为while(i < n1 && j < n2 && k < n3)

答：

倘若组合为A, B, C且A<B<C, A, B, C的最大值分别为Amax， Bmax ，Cmax

A B C Amax Bmax Cmax

——————————————————————————————>数轴

由图可知A只要在Amax之间枚举都是有效的，B， C同理， 因此边界就是Amax， Bmax，Cmax

因为是递增序列，所以也就是各个数组的最后一个值。

代码：

#include<iostream>
#include<cmath>

using namespace std;

//最好时间复杂度为是O(min(n1, n2, n3)),最差的时间复杂度为O(n1 + n2 + n3),空间复杂度为O(1); 
void MinDis(int s1[], int s2[], int s3[], int n1, int n2, int n3) {
    int i = 0, j = 0, k = 0;//三个指针分别指向数组的最左侧; 
    int Min_Dis = 0x7fffffff;//ox7fffffff是int范围内的最大值; 
    int ans_s1 = s1[0], ans_s2 = s2[0], ans_s3 = s3[0];//距离最短的时候的组合;
    while(i < n1 && j < n2 && k < n3) {  
    int Dis = abs(s1[i] - s2[j]) + abs(s2[j] - s3[k]) + abs(s3[k] - s1[i]);
    //因为每次变更组合，那么在数轴上的结构就会改变，因此每次改变都要算一次距离;
    if(Dis < Min_Dis) {
        Min_Dis = Dis;
        ans_s1 = s1[i];
        ans_s2 = s2[j];
        ans_s3 = s3[k];
    }//这个组合结构比上一次的组合算出来的距离更短;     
    
    //找出三个数的最小值， 移动最小值， 更新组合结构; 
    //只有最小值向右侧移动的时候才有可能使得距离变小， 但是也可能会改变组合结构
    /*假如a, b, c为三个数组选出的三个数， 且a < b < c(方便讨论而已，便于判断） 
    a最为最小值
    1. 如果a在a,b之间移动，没有改变结构还是a < b < c, 此时Dis肯定比上一次小; 
    2. 如果a在b, c之间移动，改变了结构，变成了 b < a < c, 最小值变成了b, 然后b再往右边移动，看看d有没有变小，但不一定比上一个结构的Dis小； 
    3. 如果a在b, c之间移动，和2同理； 
    因此只需要不断改变最小值，不断更新组合结构并找到其Dis，才能找到最小的Dis； 
    */ 
    if(s1[i] < s2[j] && s1[i] < s3[k])//s1是最小的时候, 最小值向右移动才可能Dis变小； 
        i++;
    else if(s2[j] < s1[i] && s2[j] < s3[k])//s2为最小的时候 
        j++;
    else //s3为最小值的情况； 
        k++;
    }
    cout << Min_Dis << endl;
    cout << ans_s1 << " " << ans_s2 << " " << ans_s3;
}



int main() {
    int n1 = 3 , n2 = 4, n3 = 5;
    int s1[n1] = {-1, 0, 9};
    int s2[n2] = {-25, -10, 10, 11};
    int s3[n3] = {2, 9, 17, 30 ,41};
    MinDis(s1, s2, s3, n1, n2, n3);
    
    return 0;
}

8.

散列表

题目1：

找出顺序表内的主元素， 主元素是出现次数最多且出现次数 > n/2的值

思路：

散列表时间换空间

代码：

#include<iostream>
#include<cstring>
#define ElemType int
using namespace std;

const int Maxn = 50;

struct SqList {
    int length; 
    ElemType data[Maxn] = {1, 2, 4, 5, 6};
};


int FindMajor(int A[], int n) {
    int Max = A[0], MaxCnt = -1, MaxNum;
    for(int i = 1; i < n; i++) {
        if(A[i] > Max) {
            Max = A[i];
        }
    }
    int *hashtable = new int[Max + 1];
    memset(hashtable, 0, sizeof(hashtable));//记得给开辟的空间初始化，否则开辟的空间内的值初始可能不为0； 
    for(int i = 0; i < n; i++) {
        hashtable[A[i]]++;
    }
    
    for(int i = 0; i < n; i++) {
        if(hashtable[A[i]] > MaxCnt) {
            MaxCnt = hashtable[A[i]];
            MaxNum = A[i];
        }
    }
    delete []hashtable;
    return MaxCnt > n / 2 ? MaxNum : -1;
}


int main () {
        int A[] = {0, 5, 5, 3, 5, 1, 5, 7};
        int num = FindMajor(A, 8);
        cout << num;        
        return 0;
}

题目2：

找出顺序表缺失的最小正整数（最小正整数不包括0）， 如1， 3， 5， 7缺失的最小正整数即为2;

思路:

散列表除了可以统计出现的次数还可以用来判断某元素是否出现过， 通过这个性质， 遍历散列表，为值为0就说明没出现过， 说明缺失

代码：

#include<iostream>
#include<cstring>
#define ElemType int
using namespace std;

const int Maxn = 50;

struct SqList {
    int length; 
    ElemType data[Maxn] = {1, 2, 4, 5, 6};
};


int FindElem(int a[], int n) {
    int Max = a[0];
    for(int i = 1; i < n; i++) {
        if(Max < a[i])
            Max = a[i];
    }
    int hashtable[Max + 1 + 1] = {0};//第一个+1是因为开的下标的范围为[0,Max-1]因此要多开一个单位，第二个+1是因为要判断最后一个元素的后面一个为位置是否为最小正整数 
    for(int i = 0; i < n; i++) 
        hashtable[a[i]]++;
    for(int i = 1; i <= Max + 1; i++) {
        if(hashtable[i] == 0)
            return i;
    } 
} 


int main () {
        int n = 5;
        int a[n] = {1, 2, 3, 4, 5};
        int num = FindElem(a, n);
        cout << num;
        return 0;
}

柘木木
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 之 顺序表元素逆置 复杂度O(1)
Xuan_m_o的博客
04-24 2424
/*设计一个高效算法，将顺序表L中的所有元素逆置，要求算法的空间复杂度为O（1）*/ 这篇文章其实也算不上完全原创，但是我添了一点点个人总结。 顺序表的学习看的是这个教程：http://data.biancheng.net/view/158.html 代码段如下： #include <stdio.h> #include <stdlib.h> typedef str...
小白算法积累——顺序表6#有序顺序表 +删除重复元素
01-07
题目：从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不同。 关键字：有序顺序表 删除重复元素 思路 关注：因为是有序表，所以值相同的元素一定在连续的位置上， 用类似于直接插入排序的思想 1.初始时...
408数据结构——线性表之C++实现顺序表
long99920的博客
05-22 491
可修改main函数内的注释，测试相应的顺序表操作。 #include <iostream> using namespace std; #define initSize 10 // 顺序表初始容量 // 创建顺序线性表(顺序表),动态分配内存空间地址 typedef struct { int *array; // 指向顺序表的指针 int maxSize,length; // 顺序表最大容量,顺序表当前长度 }sqList;
顺序表2：顺序表的逆置
qq_43591406的博客
12-03 8154
一、顺序表逆置基本逻辑和实现 1.顺序表逆置的逻辑 将顺序表丛中间一分为二。 如果这个顺序表元素个数为i； 让第一个元素和最后一个元素互换， 第二个和倒数第二个元素互换； … 第i/2个元素和第i/2+1个元素互换。 交换结束以后，这就是个逆序的表了。 2.代码实现 void Reverse(Sqlist &L) { int temp;//辅助变量 //这里L.Length/2会自动保留整数部分，所以，如果是奇数就没有任何影响了 for (i = 0; i < L.Length/2; i
顺序表的逆置算法
热门推荐
weixin_43715601的博客
02-13 1万+
顺序表的逆置算法1、逆置原理2、算法实现3、经典例题14、经典例题2 1、逆置原理 顺序表的逆置即将线性表(a1,a2,a3…,an)转化为(an,an-1,an-2…,a2,a1)，此操作在程序设计中经常使用。 2、算法实现 #include<iostream> #include<cstdlib> using namespace std; typedef int Data...
数据结构算法之---顺序表逆置
知识在于理解,运用在于总结,高阶在于巩固!
09-29 3901
思路： 此种算法较为经典，可扫描该线性表的前半部分，然后把前半部分的每一个元素和后半部分进行交换。具体算法如下： void reverse(sqList s,int length)//传入一个线性表，length该表的长度 { int temp; for(int i=0;i<length/2;i++)//只扫描表的前半部分 { temp=s[i]; int s[i]=s[length-1-i]; s[length-i-1]=s[i
线性表——顺序表PPT学习教案.pptx
10-04
线性表——顺序表PPT学习教案 线性表是一种典型的线性结构，其基本特点是线性表中的数据元素是有序且是有限的。线性表可以分为顺序表和链表两种存储结构，今天我们主要讨论顺序表。 1. 线性表的定义 线性表是具有...
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
代码包含顺序表和单链表的基本操作（增删改查等，详见注释），并展示了两个具体使用例子，包括对基本操作的验证和合并两个有序线性表为一个有序表。代码均已通过Dev-C++5.4.0，为了防止误修改，文档已限制编辑，密码...
线性表——链表PPT学习教案.pptx
10-01
链表的操作，如插入和删除，通常比顺序存储的线性表更灵活，因为它们主要涉及到节点之间的指针修改，而不需要像顺序表那样移动大量元素。然而，这也意味着链表的访问速度可能较慢，因为必须从头节点开始遍历，寻找...
小白算法积累——顺序表5#无序顺序表+删除范围
01-07
题目：从顺序表中删除其值在给定值s与t之间（包含s和t，要求s<t）的所有元素，如果s或t不合理或顺序表为空，则显示出错信息并退出运行。 关键词：无序顺序表 删除范围 思路： 1.遍历扫描顺序表L，用k记录下当前...
实现对顺序表的逆置
03-28
实现对顺序表的逆置，在大学的数据结构课上这是很多人第一次实验的第一道题，希望这份代码可以帮助到大家，希望大家有心的更好的思路也多分享分享。
算法作业：顺序表逆置算法
06-28
数据结构和算法的作业，顺序表的逆置，绝对可以用，是用文件输入输出，要先建一个input.txt文档，在里面输入数据，最后生成output.txt文档就是排序后的顺序表
顺序表逆置算法
10-08
顺序表就地逆置算法用c语言描述的，数据结构课后习题之一
数据结构（C语言）：顺序表就地逆置
最新发布
lbcbjtlhmjq的博客
04-14 4576
用循环遍历顺序表中的元素，依次调用两数交换函数，将顺序表中的第一个元素与最后一个元素的值互换，再将第二个元素与倒数第二个的值互换，以此类推，直到顺序表完成倒序。，即利用原顺序表的存储单元将数据元素序列（a0,a1,…,an-1）逆置为（an-1,…、定义两数交换函数。
数据结构——顺序表的逆置
luladuck的博客
03-20 1万+
题目：请写一个算法将顺序存储结构的线性表（a1...an）逆置为(an...a1)，要求使用最少的附加空间。 解析：可以理解为一个线性表内的交换问题。当n为奇数时，将第一个元素与最后一个元素进行交换，第二个元素与倒数第二个元素进行交换，以此类推，最中间的元素不用进行交换（n/2+1）。当n为偶数时，规则与奇数时一样，只是最中间两个元素也要进行交换（n/2 <----> n/2+1）。 核心代码： //核心代码 void Inverse(SqList &L) { int i, t
顺序表的逆置
m0_53171456的博客
02-10 7711
算法基本设计思想： 先举两个例子吧。 例1：原顺序表：1 2 3 4 5 6 逆置后为：6 5 4 3 2 1 例2：原顺序表：1 2 3 4 5 6 7 逆置后为：7 6 5 4 3 2 1 在例1中顺序表的长度为6，为偶数，我们可以这样来交换，6和1，5和2，4和3，一共进行三趟交换，这样交换后就得到改顺序表的逆序了。在例2中，顺序表的长度为7，为奇数，和例1一样交换，7和1，6和2 ，5和3，4这个元素处于最中间，它是固定不动的。从这两个例子我们可以发现其中的规律，就是当顺序表的长度为奇数和偶数时，
数据结构-顺序表-将顺序表所有元素逆置，且要求空间复杂度为O(1)
Xulidanga的博客
09-23 2063
一.算法思想 根据题目的要求，将顺序表中的元素上半部分及下半部分的元素通过变量temp进行逆置 二.源代码 //逆置顺序表 void Reverse(List list) { int temp = 0; //辅助变量 /*转置前的数组*/ PrintList(list); /*算法思想:将顺序表的前半部分与后半部分进行交换,故需用到temp辅助变量 注: 因list->last为顺序表的下标,故list->last/2为奇数和偶数时处理方式不同 即list->last
顺序表和单链表的就地逆置
weixin_57940917的博客
10-07 1574
本题分为两部分，一是顺序表的逆置操作，二是单链表的逆置操作，二者的要求是实现就地逆置，要利用原表的存储空间实现逆置而不能在创建一个表，将原表的数据元素插入到新的表中。 顺序表的逆置操作：先封装一个最大空间为100的顺序表，然后将一个数组赋值给该顺序表，将该顺序表以中心对称的两侧元素（分别用m,n来表示）对调位置,直到m,n两变量相等时结束循环，输出新的逆置后的顺序表。 单链表的逆置操作：先封装一个单链表,定义一个能利用头插法随机生成链表元素的函数CreatListH...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值