SDUT程序二链表题目

最新推荐文章于 2022-08-18 11:19:30 发布
最新推荐文章于 2022-08-18 11:19:30 发布
阅读量134 收藏
点赞数
分类专栏： 题目答案 文章标签： 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_51335453/article/details/113663305
版权
  • 数据结构实验之链表一：顺序建立链表
#include <stdio.h>
#include <string.h>
#include <stdlib.h> 

struct node 
{
	int mode;
	struct node* pnext;
 };
 
 int main()
{
    int n,i;
    struct node*  head;
    struct node* tail;
    struct node* p;
	scanf("%d",&n);
	head=(struct node*)malloc(sizeof(struct node));
	head->pnext=NULL;
	tail=head;
	for(i=1;i<=n;i++)
	{
		p=(struct node*)malloc(sizeof(struct node));
		scanf("%d",&p->mode);
		p->pnext=NULL;
	    tail->pnext=p;
	    tail=p;
	 } 
	 p=head->pnext;
	 while(p!=NULL)
	 {
	 	printf("%d",p->mode);
	 	if(p->pnext!=NULL)
	 	{
	 		printf(" ");
		 }
		 else 
		 {
		 	printf("\n");
		 }
		 p=p->pnext;
	 }
	 return 0;
}
  • 数据结构实验之链表二：逆序建立链表
#include <stdio.h>
#include <stdlib.h>

struct node 
{
	int mode;
	struct node* pnext;
}*head,*p;

int main()
{
	int n,i;
	scanf("%d",&n);
	p=(struct node*)malloc(sizeof(struct node));
	p->pnext=NULL;
	for(i=0;i<n;i++)
	{
		head=(struct node*)malloc(sizeof(struct node));
	     scanf("%d",&p->mode);
	     head->pnext=p;
	     p=head;
	}
	while(p->pnext!=NULL)
	{
		printf("%d",p->pnext->mode);
		if(p->pnext->pnext!=NULL)
		{
			printf(" ");
		}
		else
		{
			printf("\n");
		}
		p=p->pnext;
	}
	return 0; 
}
  • 师–链表的结点插入
#include <iostream>

using namespace std;

struct node {
	int data;
	node *pnext;
};

void Insert(node* head, int m,int data1)
{
	node *p=head;
     while(m--&&p->pnext!=NULL)
     {
     	p=p->pnext;
	 }
	 node *ptr=new node;
	 ptr->data=data1;
	 ptr->pnext=p->pnext;
	 p->pnext=ptr;
}

void show(node *head)
{
	node *pe=head->pnext;
	while(pe!=NULL)
	{
		printf("%d ",pe->data);
		pe=pe->pnext;
	}
}

int main()
{
	int m,x;
	int n; 
	while(cin>>n){
		node *head=new node;
		head->pnext=NULL;
	    for(int i=1;i<=n;i++){
	    	scanf("%d%d",&m,&x);
	    	Insert(head,m,x);
		}show(head);
	}
	
	return 0;
}
  • 数据结构实验之链表七：单链表中重复元素的删除
#include <iostream>

using namespace std;

struct node{
	int data;
	node *next;
}; 


node *create(int n){
	node *head=new node;
	head->next=NULL;
	node* tail;
	tail=head;
	for(int i=1;i<=n;i++){
		node* p=new node;
		scanf("%d",&p->data);
		p->next=tail->next;
		tail->next=p;       //尾插法建立链表 
	}
	return head; 
}

void show(node *head){
	node *p;
	p=head->next;
	while(p!=NULL)
	{
		if(p->next==NULL)
		{printf("%d\n",p->data);
		p=p->next;
	}
		else{
			printf("%d ",p->data);
			p=p->next;
		}
	
	}
}

node * cut(node *head, int n){
	node *front;   //第一个指针用于外循环 
	node *back;    //第二个指针用于内循环 
	node *preback; //用作内循环指针的前一个元素的指针 便于元素的删除 
	front=head;
	back=front->next;
	preback=front;
	int flag;  //标记是否删除元素 
	while(front->next!=NULL)
	{
		
		while(back!=NULL)
		{flag=0; 
			if(back->data==front->data)
			{
				preback->next=back->next; //元素的删除 
				n--;    //元素总数-1 
				flag=1;
			}
			if(flag){
				back=back->next;
			}
			else{
			back=back->next;  
			preback=preback->next; 
			} //内循环元素向后推一个 
		}
		if(front->next==NULL) break;
		else{
		front=front->next;
		back=front->next;  //让内循环指针回归外循环指针的next 
		preback=front;
	}
	}
	cout<<n<<endl;
	return head;
}
int main()
{
	int n;
	cin>>n;
	node* head = create(n);
	printf("%d\n",n);
	show(head);
	node *head1=cut(head,n); 
	show(head1);
	return 0;
}
  • 数据结构实验之链表三：链表的逆置
