线性表的应用

已于 2022-02-02 11:05:43 修改
阅读量376 收藏 2
点赞数
分类专栏： 数据结构 文章标签： 数据结构 c语言
于 2021-10-19 19:27:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50849959/article/details/120833259
版权

1:顺序表（有序）二路归并找成绩排名

总时间限制: 100000ms 内存限制: 10240kB
描述
学生成绩表A、B分别存储有n和m个学生的成绩（int整数），A、B中所有成绩分别以递减有序顺序表的方式存储，假设这n+m个成绩各不相同。利用二路归并的思路设计一个算法求这n+m个成绩中排名第k（k从1开始编号）的学生，输出其成绩。

输入
排名k
输出
排名k 成绩
或
k=排名k err
样例输入
2
样例输出
2 92

ac代码：

#include <stdio.h>
#define MAXSIZE 255 

typedef int ElemType;
			
typedef struct
{	ElemType stu_score[MAXSIZE];		
	int length;					
} StuSqList;			
			
void InitList(StuSqList &L)	
{
	L.length=0;
}
void DestroyList(StuSqList L)
{
}

void CreateList(StuSqList &L,ElemType a[],int n)
{
	int i,k=0;						
	for (i=0;i<n;i++)
	{
		L.stu_score[k]=a[i];				
		k++;						
	}
	L.length=k;						
}

int Topk(StuSqList A,StuSqList B,int k,ElemType &e)
{
int i=0,j=0,p=0;
	while(i<A.length&&j<B.length)
	{
		if(p==k)
		{
			return e;
		}
		else if(A.stu_score[i]>B.stu_score[j])
		{
			e=A.stu_score[i];
			i++;
			p++;
		}
		else if(A.stu_score[i]<B.stu_score[j])
		{
			e=B.stu_score[j];
			j++;
			p++;
		}
	}
	while(i<A.length&&p<k)
	{
		e=A.stu_score[i];
		i++;
		p++;
	}
	while(j<B.length&&p<k)
	{
		e=B.stu_score[j];
		j++;
		p++;
	}
	if(p==k)
	{
		return e;
	}
	else
	{
		return 0;
	}
}

int main()
{
	StuSqList L1,L2;
	ElemType a[]={98,86,85,78,75,72,69,62,52};
	int n=sizeof(a)/sizeof(a[0]);
	CreateList(L1,a,n);

	ElemType b[]={92,90,82,81,79,77,73,64,63};
	int m=sizeof(b)/sizeof(b[0]);
	CreateList(L2,b,m);

	ElemType e;
	int k;
	scanf("%d",&k);

	if (Topk(L1,L2,k,e))
		printf("%d %d",k,e);
	else
		printf("k=%d err",k);
	
	DestroyList(L1);
	DestroyList(L2);
}

变式：二路归并算法
已知A、B是两个递增有序顺序表，现想将他们归并为一个递增有序顺序表C

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])
		{
			C.data[k]=A.data[i];
			i++;
			k++;
		}
		else
		{
			C.data[k]=B.data[j];
			j++;
			k++;
		}
	}
	while(i<A.length)
	{
		C.data[k]=A.data[i];
		i++;
		k++;
	}
	while(j<B.length)
	{
		C.data[k]=B.data[j];
		j++;
		k++;
	}
	C.length=k;
}

本算法空间复杂度为o(1)，时间复杂度为o(m+n)，其中m和n分别为A和B两顺序表的长度。

2:求解约瑟夫问题

总时间限制: 1000ms 内存限制: 65536kB
描述
编写一个程序求解约瑟夫（Joseph）问题。有n个小孩围成一圈，给他们从1开始依次编号，从编号为1的小孩开始报数，数到第5个小孩出列，然后从出列的下一个小孩重新开始报数，数到第5个小孩又出列，…，如此反复直到所有的小孩全部出列为止，求最后出列的小朋友的编号。

输入
小朋友总人数
输出
最后出列的竞争者的编号
样例输入
90
样例输出
88

ac代码：

#include <malloc.h>
#include <iostream>
using namespace std;

