顺序表之元素位置互换(2种方法)

本文介绍了一种针对长度为len的顺序表进行元素位置互换的移位算法,通过三次翻转操作实现前m个元素与后len-m个元素的位置交换,且空间复杂度为O(1)。
部署运行你感兴趣的模型镜像

顺序表应用3:元素位置互换之移位算法
Time Limit: 1000 ms Memory Limit: 570 KiB

Problem Description
一个长度为len(1<=len<=1000000)的顺序表,数据元素的类型为整型,将该表分成两半,前一半有m个元素,后一半有len-m个元素(1<=m<=len),借助元素移位的方式,设计一个空间复杂度为O(1)的算法,改变原来的顺序表,把顺序表中原来在前的m个元素放到表的后段,后len-m个元素放到表的前段。
注意:先将顺序表元素调整为符合要求的内容后,再做输出,输出过程只能用一个循环语句实现,不能分成两个部分。
Input
第一行输入整数n,代表下面有n行输入;
之后输入n行,每行先输入整数len与整数m(分别代表本表的元素总数与前半表的元素个数),之后输入len个整数,代表对应顺序表的每个元素。
Output
输出有n行,为每个顺序表前m个元素与后(len-m)个元素交换后的结果
Sample Input
2
10 3 1 2 3 4 5 6 7 8 9 10
5 3 10 30 20 50 80
Sample Output
4 5 6 7 8 9 10 1 2 3
50 80 10 30 20
Hint

注意:先将顺序表元素调整为符合要求的内容后,再做输出,输出过程只能在一次循环中完成,不能分成两个部分输出。
Source

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define LISTINCREASEMENT 100
#define LISTSIZE 1000000
typedef struct
{
    int *elem;
    int length;
    int listsize;
}Sqlist;
void InitList(Sqlist&L)
{
    L.elem=(int*)malloc(LISTSIZE*(sizeof(int)));
    L.length=0;
    L.listsize=LISTSIZE;
}
void ListInsert(Sqlist&L,int i,int e)
{
    if(L.length>=L.listsize)
    {
        int *newbase=(int*)realloc(L.elem,(L.listsize+LISTINCREASEMENT)*sizeof(int));
        L.elem=newbase;
        L.listsize=L.listsize+LISTINCREASEMENT;
    }
    L.elem[i]=e;
    L.length++;
}
//void exchange(Sqlist&L,int m)
//{
//    for(int i=0,j=m;j<L.length;i++,j++)
//    {
//        int x=L.elem[j];
//        for(int k=j;k>i;k--)
//        {
//            L.elem[k]=L.elem[k-1];
//        }
//        L.elem[i]=x;
//    }
//}
void invert(Sqlist&L,int s,int t)
{
    for(int i=s,j=t;i<j;i++,j--)
    {
        int w=L.elem[i];
        L.elem[i]=L.elem[j];
        L.elem[j]=w;
    }
}
void exchange(Sqlist&L,int m)
{
    int n=L.length-m;
    invert(L,0,L.length-1);
    invert(L,0,n-1);
    invert(L,n,n+m-1);
}
void print(Sqlist&L)
{
    for(int i=0;i<L.length;i++)
    {
        if(i==0)printf("%d",L.elem[i]);
        else printf(" %d",L.elem[i]);
    }
    printf("\n");
}
int main()
{
    int n;
    scanf("%d",&n);
    Sqlist L;
    while(n--)
    {
        int len,m;
        InitList(L);
        scanf("%d%d",&len,&m);
        for(int i=0;i<len;i++)
        {
            int w;
            scanf("%d",&w);
            ListInsert(L,i,w);
        }
        exchange(L,m);
        print(L);
    }
    return 0;
}

您可能感兴趣的与本文相关的镜像

Stable-Diffusion-3.5

Stable-Diffusion-3.5

图片生成
Stable-Diffusion

Stable Diffusion 3.5 (SD 3.5) 是由 Stability AI 推出的新一代文本到图像生成模型,相比 3.0 版本,它提升了图像质量、运行速度和硬件效率

顺序表元素逆序常见的实现方法有以下几种: ### 交换元素法 该方法通过依次交换顺序表中对称位置元素来实现逆序。具体步骤为先确定元素个数`length`,也就是表的长度,将第`(length - 1)`个元素给中间变量`temp`,再将前者元素`i`赋给后者元素,最后将`temp`赋给前者元素,完成前后元素互换,通过`for`循环语句完成整个表中元素的逆序。交换`L.length / 2`次即可完成逆序操作。示例代码如下(C语言): ```c #include <stdio.h> #define MAX_SIZE 100 typedef struct { int data[MAX_SIZE]; int length; } SeqList; void Reverse(SeqList *L) { int n; for (int i = 0; i < L->length / 2; i++) { n = L->data[i]; L->data[i] = L->data[L->length - i - 1]; L->data[L->length - i - 1] = n; } } int main() { SeqList L; L.length = 10; for (int i = 0; i < L.length; i++) { L.data[i] = i + 1; } printf("原顺序表内容为:\n"); for (int i = 0; i < L.length; i++) { printf("data[%d]=%d\n", i, L.data[i]); } Reverse(&L); printf("顺序表逆序内容为:\n"); for (int i = 0; i < L.length; i++) { printf("data[%d]=%d\n", i, L.data[i]); } return 0; } ``` 上述代码中,`Reverse`函数通过循环交换对称位置元素,实现了顺序表的逆序操作。 ### 双游标法 利用两个游标`i`和`j`,`i`从零开始遍历,`j`从最后一个元素开始遍历,然后利用一个临时空间`value`,先把其中一个保存到`value`,防止在复制中`i`或`j`中的消失,之后依次复制元素,重复以上步骤,直到`i >= j`。示例代码如下(C语言): ```c #include <stdio.h> #define MAX_SIZE 100 typedef struct { int Data[MAX_SIZE]; } SqList; void ReversedList(SqList* L, int Length1, int Length2) { int i = Length1; int j = Length2 - 1; int value = '\0'; while (i <= j) { value = L->Data[i]; L->Data[i] = L->Data[j]; L->Data[j] = value; i++; j--; } } int main() { SqList L; int length = 10; for (int i = 0; i < length; i++) { L.Data[i] = i + 1; } ReversedList(&L, 0, length); for (int i = 0; i < length; i++) { printf("%d ", L.Data[i]); } return 0; } ``` 上述代码中,`ReversedList`函数利用双游标和临时变量,实现了指定范围元素的逆序操作。 ### Java语言实现 在Java中,可以通过定义一个`SqList`类,在其中实现`reverse`方法来完成顺序表的逆序。示例代码如下: ```java import java.util.Scanner; class SqList { int[] listElem; int curLen; public SqList() { Scanner sc = new Scanner(System.in); this.listElem = new int[100]; int n = sc.nextInt(); for (int i = 0; i < n; i++) { this.listElem[i] = sc.nextInt(); } this.curLen = n; } public void display() { for (int i = 0; i < this.curLen; i++) { System.out.print(this.listElem[i] + " "); } } public void reverse() { for (int i = 0; i < this.curLen / 2; i++) { int temp = this.listElem[i]; this.listElem[i] = this.listElem[this.curLen - i - 1]; this.listElem[this.curLen - i - 1] = temp; } } } public class Main { public static void main(String args[]) { SqList L = new SqList(); L.reverse(); L.display(); } } ``` 上述Java代码中,`SqList`类的`reverse`方法通过交换对称位置元素,实现了顺序表的逆序操作。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值