#include <iostream>

using namespace std;

struct node{
	int data;
	node *next; 
};

node * create()
{
	int n;
	node *head,*tail,*p;
	head=new node;
	head->next=NULL;
	tail = head;
	while(~scanf("%d",&n)){
		if(n==-1) break;
		p= new node;
		p->data=n;
		p->next=tail->next;
		tail->next=p;
	}
	return head;
}

void show(node *head){
	node *p;
	p=head->next;
	while(p!=NULL)
	{
		if(p->next==NULL)
		{printf("%d\n",p->data);
		p=p->next;
	}
		else{
			printf("%d ",p->data);
			p=p->next;
		}
	
	}
}
	

int main(){
	node *head= new node;
	head=create();
	show(head);
	return 0;
    
}
  • 数据结构实验之链表四：有序链表的归并
#include <iostream>

using namespace std;

struct node {
	int data;
    node *next;
};
node *create(int n)
{
	int x;
	node *head=new node;
	node *tail;
	head->next=NULL;
	tail=head;
	for(int i=0;i<n;i++){
		cin>>x;
		node *p=new node;
		p->data=x;
		p->next=tail->next;
		tail->next=p;
		tail=p;
	}
	return head;
}

node *together_sort(node* head_1,node* head_2)
{
	node *tail;
	node * p=head_1->next;
	node * q=head_2->next; 
	tail=head_1;
	while(p!=NULL&&q!=NULL)
	{
		if(p->data>=q->data)
		{
			tail->next=q;
			tail=q;
			q=q->next;
		}
	    else if(p->data<q->data)
		{
			tail->next=p;
			tail=p;
			p=p->next;
		}
		if(q) tail->next=q;
		else tail->next=p;
	}
	return head_1;
	
}

void show(node *head)
{
	node *p=head->next;
	while(p!=NULL)
	{
		if(p->next==NULL)
		{
			printf("%d\n",p->data);
			p=p->next;
		}
		else{
			printf("%d ",p->data);
			p=p->next;
		}
	 } 
}
	
int main()
{
	int n,m;
	cin>>n>>m;
	node *head_1=create(n);
	node *head_2=create(m);
	head_1=together_sort(head_1,head_2);
	show(head_1);
	return 0;
}
  • 数据结构实验之链表五：单链表的拆分
#include <iostream>

using namespace std;

struct node{
	int data;
	node * next;
};

node *create(int n){
	node *head=new node;
	node *tail;
	head->next=NULL;
	tail=head;
	for(int i=0;i<n;i++)
	{
		node *p=new node;
		scanf("%d",&p->data);
		p->next=tail->next;
		tail->next=p;
		tail=p;
	}
	return head;
} 
node * dou(node * head1)
{
	int n=0;
	node* head=new node;
	node* tail;
	head->next=NULL;
	tail=head;
	node* p=head1->next;
	while(p!=NULL)
	{
		if(p->data%2==0)
		{
			node *q=new node;
			q->data=p->data;
			q->next=tail->next;
			tail->next=q;
			tail=q;
			n++;
		}
		p=p->next;
	}
	cout<<n<<' ';
	return head;
}

node * you(node * head1)
{
	int n=0; 
	node* head=new node;
	node* tail;
	head->next=NULL;
	tail=head;
	node* p=head1->next;
	while(p!=NULL)
	{
		if(p->data%2!=0)
		{
			node *q=new node;
			q->data=p->data;
			q->next=tail->next;
			tail->next=q;
			tail=q;
			n++;
		}
		p=p->next;
	}
	cout<<n<<endl;
	return head;
}

void show(node *head)
{
	node *p=head->next;
	while(p!=NULL)
	{
		if(p->next==NULL) printf("%d\n",p->data);
	    else printf("%d ",p->data);
	    p=p->next;
	}
}

int main()
{
	int n;
	cin>>n;
	node * head=create(n);
	node * head1,*head2;
	head1=dou(head);
	head2=you(head);
	show(head1);
	show(head2);
	return 0;
}
  • 数据结构实验之链表九：双向链表
#include <iostream>

using namespace std;

struct node{
	int data;
	node* front,*back;
};