typedef struct node
{
	int no;			//小孩编号
	struct node *next;		//指向下一个结点指针
} Child;

void CreateList(Child *&L, int n) //建立有n个结点的循环单链表
{
	int i;  Child *p, *tc;	//tc指向新建循环单链表的尾结点
	L = (Child *)malloc(sizeof(Child));
	L->no = 1;			//先建立只有一个no为1结点的单链表
	tc = L;
	for (i = 2; i <= n; i++)
	{
		p = (Child *)malloc(sizeof(Child));
		p->no = i;		//建立一个存放编号i的结点
		tc->next = p; tc = p;	//将p结点链到末尾
	}
	tc->next = L;			//构成一个首结点为L的循环单链表
}
void Joseph(int n)  //求解约瑟夫序列
{
	int i, j;  Child *L, *p, *q;
	CreateList(L, n);
	int m = 5;
	for(i=1;i<=n;i++)
	{
		p=L;j=1;
		while(j<4)
		{
			j++;
			p=p->next;
		}
		q=p->next;
		if(i==n)
		{
			printf("%d ",q->no);
		}//若想依次输出，只需去掉if条件
		p->next=q->next;
		free(q);
		L=p->next;
	}
}
int main()
{
	int n;
	cin>> n;
	Joseph(n);
	system("pause");
	return 0;
}

3:单链表-删除值重复节点

总时间限制: 10000ms 内存限制: 10000kB
描述
有一个非空整数单链表L，设计一个算法删除值重复的节点，多个值相同的节点仅保留第一个。

输入
8
1 4 1 2 2 1 3 4
输出
1 4 2 3
样例输入
8
1 4 1 2 2 1 3 4
样例输出
1 4 2 3

不知道为什么写了好多种方法都是dev能过，oj过不了，现把oj上ac的代码贴在这里

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef  int  Elemtype;
typedef struct LNode{
	Elemtype data;
	struct LNode *next;
}LNode,*Linklist;

void Init_Linklist(Linklist *L)
{
	*L=(Linklist)malloc(sizeof(LNode));
	assert(*L != NULL);
	(*L)->next=NULL;	
}

void Create_Linklist(Linklist *L)
{
	int n;
	LNode *p,*q;
	p = *L;
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		q=(Linklist)malloc(sizeof(LNode));
		assert( q != NULL);
		scanf("%d",&q->data);
		p->next=q;
		p=q;
	}
	p->next=NULL;
}

void delsame(Linklist *L)
{
	LNode *p,*q,*s;
	p = (*L)->next;

	for(p;p!=NULL;p=p->next)
	{
		s=p;                   
		for(q=p->next;q!=NULL; )
		{
			if(q->data==p->data)
			{
				s->next=q->next;
				free(q);
				q=s->next;
			}
			else
			{
				s=q;
				q=q->next;
			}
		}
	}
	
}

void Print_Linklist(Linklist *L)
{
	LNode *p;
	p = *L;
	while(p->next)
	{
		p=p->next;
		printf("%d ",p->data);
	}
	printf("\n");
}

int main()
{
	Linklist L;
	Init_Linklist(&L);
	Create_Linklist(&L);
	delsame(&L);
	Print_Linklist(&L);
	return 0;
}

再附上一个我看不出哪错了的写法，以后也许会发现问题所在。

#include<iostream>
#include<cstdlib>
using namespace std;
const int MAXSIZE=100;
#define ElemType char

