《数据结构》专题1--顺序表

已于 2022-07-26 20:56:00 修改
阅读量573 收藏 3
点赞数
分类专栏： 数据结构 文章标签： 大数据 数据结构 c#
于 2022-07-16 22:38:15 首次发布
简 阳
本文链接：https://blog.csdn.net/qq_62268699/article/details/125776590
版权

C - 顺序表应用1：多余元素删除之移位算法

Description

一个长度不超过10000数据的顺序表，可能存在着一些值相同的“多余”数据元素（类型为整型），编写一个程序将“多余”的数据元素从顺序表中删除，使该表由一个“非纯表”（值相同的元素在表中可能有多个）变成一个“纯表”（值相同的元素在表中只保留第一个）。

要求：

1、必须先定义线性表的结构与操作函数，在主函数中借助该定义与操作函数调用实现问题功能；

2、本题的目标是熟悉顺序表的移位算法，因此题目必须要用元素的移位实现删除；

Input

第一行输入整数n，代表下面有n行输入；

之后输入n行，每行先输入整数m，之后输入m个数据，代表对应顺序表的每个元素。

Output

输出有n行，为每个顺序表删除多余元素后的结果

Sample

Input 

4
5 6 9 6 8 9
3 5 5 5
5 9 8 7 6 5
10 1 2 3 4 5 5 4 2 1 3

Output 

6 9 8
5
9 8 7 6 5
1 2 3 4 5

Hint

#include <stdio.h>
#include <stdlib.h>
#define max 10001
struct node
{
    int data[max];
    int length;
};
void init(struct node *p) //线性表初始化
{
    p->length=0;//指针变量 成员引用 用“->”
}
void putin(struct node *p,int k) //输入数据
{
    int i;
    p->length=k;
    for(i=1; i<=k; i++)
    {
        scanf("%d",&p->data[i]);
    }
}
void delete_same(struct node *p) //根据题目要求删除重复元素
{
    int i,j,k;
    for(i=1; i<=p->length; i++)
    {
        for(j=i+1; j<=p->length; j++)
        {
            if(p->data[i]==p->data[j])
            {
                for(k=j; k<=p->length; k++) //利用K记录重复元素的位置
                {
                    p->data[k]=p->data[k+1];//通过元素移位将重复元素删除
                }
                p->length--;//元素删除后 注意：线性表长度的改变
                j--;// 注意细节
            }
        }
    }

}
void putout(struct node *p) //输出＋格式控制
{
    int i;
    for(i=1; i<=p->length; i++)
    {
        if(i==p->length)
            printf("%d\n",p->data[i]);
        else printf("%d ",p->data[i]);
    }

}
int main()
{
    struct node *a;
    a=(struct node *)malloc(sizeof(struct node));
    init(a);
    int n,m;
    scanf("%d",&n);
    while(n--)
    {
        scanf("%d",&m);
        putin(a,m);
        delete_same(a);
        putout(a);
    }

    return 0;
}

B - 顺序表应用2：多余元素删除之建表算法

Description

一个长度不超过10000数据的顺序表，可能存在着一些值相同的“多余”数据元素（类型为整型），编写一个程序将“多余”的数据元素从顺序表中删除，使该表由一个“非纯表”（值相同的元素在表中可能有多个）变成一个“纯表”（值相同的元素在表中只保留第一个）。

要求：

1、必须先定义线性表的结构与操作函数，在主函数中借助该定义与操作函数调用实现问题功能；

2、本题的目标是熟悉在顺序表原表空间基础上建新表的算法，要在原顺序表空间的基础上完成完成删除，建表过程不得开辟新的表空间；

3、不得采用原表元素移位删除的方式。

Input

第一行输入整数n，代表下面有n行输入；

之后输入n行，每行先输入整数m，之后输入m个数据，代表对应顺序表的每个元素。

Output

输出有n行，为每个顺序表删除多余元素后的结果

Sample

Input 

4
5 6 9 6 8 9
3 5 5 5
5 9 8 7 6 5
10 1 2 3 4 5 5 4 2 1 3

Output 

6 9 8
5
9 8 7 6 5
1 2 3 4 5

Hint

