2021-06-18单链表作业

最新推荐文章于 2023-11-05 17:45:41 发布
最新推荐文章于 2023-11-05 17:45:41 发布
阅读量697 收藏 5
点赞数 1
分类专栏： 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51589257/article/details/118017665
版权 
/*函数mergelist完成的功能是：将两个已按从小到大次序排序的不带头结点的链表合并成一个新的不带头结点的单链表,要合并的两个链表的头指针分别为ahead和bhead。请填空，将函数补充完整。*/

#include <iostream>

using namespace std;

struct LNode {

    int data;

    LNode *next;

};

typedef LNode *LinkList;

LinkList mergelist(LinkList ahead, LinkList bhead) 
{

    LinkList chead, ap, bp, cp;

    ap = ahead;

    bp = bhead;

    chead = NULL;

    while (    // ahead!=NULL&&bhead!=NULL    ) // 【 正确答案: ap&&bp 或 ap!=NULL&&bp!=NULL】) 
	{

        if (ap->data <= bp->data) 
		{

            if (chead == NULL)

                chead = cp = ap;

            else {

                cp->next = ap;

                cp = ap;

            }

                 ap=ap->next      //【 正确答案: ap=ap->next】;

        } 
		else 
		{

            if (chead == NULL)

                chead = cp = bp;

            else {

                cp->next = bp;

                cp = bp;

            }

                 bp=bp->next      //【 正确答案: bp=bp->next】;

        }

    }

        // cp=NULL     // 【 正确答案: cp->next=ap!=NULL?ap:bp 或 cp->next=bp!=NULL?bp:ap 或 cp->next=ap==NULL?bp:ap 或 cp->next=bp==NULL?ap:bp】;

    return (chead);

}

/*【输入形式】第一行：单链表中元素个数m

第二行：单链表中的m个整数

第三行：k值

【输出形式】倒数第k个元素的值（不存在倒数第k个元素输出"no"）

【样例输入】



【样例输出】

33

【样例说明】

输入：

5

13 24 50 33 56

6

输出：no*/
#include<iostream>
using namespace std;

struct Node
{
	int date;
	Node* next;
 } ;
 typedef Node* LinkList;
 
 
 void createList(LinkList& L,int m)  //一定要用引用。引用就是指针的指针，单用指针是不行的。 
 /*在函数调用时用指针或者引用做参数，表示把变量的地址传递给子函数，但是子函数只能修改指针所指变量的值，
 并不能修改指针的指向。如果想要修改指针的指向，就要用指针的指针，或者指针的引用。
 链表做参数时，其实就是头结点的指针，在遍历，查找这种操作做子函数时，链表不会发生改变，就用头结点的指针做参数就可以了。
 但在增加，修改，删除这种操作时，链表会发生改变，这就表示头结点指针所指的这块内存会发生改变，也就是指针的指向可能会发生改变，这种情况下就要用头指针的引用。 */
 {
 	L=new Node;//new一个头结点的地址给L；
	L->next=NULL; 
 	Node* r;//定义一个node 型指针，r是随链表每个节点移动的指针。 
 	r=L;//r先指向头节点。 
 	Node* p; //定义一个node 型指针 
 	for(int i=1;i<=m;i++)      //有等于号。 
 	{
 		p=new Node; //为p申请后面每个结点的地址。 
 		cin>>p->date;//写入p的date域里的值。 
		r->next=p;   //头结点的next域指向p; 
 		r=p;//指针r 移动到p的位置； 
	 }
	 r->next=NULL;//最后一个结点的next域指向空。 
 }
 
 void printList(Node* L)
 {
 	Node* p;
 	p=L->next;
	 for(p=L->next;p!=NULL;p=p->next) //最后一个结点的next域为空，最后一个结点不为空。 
	 cout<<p->date; 
	 cout<<endl; 
  } 
  
Node* getElem(Node* L,int k)
{
	int num=0;
	Node* p;
	p=L->next;
	if(p==NULL);
	num=0;
	while(p)
	{
		num++;
		p=p->next;
	}
	
	int n;
	n=num-k+1;
	int count=0;
	Node* p1;
	p1=L->next;
	while(p1)
	{
		count++;
		if(count==n)
		return p;
		else
		p1=p1->next;
	}
	
	
}
 int main()
 {
 	int m;
 	cin>>m;
 	Node* L; //只要一个头，后面的next域先不管。 
 	createList(L,m);
 	printList(L);
 	int k;
 	cin>>k;
 	Node* p=getElem(L,k);
 	if(p) 
	cout<<p->date;
	else
	cout<<"no"<<endl;


	return 0;
 }


——————————————————————————————
//自己练的
#include <iostream>
using namespace std;
struct Node {
    int data;
    Node *next;
};
typedef Node *LinkList;
void createList(LinkList &L,int n) { //因为要改变l,随意要用l的引用。 
    Node *p,*r;
    L=new Node;  //l是头指针 的地址 
    L->next=NULL;//头指针指向空。 
    r=L; //r指向头节点。 
    for(int i=1; i<=n; i++) {
        p=new Node;//新建节点，第一个节点，o开头的节点是头节点。 
        cin>>p->data;//给第一个结点的数据域赋值。 
        r->next=p;//让头结点的指针域指向第一个节点。 
        r=p;//r移动到p的位置。 
    }
    r->next=NULL;//让最后一个结点的指针域指向空； 
}
void printList(LinkList L) {//不改变l，不需要引用。 
    Node *p;
    p=L->next;//p指向头指针的next域，即第一个节点。 
    while(p) { //只要p指向的节点不为空， 
        cout<<p->data<<" ";
        p=p->next;//p指向p的next域，移动到下一个节点。 
    }
    cout<<endl;
}
Node* getElem(LinkList L,int k) //结构型函数。参数为头指针，和倒数第k的数。 
{
	int num=0;
	LinkList p1;                        //p1是一个node型指针。 
	p1=L->next;                         //p指向头指针的next域，即第一个节点。  
	if(p1==NULL)                        //p1==null,一个节点都没有。 
		num=0;
	while(p1){                          //只要p1不等于空。 
		num++;                          //计数。 
		p1=p1->next;                    //p1指向p1的next域，移动到下一个节点。  
	}                                   //num完成统计节点的个数。 
	
	int temp=0;
	int n=num-k+1;                      //共10个，倒数第三个，即第8个。8=10-3+1； 
	LinkList p;                         //p1是一个node型指针。 
	p=L->next;                          //p指向头指针的next域，即第一个节点。
	/*if(p==NULL)
		cout<<"no";
	if(k>m)
		cout<<"no";*/
	while(p)                             //只要p1不等于空。 
	{
		temp++;
		if(temp==n)
		{
			return p;
		}
		else
		p=p->next;                      //p指向p的next域，移动到下一个节点。 
	}
}

int main() {
    LinkList L;                         //单链表的头节点 
    int m,k;
    cin>>m;                             //m是单链表的长度 
    createList(L,m);                    // 建一个长为m，头节点为l的单链表 
    cin>>k;                             //k为倒数第k个节点。 
    Node *p=getElem(L,k);               //得到倒数第k个节点的地址后赋值给p. 
    if(p)
        cout<<p->data;                  //p不为null,则输出p的date域里的值。 
    else
        cout<<"no";                     //没找到p,输出“no". 
    return 0;
}


/*【问题描述】已知某带头结点的单链表中存放着若干整数，请删除该单链表中元素在[x, y]之间的所有结点，要求算法的时间复杂度为O(n)，空间复杂度为O(1)。

【输入形式】第一行：单链表中元素个数m

第二行：单链表中的m个整数

第三行：要删除的元素值所在区间[x,y]对应的x和y

【输出形式】

删除元素后的单链表中剩下的元素值

【样例输入】

5

13 24 50 33 56

30 50

【样例输出】

13 24 56

【样例说明】

【评分标准】*/


#include <iostream>
using namespace std;
struct Node {
    int data;
    Node *next;
};
typedef Node *LinkList;
void createList(LinkList &L,int n) {
    Node *p,*r;
    L=new Node;
    L->next=NULL;
    r=L;
    for(int i=1; i<=n; i++) {
        p=new Node;
        cin>>p->data;
        r->next=p;
        r=p;
    }
    r->next=NULL;
}
void printList(LinkList L) {
    Node *p;
    p=L->next;
    while(p) {
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;
}
void delElem(LinkList L, int x, int y) {//创建链表用了引用，删除链表某个元素没用引用。 
    Node *p,*q;//指针p随链表移动，q指向要删除的节点，最后删除p. 
    p=L;//p指向头节点，不指向头结点的next。 
    while(p->next) {
        if(p->next->data>=x&&p->next->data<=y) {
            q=p->next;//这个要先 。 
            p->next=q->next;//这个要后。 
            delete q;//最后删除q. 
        } else {
            p=p->next;
        }
    }
}

int main() {
    LinkList L;
    int m;
    int x,y;
    cin>>m;
    createList(L,m);
    cin>>x>>y;
    delElem(L,x,y);
    printList(L);
    return 0;
}



/*【问题描述】已知某带头结点的单链表中存放着若干整数，请找出这批整数的最大值。

【输入形式】

第一行：整数个数m

第二行：m个整数

【输出形式】

m个整数中的最大值

【样例输入】

5

13 24 50 33 56

【样例输出】56*/
#include <iostream>
using namespace std;
struct Node{
    int data;
    Node *next;
};
typedef Node *LinkList;
void createList(LinkList &L,int n) {
    Node *p,*r;
    L=new Node;
    L->next=NULL;
    r=L;
    for(int i=1; i<=n; i++) {
        p=new Node;
        cin>>p->data;
        r->next=p;
        r=p;
    }
    r->next=NULL;
}
int getMax(LinkList L) 
{
    LinkList p, pr;
    p = L->next;
    pr = p->next;
    while (pr) 
    {
        if (pr->data > p->data)
            p = pr;
        pr = pr->next;
    }
    return p->data;
}

int main(){
    int m;
    LinkList h;
    cin>>m;
    createList(h,m);
    cout<<getMax(h);
    return 0;
}



/*【问题描述】为从键盘终端输入的m个整数创建带头结点的有序单链表存储结构，使输入的数据元素在单链表中按照元素值递增有序。

【输入形式】

第一行：单链表中元素个数m

第二行：单链表中的m个整数

【输出形式】

按递增有序形式输出m个整数

【样例输入】

5

1 3 2 4 5

【样例输出】

1 2 3 4 5*/
#include <iostream>
using namespace std;
struct Node {
    int data;
    Node *next;
};
typedef Node *LinkList;
void createOList(LinkList &h,int n){
    Node *p,*pre;
    h=new Node;
    h->next=NULL;
    for(int i=1;i<=n;i++){
        p=new Node;           //p是新节点，边增边比。 
        cin>>p->data;
        pre=h;
        while(pre->next&&pre->next->data<p->data) //循环条件是（第一个）下一个节点存在并且 第一个结点的数据域的值小于新节点的数据域的值。 
		{
            pre=pre->next;                        //pre移动到下一个节点。 
        }
        p->next=pre->next;                        //p的next域存入pre下一个节点的地址。 
        pre->next=p;                             //pre的next域存入p的地址。 
    }
}
/*
第一次for循环；pre的next域为NULL,不执行while里面的循环。p的next域为空。pre的next域存入p的地址。即头节点后接入p. 
for(int i=1;i<=n;i++){
        p=new Node;           
        cin>>p->data;
        pre=h;           //每次循环pre都指向头节点，即从头开始一个一个对比选择插入。 
        p->next=pre->next;                        //p的next域为空。前后顺序要注意。 
        pre->next=p; 
	}
第二次for循环；
pre的next域不为空，假设第一个节点的数据域的值小于新节点的数据域的值，则执行while循环里的内容。pre指向第一个节点。新节点的next域存入第一个结点的next域的内容，第一个结点的next域存入新节点的地址。 
*/

void printList(LinkList L) {
    Node *p;
    p=L->next;
    while(p) {
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;
}
int main() {
    LinkList L;
    int m;
    cin>>m;
    createOList(L,m);
    printList(L);
    return 0;
}
刘秦001
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表的链式实现-----单链表
07-02
在实际应用中，线性表的实现方式多种多样，其中链式存储是一种常见的实现方法，而单链表是链式存储结构的一种基本形式。 单链表的每个元素称为节点，每个节点包含两部分：数据域和指针域。数据域用于存储元素的值，...
单链表-C++数据结构之单链表实现.zip
03-13
单链表是计算机科学中一种基础且重要的数据结构，它在C++中有着广泛的应用。在C++中实现单链表，需要理解链表的基本概念、节点结构以及相关的操作。以下是对这一主题的详细讲解： 1. **链表概念**： 链表是一种...
第4周项目3-单链表的应用（2）链表的连接
licoo0925的博客
09-20 265
问题及代码： /* * Copyright(c) 2016, 烟台大学计算机与控制工程学院 * All rights reserved. * 文件名称： * 作 者：路亚丽 * 完成日期：2016年 9月 20日 * 版 本 号：v1.0 * * 问题描述: 已知L1和L2分别指向两个单链表的头结点，且已知其长度分别为m、n，请设计算法将L2连接到L1的后面。实现这个算法，完成测试，
数据结构上机实验：单链表操作
weixin_33923148的博客
03-19 198
#include <iostream> #include <malloc.h> using namespace std; typedef struct Node { char c; struct Node *next; }*LinkList,LNode; //初始化单链表h LinkList Init(LinkList &a...
数据结构-单链表(Linked List)
Q75999的博客
01-02 332
#include <stdio.h> #include <stdlib.h> #define LIST_INIT_SIZE 10 #define LISTINCREMENT 100 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEAS...
第四周 项目1 建立单链表
lt1095862229的博客
09-21 265
定义单链表存储结构，用头插法和尾插法建立单链表，并显示建立好以后的结果。  　　请在下面代码的基础上开展工作： #include #include typedef int ElemType; typedef struct LNode //定义单链表结点类型 { ElemType data; struct LNode *next; //指向后继结点 }
一.单链表习题(1)
qq_26158965的博客
04-13 140
文章目录二.2王道课后题第一部分==1==代码(1)推荐演示结果代码(2)==2==代码演示结果代码(2)演示结果==3==代码演示结果==4==代码演示结果==5==代码(1)代码(2)演示结果==6==代码演示结果7代码演示结果代码演示结果 二.2王道课后题 第一部分 1 相当经典的一道题 一般来说,写递归函数,第一句是递归出口 引用是给变量取别名,实际是同一个变量 q=p 是两个变量,指向同一个位置而已. 断链的问题–引用可以解决,对于作题来说,可以每次都加上引用 一般来说,没有结点的增删,可
循环单链表-双链表_循环单链表-双链表_throat6v2_
09-30
循环单链表和双链表是数据结构中的基础概念，它们在计算机科学中扮演着重要角色，尤其是在处理线性数据序列时。这两种链表都属于动态数据结构，因为它们允许在运行时添加或删除元素，而不需要预先知道数据的大小。 ...
链表-使用PHP实现的单链表数据结构.zip
最新发布
03-13
单链表是由一系列节点组成的数据结构，每个节点包含两部分：数据域和指针域。数据域存储实际的值，而指针域则指向下一个节点的地址。在单链表的末尾，最后一个节点的指针域通常设置为`NULL`，表示链表的结束。 PHP...
数据结构---线性表之单链表（C语言）
03-28
单链表是数据结构中的一种基础类型，尤其在C语言编程中经常被使用。它是一种线性的、非连续的数据组织形式，每个元素称为节点，每个节点包含数据和一个指向下一个节点的指针。本篇文章将深入探讨单链表的创建、插入...
第四周 项目3 - 单链表应用
zikun6578的博客
09-28 365
/* 程序头部注释开始   * 程序的版权和版本声明部分   * Copyright (c) 2017, 烟台大学计算机学院学生   * All rights reserved.   * 文件名称：   danlianbao.cpp                             * 作    者：   胡俊超                             * 完成日
数据结构练习：单链表
一个搬运知识的笨小孩
10-23 340
方法一 直接使用指针的指针来保存头指针L，避免返回头结点的指针 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<malloc.h> typedef int ElemType; //创建结点结构体 typedef struct Node { //数据域 ElemType data; //指针域 struct Node* next; }LNode, * LinkList; //初始化单链表 //函数周期结束后..
线性表之链表复习（仅王道单链表题目）
至臻求学，胸怀云月
08-05 716
考研408复习，如发现任何错误，请私聊，不胜感谢 单链表代码已更新完毕。 如下： #include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;string&gt; #include &lt;cmath&gt; #include &lt;iomanip&gt; #include &lt;cstring&gt; usin...
【数据结构】单链表的基本操作
我的我的博客
08-18 207
单链表是线性表的链式存储。一般对于每一个节点都会有一个数据域和一个指针域，指针指向下一个节点的地址，所以在逻辑结构上相邻的节点，物理位置可能不是相邻的。 单链表一般会引入一个头结点用于同一处理空表和非空表。对于链表第一个节点的操作无异于其他节点，操作更加方便。 单链表的创建一般有头插法和尾插法。头插法在链表得头结点后插入，这就使得整个链表得顺序与插入时的顺序相反，尾插法在链表中创建了一个尾结点指针...
2021-05-18 每周一练 掌握数据结构（二）单链表的基本操作
worite001的博客
05-18 388
单链表的基本操作 实验环境：Visual C++ 实验目的： 1、掌握单链表的定义； 2、掌握单链表的基本操作，如建立、查找、插入和删除等。 实验内容： 定义一个包含学生信息（学号，姓名，成绩）的单链表，使其具有如下功能： 根据指定学生个数，逐个输入学生信息； 逐个显示学生表中所有学生的相关信息； 根据姓名进行查找，返回此学生的学号和成绩； 根据指定的位置可返回相应的学生信息（学号，姓名，成绩）； 给定一个学生信息，插入到表中指定的位置； 删除指定位置的学生记录； 统计表中学生个数
数据结构学习：单链表的基本操作总结
weixin_45632016的博客
07-24 453
数据结构学习：单链表的基本操作总结 #include <iostream> #include<stdlib.h> using namespace std; //定义单链表结点类型 struct LNode{ ElemType data; //结点的数据域，用来存放数据 struct LNode *next；//指针域，存放指向下一个结点的指针 }LNode *LinkList; //重命名 // 初始化单链表（带头结点） bool IntiList(LinkList
上机二——单链表
m0_75017568的博客
11-05 101
【问题描述】已知某带头结点的单链表中存放着若干整数，请删除该单链表中元素在[x, y]之间的所有结点，要求算法的时间复杂度为O(n)，空间复杂度为O(1)。【输入形式】三行，第一行：两个有序链表中元素的个数，第二行：第一个链表中的元素以空格间隔，第三行：第二个链表中的元素以空格间隔。【输入形式】三行，第一行：两个有序链表中元素的个数，第二行：第一个链表中的元素以空格间隔，第三行：第二个链表中的元素以空格间隔。第二行：单链表中元素的个数。【输出形式】合并后的没有重复元素的有序链表中的数据以空格间隔。
3046. 单向链表中的节点删除华师大oj
m0_68361357的博客
09-18 216
给定一个存储了若干个整数（个数范围：0 - 1000）的单向链表和一个整数 v，删除单向链表中所有值为 v 的节点。
《数据结构》上机实验(第二章)——线性表 Ⅳ
Miss Z的博客
08-04 1178
《数据结构》上机实验(第二章) Ⅲ 15. 已知两个链表A和B分别表示两个集合，其元素递增排列。编制函数，求A与B的交集，并存放于A链表中。 算法思想：第8题(2) 该题与14题的区别是，14题中要求不破坏A、B的结点，那么应该将结果放入新链表C中，而此题可以修改A、B中某条链表，从而不开辟新空间。14题的空间复杂度为：O(m+n)，其中m、n分别为两个链表的长度；该题的空间复杂度为：O(1)。 16. 两个整数序列A=a1,a2,a3,…,anA=a_1,a_2,a_3,…,a_nA=a1​,a2
6-1 带头结点的单链表就地逆置
03-27
要实现带头结点的单链表就地逆置，可以按照如下步骤进行： 1. 定义三个指针变量：p、q、r。其中，p指向头结点，q指向第一个结点，r指向第二个结点。 2. 将p->next指向NULL，表示链表只剩下头结点。 3. 依次将q、r...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值