node *creat(int n)
{
	node* head=new node;
	node * tail;
	head->front=NULL;
	head->back=NULL;
	tail=head;
	for(int i=0;i<n;i++){
		node * p=new node;
		scanf("%d",&p->data);
		p->back=NULL;
		tail->back=p;
		p->front=tail;
		tail=p;
	}
	return head;
}

void search(int x,node *head){
	 node *p=head->back;
        while(p->data!=x)
            p=p->back;
        if(p->front==head)
            printf("%d\n",p->back->data);
        else if(p->back==NULL)
            printf("%d\n",p->front->data);
        else
            printf("%d %d\n",p->front->data,p->back->data);
}

int main(){
	int n,m;
	int x;
	cin>>n>>m;
	node* head=creat(n);
	for(int i=0;i<m;i++)
	{
	cin>>x;
		 search(x,head);
		}
	return 0;
}
  • 约瑟夫问题
#include <iostream>
#include <malloc.h>

using namespace std;

struct node {
	int data;
	node *next;
}; 

node * create(int n)
{
	node *head=new node ;
	node *tail;
	head->data=1;
	head->next=NULL;
	tail=head;
	for(int i=2;i<=n;i++)
	{
		node *p=new node;
		p->data=i;
		p->next=NULL;
		tail->next=p;
		tail=p;
	 } 
	 tail->next=head;
	 return head;
 } 
 
int main()
{
	int n,m;
	cin>>n>>m;
	node *head=create(n);
	node *q,*p;
	q=head;
	while(q->next!=head)
	q=q->next;
	int con=0;
	while(q->next!=q)
	{
		p=q->next;
		con++;
		if(con==m)
		{
			q->next=p->next;
			free(p);
			con=0;
		}
		else q=p;
		
	}
	printf("%d",q->data);
	return 0;
}
  • 不敢死队问题
#include <iostream>
#include <malloc.h>
using namespace std;

struct node{
	int data;
	node *next;
};

node * create(int n)
{
	node *head=new node;
	node *tail;
	head->next=NULL;
	head->data=1;
	tail=head;
	for(int i=2;i<=n;i++)
	{
		node *p=new node;
		p->data=i;
		p->next=NULL;
		tail->next=p;
		tail=p;
	}
	tail->next=head;
	return head;
}