#include <stdio.h>
#include <stdlib.h>
#define max 10001
struct node
{
    int data[max];
    int length;
};
void init(struct node *p) //线性表初始化
{
    p->length=0;//指针变量 成员引用 用“->”
}
void putin(struct node *p,int k) //输入数据
{
    int i;
    p->length=k;
    for(i=1; i<=k; i++)
    {
        scanf("%d",&p->data[i]);
    }
}
void delete_same(struct node *p) //根据题目要求删除重复元素 非 移位法
{
    int i,j;
    int t=1;
    for(i=1; i<=p->length; i++)
    {
        int flag=0;
        for(j=1; j<t; j++)
        {
            if(p->data[i]==p->data[j])
            {
                flag=1;
                break;
            }
        }
        if(flag==0)//如果无重复元素 将不重复的元素覆盖新表 （即不用开辟新空间）
        {

            p->data[t]=p->data[i];
            t++;
        }
    }
    p->length=t-1;
}

void putout(struct node *p) //输出＋格式控制
{
    int i;
    for(i=1; i<=p->length; i++)
    {
        if(i==p->length)
            printf("%d\n",p->data[i]);
        else printf("%d ",p->data[i]);
    }

}
int main()
{
    struct node *a;
    a=(struct node *)malloc(sizeof(struct node));
    init(a);
    int n,m;
    scanf("%d",&n);
    while(n--)
    {
        scanf("%d",&m);
        putin(a,m);
        delete_same(a);
        putout(a);
    }

    return 0;
}

D - 顺序表应用3：元素位置互换之移位算法

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

Output 

4 5 6 7 8 9 10 1 2 3
50 80 10 30 20

Hint

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

#include <stdio.h>
#include <stdlib.h>
#define max 1000001
struct node
{
    int data[max];
    int length;
};
void init(struct node *p) //线性表初始化
{
    p->length=0;//指针变量 成员引用 用“->”
}
void putin(struct node *p,int k,int l) //输入数据
{
    int i;
    p->length=k;
    for(i=1; i<=k; i++)
    {
        scanf("%d",&p->data[i]);
    }
    for(i=1; i<=l; i++)
    {
        p->data[k+i]=p->data[i];
    }
}

void putout(struct node *p,int l) //输出＋格式控制
{
    int i;
    for(i=l+1; i<=p->length+l; i++)
    {
        if(i==p->length+l)
            printf("%d\n",p->data[i]);
        else printf("%d ",p->data[i]);
    }

}
int main()
{
    int l;
    struct node *a;
    a=(struct node *)malloc(sizeof(struct node));
    int n,m;
    scanf("%d",&n);
    while(n--)
    {
        init(a);
        scanf("%d%d",&m,&l);
        putin(a,m,l);
        putout(a,l);
    }

    return 0;
}

顺序表应用4：元素位置互换之逆置算法

Description

一个长度为len(1<=len<=1000000)的顺序表，数据元素的类型为整型，将该表分成两半，前一半有m个元素，后一半有len-m个元素（1<=m<=len)，设计一个时间复杂度为O(N)、空间复杂度为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

Output 

4 5 6 7 8 9 10 1 2 3
50 80 10 30 20

Hint

注意：先将顺序表元素调整为符合要求的内容后，再做输出，输出过程只能用一个循环语句实现，不能分成两个部分。

#include <stdio.h>
#include <stdlib.h>
#define max 10001
struct node
{
    int data[max];
    int length;
};
void init(struct node *p) //线性表初始化
{
    p->length=0;//指针变量 成员引用 用“->”
}
void putin(struct node *p,int k) //输入数据
{
    int i;
    p->length=k;
    for(i=1; i<=k; i++)
    {
        scanf("%d",&p->data[i]);
    }

}
void nizhi(struct node *p,int s,int l)
{
    int i,j;
    int t;
    for(i=s,j=l; i<j; i++,j--)
    {
        t=p->data[j];
        p->data[j]=p->data[i];
        p->data[i]=t;
    }
}
void putout(struct node *p) //输出＋格式控制
{
    int i;
    for(i=1; i<=p->length; i++)
    {
        if(i==p->length)
            printf("%d\n",p->data[i]);
        else printf("%d ",p->data[i]);
    }

}
int main()
{
    int l;
    struct node *a;
    a=(struct node*)malloc(sizeof(struct node));
    int n,m;
    scanf("%d",&n);
    while(n--)
    {
        init(a);
        scanf("%d%d",&m,&l);
        putin(a,m);
        nizhi(a,1,m);//将整个数组逆置 L位置前后的数据进行整体的逆置交换
        nizhi(a,1,m-l);//将L位置前的数据逆置 局部恢复之前正确的顺序      注意：边界！
        nizhi(a,m-l+1,m);//将L位置后的数据逆置  局部恢复之前正确的顺序
        putout(a);
    }

    return 0;
}