typedef struct LNode{
	ElemType data;
	struct LNode *next;
}LinkNode;
bool InitList(LinkNode *&L)
{
	L=(LinkNode *)malloc(sizeof(LinkNode));
	if(!L)
		return false;
	L->next=NULL;
}
void CreateListF(LinkNode *&L,ElemType a[],int n)//头插法 
{
	LinkNode *s;
	int i;
	L=(LinkNode *)malloc(sizeof(LinkNode));
	L->next=NULL;
	for(i=0;i<n;i++)
	{
		s=(LinkNode *)malloc(sizeof(LinkNode));
		s->data=a[i];
		s->next=L->next;
		L->next=s;
	}
}
void CreateListR(LinkNode *&L,ElemType a[],int n)//尾插法 
{
	LinkNode *s,*r;
	int i;
	L=(LinkNode *)malloc(sizeof(LinkNode));
	r=L;
	for(i=0;i<n;i++)
	{
		s=(LinkNode *)malloc(sizeof(LinkNode));
		s->data=a[i];
		r->next=s;
		r=s;
	}
	r->next=NULL;
}
void DispList(LinkNode *&L)
{
	LinkNode *p=L->next;
	while(p!=NULL)
	{
		cout<<p->data<<" ";
		p=p->next;
	}
	cout<<endl;
}
int GetLength(LinkNode *L)
{
	int i=0;
	LinkNode *p=L->next;
	while(p!=NULL)
	{
		i++;
		p=p->next;
	}
	return i;
}
bool GetElem(LinkNode *&L,int i,ElemType &e)
{
	int j=0;
	LinkNode *p=L;
	while(j<i&&p!=NULL)
	{
		j++;
		p=p->next;
	}
	if(p==NULL)
		return false;
	else{
		e=p->data;
		return true;
	}
}
int LocateElem(LinkNode *&L,ElemType e)
{
	int i=1;
	LinkNode *p=L->next;
	while(p!=NULL&&p->data!=e)
	{
		p=p->next;
		i++;
	}
	if(p==NULL)
		return (0);
	else
		return (i);
}
bool ListEmpty(LinkNode *L)
{
	return(L->next==NULL);
}

bool ListInsert(LinkNode *&L,int i,ElemType e)
{
	int j=0;
	LinkNode *p=L,*s;
	while(j<i-1&&p!=NULL)
	{
		j++;
		p=p->next;
	}
	if(p==NULL)
		return false;
	else{
		s=(LinkNode *)malloc(sizeof(LinkNode));
		s->data=e;
		s->next=p->next;
		p->next=s;
		return true;
	}
		
}
bool ListDelete(LinkNode *&L,int i,ElemType &e)
{
	int j=0;
	LinkNode *p=L,*q;
	while(j<i-1&&p!=NULL)
	{
		j++;
		p=p->next;
	}
	if(p==NULL)
		return false;
	else
	{
		q=p->next;
		if(q==NULL)
			return false;
		e=q->data;
		p->next=q->next;
		free(q);
		return true; 
	}
}
void DestoryList(LinkNode *&L)
{
	LinkNode *pre=L,*p=L->next;
	while(p!=NULL)
	{
		free(pre);
		pre=p;
		p=pre->next;
	}
	free(pre);
}

int delsame(LinkNode *&L)
{ 
	LinkNode *p,*q,*s;
	p=L->next;
	while(p!=NULL && p->next!=NULL)
	{ 
		s=p; 
		q=p->next;
		while (q!=NULL)
		{ 
			if (q->data==p->data)
			{ 
				s->next=q->next;
				free(q);
				q=s->next;	
			} 
			else
			{ 
				s=q;
				q=q->next;
			}
		}
	p=p->next;
	}
}

int main()
{
	LinkNode *L;
	ElemType e;
	InitList(L);
	int n;
	char a[MAXSIZE];
	cin>>n;
	for(int i=0;i<n;i++)
	{
		cin>>a[i];
	}
	CreateListR(L,a,n);
	delsame(L);
	DispList(L); 
	DestoryList(L);
}

问了一个同学，他说把delsame函数用void更好，不过也不能上oj测了，不知道改完能不能过orz