int main()
{
	int n;

	while(~scanf("%d",&n)&&n){
		node *head;
	    node *p,*q;
	    head=create(n);
		q=head;
		while(q->next!=head)
		q=q->next;
		int con=0,ans=0;
		while(q->next!=q)
		{
			p=q->next;
			con++;
			if(con==5){
				if(p->data==1)
				break;
				q->next=p->next;
				free(p);
				con=0;
				ans++;
			}
			else q=p;
		}
		printf("%d\n",ans+1);
	}
	return 0;
}
新手向链表及其基本操作的代码实现（C++）
松鼠的一巴掌
09-16 1320
顺序表 顺序表：采用顺序存储的方式实现，把逻辑上相邻的元素存储在物理位置上也相邻的位置上。元素之间的关系由存储单元的邻接关系构成。 顺序表的静态实现：数组 顺序表的动态实现：分配内存 顺序表优点： 随机访问速度快，时间复杂度为O(1)，但插入和删除数据的时候需要移动元素，内存拷贝次数较多。 ...
SDUT---OJ《程序设计基础（B）II》实验2--链表
m0_46062697的博客
11-06 1790
A - 数据结构实验之链表一：顺序建立链表 Description 输入N个整数，按照输入的顺序建立单链表存储，并遍历所建立的单链表，输出这些数据。 Input 第一行输入整数的个数N； 第二行依次输入每个整数。 Output 输出这组整数。 Sample Input 8 12 56 4 6 55 15 33 62 Output 12 56 4 6 55 15 33 62 #include<stdio.h> #include<stdlib.h> st..
数据结构f
qq_53300039的博客
08-18 462
无
插入元素（c++）
weixin_46424226的博客
03-28 246
#include<iostream> using namespace std; typedef struct LNode { int data; struct LNode* next; }LNode, * LinkList; void CreatTail(LinkList& L, int n) { L = new LNode; L->next = NULL; LinkList r = L; while (n--) { LinkList p = new LNode.
c++基础知识——STL之链表
热门推荐
qq_59931372的博客
05-05 1万+
STLzhi链表，想学习c++ 的朋友可以看过来了，带你学会c++中的链表;
数据结构习题解析与实验指导第八章(排序)课后算法设计题
学者的博客
09-07 2044
1.试以单链表为例，实现简单的选择排序算法。 #include <iostream> using namespace std; struct Node { int data; Node* next; Node(int data = 0, Node* next = 0): data(data), next(next) { } }; /*题目要求的选择排序*/ void sort(Node& list) { Node* tail = &list; w
SDUT链表节点
最新发布
03-22
在山东理工大学 (SDUT) 的数据结构课程中，关于单链表的操作通常涉及基本的节点定义以及常见的链表处理方法。以下是基于题目描述中的需求所设计的一个完整的解决方案。 #### 节点类定义 为了构建单链表，首先需要...
SDUT链表pta
03-08
### 关于SDUT（山东理工大学）链表PTA练习题 #### 插入元素保持顺序表有序 对于已知递增有序的顺序表 \( L \)，为了将新元素 \( X \) 插入到合适的位置以维持其有序性，可以遍历整个列表找到第一个大于等于 \( X \)...
sdut pta数据结构链表
03-15
#### SDUT PTA 链表练习题分析 以下是几道典型的链表相关题目及其解法： --- #### 一元多项式加法与乘法 此题可以通过数组实现简单版本的解决方案，但由于未充分考虑负指数情况以及大规模数据处理需求，推荐使用...
数据结构实验之链表一：顺序建立链表 SDUT
weixin_43892738的博客
01-15 535
数据结构实验之链表一：顺序建立链表 SDUT Time Limit: 1000 ms Memory Limit: 65536 KiB Submit Statistic Problem Description 输入N个整数，按照输入的顺序建立单链表存储，并遍历所建立的单链表，输出这些数据。 Input 第一行输入整数的个数N； 第二行依次输入每个整数。 Output 输出这组整数。 Sample I...
数据结构实验之链表九：双向链表
°渐行渐远っ的博客
12-17 819
数据结构实验之链表九：双向链表 Time Limit: 1000 ms Memory Limit: 65536 KiB Submit Statistic Problem Description 学会了单向链表，我们又多了一种解决问题的能力，单链表利用一个指针就能在内存中找到下一个位置，这是一个不会轻易断裂的链。但单链表有一个弱点——不能回指。比如在链表中有两个节点A,B，他们的关系是B是A...
C++单链表递归逆序
liuhuiyan_2014的专栏
07-14 1369
#include <iostream> using namespace std; struct Node { int data; Node *next; Node(int d = int()) :data(d), next(NULL){} }; class List { public: List() { first = NULL; }
链表插入删除操作
hodd1988的专栏
01-05 2072
#include using namespace std; // 定义单向链表节点 struct ListNode { int data; ListNode* next; }; // end of ListNode // 将新节点插入链表头 void insertList(ListNode** head, int insertData) { if(head == NULL) { re
单链表输入输出
千苏的博客
07-19 4207
废话不说 单链表 头结点没数据 能输入输出char类型的数据 代码： #include<iostream> using namespace std; struct Node { int data; char name[80]; Node* next; }; Node* head, * p, * r; int x; char str[80]; int main() { cin &...
hdu 2128(bfs)
weixin_34262482的博客
06-05 137
题目链接 :http://acm.hdu.edu.cn/showproblem.php?pid=2128 思路：这题判重比较麻烦，我是这样做的：每个状态记录炸弹数目以及爆破点的坐标映射，还要有一个访问数组来标记已经取过的炸弹的位置（下次经过就不能再取了），由于要求时间最短，可以考虑优先队列。 1 #include&lt;iostream&gt; 2 #include&lt;cst...
华南师大19级计算机学院专硕上机题
热爱永不过时！
02-14 1899
一、 编程计算1/1!-1/3!+1/5!-…+(-1)(n+1)/(2n-1)! #include <iostream> using namespace std; int main() { int n; //输入n cin >> n; int t = 1; double num = 1; //定义变量 double sum = 0; double temp = num; while (n>0) { sum += 1 / temp * t
单链表的创建及对应操作（增删改查）
qq_45648856的博客
06-06 161
#include <iostream> using namespace std; typedef struct Node{ int data; struct Node* next; }node; //初始化链表 node* initList(){ node* head = (node*)malloc(sizeof(node)); node* temp = head;//临时节点记录头结点，不能直接使用头结点遍历，否则容易造成头结点地址丢失 for(in
根据先序，中序，求后序遍历#include<cstdio> #include<cstring> #include<iostream> using namespace std; struct Node...
weixin_30606669的博客
10-29 2090
#include<cstdio>#include<cstring>#include<iostream>using namespace std; struct Node{ char data; Node *lchild,*rchild;}; Node* createtree(string pre,string in){ Node *root=NULL; if...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值