I - 顺序表应用4-2：元素位置互换之逆置算法(数据改进）

Description

一个长度为len(1<=len<=1000000)的顺序表，数据元素的类型为整型，将该表分成两半，前一半有m个元素，后一半有len-m个元素（1<=m<=len)，设计一个时间复杂度为O(N)、空间复杂度为O(1)的算法，改变原来的顺序表，把顺序表中原来在前的m个元素放到表的后段，后len-m个元素放到表的前段。
注意：交换操作会有多次，每次交换都是在上次交换完成后的顺序表中进行。

Input

第一行输入整数len(1<=len<=1000000)，表示顺序表元素的总数；

第二行输入len个整数，作为表里依次存放的数据元素；

第三行输入整数t(1<=t<=30)，表示之后要完成t次交换，每次均是在上次交换完成后的顺序表基础上实现新的交换；

之后t行，每行输入一个整数m(1<=m<=len)，代表本次交换要以上次交换完成后的顺序表为基础，实现前m个元素与后len-m个元素的交换；

Output

输出一共t行，每行依次输出本次交换完成后顺序表里所有元素。

Sample

Input 

10
1 2 3 4 5 6 7 8 9 -1
3
2
3
5

Output 

3 4 5 6 7 8 9 -1 1 2
6 7 8 9 -1 1 2 3 4 5
1 2 3 4 5 6 7 8 9 -1

Hint

#include <stdio.h>
#include <stdlib.h>
#define max 100001
struct node
{
    int data[max];
    int length;
};
void init(struct node *p) //线性表初始化
{
    p->length=0;//指针变量 成员引用 用“->”
}
void putin(struct node *p,int k) //输入数据
{
    int i;
    p->length=k;
    for(i=1; i<=k; i++)
    {
        scanf("%d",&p->data[i]);
    }
}
void nizhi(struct node *p,int s,int l)
{
    int i,j;
    int t;
    for(i=s,j=l; i<j; i++,j--)
    {
        t=p->data[j];
        p->data[j]=p->data[i];
        p->data[i]=t;
    }
}
void putout(struct node *p) //输出＋格式控制
{
    int i;
    for(i=1; i<=p->length; i++)
    {
        if(i==p->length)
            printf("%d\n",p->data[i]);
        else printf("%d ",p->data[i]);
    }

}
int main()
{
    struct node *a;
    a=(struct node*)malloc(sizeof(struct node));
    int m;
    int t;
    scanf("%d",&m);
    init(a);
    putin(a,m);
    scanf("%d",&t);
    while(t--)
    {
        int l;
        scanf("%d",&l);
        nizhi(a,1,m);
        nizhi(a,1,m-l);
        nizhi(a,m-l+1,m);
        putout(a);
    }


    return 0;
}

若想用C++还不超时的话（80ms），则注意“ios::sync_with_stdio(false);”语句的添加。

#include <bits/stdc++.h>
#define max 1000001
using namespace std;