浮鱼浮鱼
关注
专栏目录
数据结构学习笔记 --- 线性表 （应用举例）
JAVAweb学习
02-22 631
1. 引言  本文主要讲解一个线性表 （应用举例） 2. 具有实际意义的线性链表 #include "ds.h" using namespace std; typedef int ElemType; // 结点类型 typedef struct LNode{ ElemType data; struct LNode *next; }*Link,*Position;
实验1：线性表应用1
08-08
【实验一：线性表应用】的实验报告涵盖了线性表的基本操作，主要涉及C或C++编程语言，包括顺序存储结构和链式存储结构。实验目的是为了掌握线性表的构建、插入、删除、查找等基本操作，并利用这些操作解决实际问题，...
main_线性表应用_
09-30
线性表在实际应用中有着广泛的应用，如数组、链表等。本项目主要关注的是单链表在集合运算中的应用，包括求集合的差集、补集、并集和交集。下面将详细讲解这些概念以及如何通过单链表来实现它们。 首先，单链表是一...
线性表应用
10-25
线性表应用，用于学习数据结构等。初级水平
线性表应用二：队列（线性表实训）
韶言大雅
04-28 2921
用前面已经实现的线性表来实现一个整数队列（队列里的数据是整数）。共需要补全三个函数（也是队列的基本功能）： 判断队列空queueEmpty、入列enQueue和出列deQueue。 相关知识 队列是一种功能受限的线性表，具有先进先出的特性。队列仅允许从一头出列（这一头称为队列头），从另外一头入列（队列尾）。 入列操作是将结点插入到队列尾（该结点称为新的队列尾）； 出列操作是从队列头删除头结点，并获...
数据结构学习--线性表及其应用--链表
06-25
线性表是一种基础的数据结构，它是由n（n>=0）个相同类型元素构成的有限序列。在计算机科学中，线性表可以采用顺序存储结构或链式存储结构来实现。本篇主要讨论的是链式存储结构的线性表，也就是链表。 链表是一种...
线性表的实际应用
最新发布
pangyou3s的博客
12-25 435
线性表的实际应用
线性表的应用举例
HLXchamp的博客
05-04 739
一元多项式的表示及相加 1、一元多项式的表示： 一元多项式可按升幂的形式写成： Pn(x)P_n(x)Pn​(x) = p0p_0p0​ + p1p_1p1​x1x^1x1 + p2p_2p2​x2x^2x2 + … + pnp_npn​xnx^nxn， PiP_iPi​是指数i项的系数. 一元多项式Qm(x)Q_m(x)Qm​(x)可用线性表Q来表示. Q= (q0q_0q0​，q1q_1q1​...
线性表应用举例
zlz18225318697的博客
11-21 1588
编程实现学生成绩管理系统，次系统具有查询，修改，删除，增加和求全班各门课平均分的功能。要求采用顺序存储结构。 package com.test1;import java.awt.DisplayMode; import java.util.Scanner;public class StudentManageSystem extends SqList {//按顺序构造顺序表，其中参数maxS
线性表的小应用
青荣的博客
09-25 402
#include&lt;stdio.h&gt; #include&lt;malloc.h&gt; #include&lt;stdlib.h&gt; #define List_c 100 #define List_j 10 typedef struct { int *elem;//地址 int length;//长度 int listsize;//容量 } SqList; voi...
算法训练营 线性表的应用
qq_20144897的博客
02-10 764
线性表 线性表就像是一条线，不会分叉。线性表有唯一的开始和结束，除了第1个元素，每个元素都有唯一的直接前驱；除了最后一个元素，每个元素都有唯一的直接后继。 线性表有两种存储方式：顺序存储和链式存储。采用顺序存储的线性表被称为顺序表，采用链式存储的线性表被称为链表。 顺序表 顺序表是顺序存储方式，即逻辑上相邻的数据在计算机内的存储位置也是相邻的。在顺序存储方式中，元素存储是连续的，中间不允许有空。 顺序表可以分为静态分配和动态分配两种。 用定长数组存储的方法被称为静态分配： #define Maxsi
数据结构----线性表应用案例
qq_38198286的博客
06-28 3397
目录1.顺序表和链表的比较2.线性表的合并3.有序表的合并（1）顺序表实现（2）链表实现4.多项式运算5.稀疏多项式运算6.图书信息管理 1.顺序表和链表的比较 2.线性表的合并 3.有序表的合并 （1）顺序表实现 （2）链表实现 （前提是有序链表） 1，两个指针pa，pb指向待操作链表的首元结点，以la的头结点作为lc的的头结点，pc指向lc头结点。 2，当pa和pb都非空时，比较指向结点的data域，将data域较小的结点地址赋给pc指向结点的next域，再移动pc和较小结点指针，直
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值