struct node
{
    int data[max];
    int length;
};
void init(struct node *p) //线性表初始化
{
    p->length=0;//指针变量 成员引用 用“->”
}
void putin(struct node *p,int k) //输入数据
{
    int i;
    p->length=k;
    for(i=1; i<=k; i++)
    {
       cin>>p->data[i];
    }
}
void nizhi(struct node *p,int s,int l)
{
    int i,j;
    int t;
    for(i=s,j=l; i<j; i++,j--)
    {
        t=p->data[j];
        p->data[j]=p->data[i];
        p->data[i]=t;
    }
}
void putout(struct node *p) //输出＋格式控制
{
    int i;
    for(i=1; i<=p->length; i++)
    {
        if(i==p->length)
           cout<<p->data[i]<<endl;
        else  cout<<p->data[i]<<" ";
    }

}
int main()
{ios::sync_with_stdio(false);//这段语句可以来打消iostream的输入、输出缓存 
//可以节省许多时间 使效率与scanf与printf相差无几
    struct node *a;
    a=(struct node*)malloc(sizeof(struct node));
    int m;
    int t;
   cin>>m;
    init(a);
    putin(a,m);
    cin>>t;
    while(t--)
    {
        int l;
        cin>>l;
        nizhi(a,1,m);
        nizhi(a,1,m-l);
        nizhi(a,m-l+1,m);
        putout(a);
    }


    return 0;
}

E - 顺序表应用5：有序顺序表归并

Description

已知顺序表A与B是两个有序的顺序表，其中存放的数据元素皆为普通整型，将A与B表归并为C表，要求C表包含了A、B表里所有元素，并且C表仍然保持有序。

Input

输入分为三行：
第一行输入m、n（1<=m,n<=10000）的值，即为表A、B的元素个数；
第二行输入m个有序的整数，即为表A的每一个元素；
第三行输入n个有序的整数，即为表B的每一个元素；

Output

输出为一行，即将表A、B合并为表C后，依次输出表C所存放的元素。

Sample

Input 

5 3
1 3 5 6 9
2 4 10

Output 

1 2 3 4 5 6 9 10

Hint

#include <stdio.h>
#include <stdlib.h>
struct node
{
    int data;
    struct node *next;
}*head1,*head2,*head3;
struct node *creat(int n)
{
    struct node *p,*q,*head;
    head=(struct node *)malloc(sizeof(struct node));
    head->next=NULL;
    p=head;
    int i;
    for(i=1; i<=n; i++)
    {
        q=(struct node *)malloc(sizeof(struct node ));
        scanf("%d",&q->data);
        q->next=NULL;
        p->next=q;
        p=q;
    }
    return head;
}
struct node *merge(struct node *head3,struct node *head1,struct node *head2)
{
    struct node *p,*q,*r;
    r=head3;
    p=head1->next;
    q=head2->next;
    while(q&&p)
    {
        if(p->data>q->data)
        {
            r->next=q;
            r=q;
            q=q->next;
        }
        else
        {
            r->next=p;
            r=p;
            p=p->next;
        }
    }
    if(q)
        r->next=q;
    if(p)
        r->next=p;
    return head3;
}
void show(struct node *head)
{
    struct node *q;
    q=head->next;
    while(q)
    {
        if(q->next)
            printf("%d ",q->data);
        else printf("%d\n",q->data);
        q=q->next;
    }

}
int main()
{
    head3=(struct node *)malloc(sizeof(struct node));
    int n,m;
    scanf("%d%d",&n,&m);
    head1=creat(n);
    head2=creat(m);
    head3=merge(head3,head1,head2);
    show(head3);
    return 0;
}

顺序表应用6：有序顺序表查询

Description

顺序表内按照由小到大的次序存放着n个互不相同的整数，任意输入一个整数，判断该整数在顺序表中是否存在。如果在顺序表中存在该整数，输出其在表中的序号；否则输出“No Found!"。

Input

第一行输入整数n (1 <= n <= 100000)，表示顺序表的元素个数；
第二行依次输入n个各不相同的有序非负整数，代表表里的元素；
第三行输入整数t (1 <= t <= 100000)，代表要查询的次数；
第四行依次输入t个非负整数，代表每次要查询的数值。

保证所有输入的数都在 int 范围内。

Output

输出t行，代表t次查询的结果，如果找到在本行输出该元素在表中的位置，否则本行输出No Found!

Sample

Input 

10
1 22 33 55 63 70 74 79 80 87
4
55 10 2 87

Output 

4
No Found!
No Found!
10

Hint

#include <stdio.h>
#include <stdlib.h>
#define max 100001
struct node
{
    int data[max];
    int length;
};
void init(struct node *p) //线性表初始化
{
    p->length=0;//指针变量 成员引用 用“->”
}
void putin(struct node *p,int k) //输入数据
{
    int i;
    p->length=k;
    for(i=1; i<=k; i++)
    {
        scanf("%d",&p->data[i]);
    }
}
void  find(struct node *p,int x)//二分查找
{
	int low, high, m;
	low = 1;
	high = p->length;
	while (low <= high)
	{
		m = (low + high) / 2;
		if (x < p->data[m])
		{
			high = m - 1;
		}
		else if (x > p->data[m])
		{
			low = m + 1;
		}
		else
		{
			printf("%d\n", m );
			return ;
		}
	}
	printf("No Found!\n");
	return ;
}
int main()
{
    struct node *a;
    a=(struct node*)malloc(sizeof(struct node));
    int m;
    int t;
    scanf("%d",&m);
    init(a);
    putin(a,m);
    scanf("%d",&t);
    while(t--)
    {
        int l;
        scanf("%d",&l);
        find(a,l);
    }


    return 0;
}

顺序表应用7：最大子段和之分治递归法

Description

给定n(1<=n<=50000)个整数（可能为负数）组成的序列a[1],a[2],a[3],…,a[n],求该序列如a[i]+a[i+1]+…+a[j]的子段和的最大值。当所给的整数均为负数时定义子段和为0，依此定义，所求的最优值为： Max{0,a[i]+a[i+1]+…+a[j]},1<=i<=j<=n。 例如，当（a[1],a[2],a[3],a[4],a[5],a[6]）=(-2,11,-4,13,-5,-2)时，最大子段和为20。

注意：本题目要求用分治递归法求解，除了需要输出最大子段和的值之外，还需要输出求得该结果所需的递归调用总次数。

递归调用总次数的获得，可以参考以下求菲波那切数列的代码段中全局变量count的用法：

#include
int count=0;
int main()
{
int n,m;
int fib(int n);
scanf("%d",&n);
m=fib(n);
printf("%d %d\n",m,count);
return 0;
}
int fib(int n)
{
int s;
count++;
if((n==1)||(n==0)) return 1;
else s=fib(n-1)+fib(n-2);
return s;
}

Input

第一行输入整数n(1<=n<=50000)，表示整数序列中的数据元素个数；

第二行依次输入n个整数，对应顺序表中存放的每个数据元素值。

Output

一行输出两个整数，之间以空格间隔输出：

第一个整数为所求的最大子段和；

第二个整数为用分治递归法求解最大子段和时，递归函数被调用的总次数。

Sample

Input 

6
-2 11 -4 13 -5 -2

Output 

20 11

Hint

#include<stdio.h>
int k=0;
int fenzhi(int a[],int l,int r)//关键代码
{
    int sum = 0,lsum = 0,rsum = 0,i;
    k++;
    if(l == r)
    {
        if(a[l]>0)
            sum = a[l];
        else
            sum = 0;
    }
    else
    {
        int mid = (l+r)/2;
        lsum = fenzhi(a,l,mid);
        rsum = fenzhi(a,mid+1,r);
        int s1=0,s2=0,s3=0;
        for(i=mid;i>=l;i--)
        {
            s3+=a[i];
            if(s3>s1) s1 = s3;
        }
        
        s3=0;
        for(i=mid+1;i<=r;i++)
        {
            s3+=a[i];
           if(s3>s2) s2 = s3;
        }
        
        sum=s1+s2;
        if(lsum>sum) sum=lsum;
        if(rsum>sum) sum=rsum;
    }
    return sum;
}
int main()
{
    int n,a[50010],t,i;
    scanf("%d",&n);
    for(i=0; i<n; i++)
    {
        scanf("%d",&a[i]);
    }
    t=fenzhi(a,0,n-1);//有返回值 所以用一变量来承接该值
    printf("%d %d\n",t,k);
    return 0;

}

顺序表应用8：最大子段和之动态规划法

Description

给定n(1<=n<=100000)个整数（可能为负数）组成的序列a[1],a[2],a[3],…,a[n],求该序列如a[i]+a[i+1]+…+a[j]的子段和的最大值。当所给的整数均为负数时定义子段和为0，依此定义，所求的最优值为： Max{0,a[i]+a[i+1]+…+a[j]},1<=i<=j<=n。 例如，当（a[1],a[2],a[3],a[4],a[5],a[6]）=(-2,11,-4,13,-5,-2)时，最大子段和为20。

注意：本题目要求用动态规划法求解，只需要输出最大子段和的值。

Input

第一行输入整数n(1<=n<=100000)，表示整数序列中的数据元素个数；

第二行依次输入n个整数，对应顺序表中存放的每个数据元素值。

Output

输出所求的最大子段和

Sample

Input 

6
-2 11 -4 13 -5 -2

Output 

20

Hint

#include <stdio.h>
#include <stdlib.h>
#define max 100001
struct node
{
    int data[max];
    int length;
};
void init(struct node *p) //线性表初始化
{
    p->length=0;//指针变量 成员引用 用“->”
}
void putin(struct node *p,int k) //输入数据
{
    int i;
    p->length=k;
    for(i=1; i<=k; i++)
    {
        scanf("%d",&p->data[i]);
    }
}
int summax(struct node *p)
{
    int i;
    int summax=0;
    int sum=0;
    for(i=1; i<=p->length; i++)
    {
        sum+=p->data[i];
        if(sum<0)
            sum=0;
        if(sum>=summax)
            summax=sum;
    }
    return summax;
}
int main()
{
    struct node *a;
    a=(struct node*)malloc(sizeof(struct node));
    int m;
    int t;
    scanf("%d",&m);
    init(a);
    putin(a,m);
    t=summax(a);
    printf("%d\n",t);
    return 0;
}

 题解：因为小于0的记为0，所以遍历一遍顺序表就可以。如果当前的sum小于0，那么加上一定不是最优解，所以直接舍去，sum=0。比较sum和当前summax的大小，记录最大值为summax。

简·阳
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构程序设计题典 李春葆1
08-08
全书分为15章，第1章是数据结构的概述。第2章~第15章以每章一个专题的形式，分别讨论了顺序表、单链表、双链表、栈、队列、串、广义表、数组、稀疏矩阵、树和二叉树
SDUT---OJ《数据结构与算法》实践能力专题训练1 顺序表
m0_46062697的博客
11-11 1459
A - 顺序表应用1：多余元素删除之移位算法 Description 一个长度不超过10000数据的顺序表，可能存在着一些值相同的“多余”数据元素（类型为整型），编写一个程序将“多余”的数据元素从顺序表中删除，使该表由一个“非纯表”（值相同的元素在表中可能有多个）变成一个“纯表”（值相同的元素在表中只保留第一个）。 要求： 1、必须先定义线性表的结构与操作函数，在主函数中借助该定义与操作函数调用实现问题功能； 2、本题的目标是熟悉顺序表的移位算法，因此题目必须要用元素的移位实现删除； Input
顺序表应用3：元素位置互换之移位算法
Godsight的博客
05-14 603
顺序表应用3：元素位置互换之移位算法 Time Limit: 1000ms   Memory limit: 570K  有疑问？点这里^_^ 题目描述 一个长度为len(1 注意：先将顺序表元素调整为符合要求的内容后，再做输出，输出过程只能用一个循环语句实现，不能分成两个部分。 输入  第一行输入整数n，代表下面有n行输入； 之后输入n行，每行先输入整数len与整数m(分别代表本表的
数据结构上机测试1：顺序表的应用
海森v
06-10 1889
数据结构上机测试1：顺序表的应用 Time Limit: 1000MS Memory limit: 65536K 题目描述 在长度为n（n 输入 第一行输入表的长度n； 第二行依次输入顺序表初始存放的n个元素值。 输出 第一行输出完成多余元素删除以后顺序表的元素个数； 第二行依次输出完成删除后的顺序表元素。 示例输入 12 5 2 5 3 3 4 2 5 7
Round2—顺序表
你倒是敲代码鸭.
09-09 1442
知识点： 顺序表也就是线性表的顺序表示，线性表的顺序表示指的是用一组连续的存储单元一次存储线性表的数据元素。 也就是说顺序表的逻辑关系与物理关系是一致的，各项数据元素在逻辑上相邻，在物理存储上也相邻。 由于顺序表的这种特性如果我们假设第一个元素的存储地址是LOC（a1），每个数据元素占用l个存储单元，那么我们可以知道： LOC（ai）= LOC（a1）+（i - 1）* l。 如果我们知...
顺序表应用5：有序顺序表归并
NTrinity的博客
10-12 263
Problem Description 已知顺序表A与B是两个有序的顺序表，其中存放的数据元素皆为普通整型，将A与B表归并为C表，要求C表包含了A、B表里所有元素，并且C表仍然保持有序。 Input  输入分为三行： 第一行输入m、n（1 第二行输入m个有序的整数，即为表A的每一个元素； 第三行输入n个有序的整数，即为表B的每一个元素； Output  输出为一
软件工程之专题九：数据结构知识
06-05
软件设计师考试大纲对数据结构部分的要求是熟练掌握常用数据结构和常用算法，因此，本专题从数据结构的概述出发，对基本的概念引出常用的数据结构类型的介绍和讲解，同时在讲解各种数据结构中间采用算法与数据结构相...
数据结构实验讲义
02-05
以实验形式分7个专题， 有实验目的、实验内容、源代码、测试数据，内容涵盖栈、数据查找、二叉树、哈希表、排序、遍历等等。此方法加强数据结构课程内容的掌握和实战操作使用能力。
数据结构常用算法.doc
07-11
专升本考试计算机专业《数据结构》算法专题 1．设计一个算法，计算单链表中数据域值为x的结点个数。 逐个查找单链表中的结点x，并计数。 int number(lnode *h,int x) { int n=0； while(h) {if(h->data==x) n++； h=...
javalruleetcode-Leetcode:LeetCode、Swordoffer、数据结构、算法的编程题
06-29
专题分类 1.1 数组 题目 备注 进度 so.1.二维数组的查找 so.13.调整数组顺序使奇数位于偶数前面 so.19.顺时针打印矩阵 so.28.数组中出现次数超过一半的数字 so.32.把数组排成最小的数 so.35.数组中的逆序对 so.40....
顺序表的应用
xinshishenchao的博客
07-26 445
数据结构上机测试1：顺序表的应用 Time Limit: 1000ms   Memory limit: 65536K  有疑问？点这里^_^ 题目描述 在长度为n（n 输入 第一行输入表的长度n； 第二行依次输入顺序表初始存放的n个元素值。 输出 第一行输出完成多余元素删除以后顺序表的元素个数； 第二行依次输出完成删除后的顺序表
C 顺序表应用2：多余元素删除之建表算法 SDUT
zhangzhaolin12的博客
05-06 417
Description 一个长度不超过10000数据的顺序表，可能存在着一些值相同的“多余”数据元素（类型为整型），编写一个程序将“多余”的数据元素从顺序表中删除，使该表由一个“非纯表”（值相同的元素在表中可能有多个）变成一个“纯表”（值相同的元素在表中只保留第一个）。 要求： 1、必须先定义线性表的结构与操作函数，在主函数中借助该定义与操作函数调用实现问题功能； 2、本题的目标是熟悉在顺序表原...
顺序表应用2：多余元素删除之建表算法
至臻求学，胸怀云月
07-27 1305
#include #include using namespace std; const int maxn=10010; typedef struct { int *emue; int lengh; }lis; void initlist(lis *L) { L->emue=new int [maxn]; L->lengh=0; } void creat(
【Redis7】10大数据类型之HyperLogLog类型
云泽野の编程日记
05-10 221
HyperLogLog是基于概率的数据结构，能够以极高的效率和极小的内存占用（固定12KB）来近似计算。个不同元素的基数，特别适合处理大规模数据集的统计计数，如网站独立访客（UV）计数等场景。类型,因为 HyperLogLog 只会根据输入元素来计算基数，而不会储存输入元素本身.Redis的HyperLogLog是一种高级数据结构，专门用于基数估算。
《大数据分析-数据仓库项目实战》学习笔记
LANXIAMAO的博客
05-09 906
文章部分内容参考《大数据分析-数据仓库项目实战》一书，仅供学习，喜欢可购买正版书籍，如有不妥请联系删除。
kde巡检文档
最新发布
王羲之的之的博客
05-13 35
此脚本采用python2.7。
数据结构----单向链表
03-27
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点只知道下一个节点的位置，而不知道前一个节点的位置。 单向链表的特点是插入和删除操作的效率较高，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值