2021-09-27 单链表

最新推荐文章于 2022-05-07 23:15:48 发布
最新推荐文章于 2022-05-07 23:15:48 发布
阅读量74 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45676126/article/details/120505918
版权
这篇博客介绍了链表操作的各种练习，包括递归删除指定值节点、删除所有值为x的节点、逆序输出链表、删除最小值节点、链表逆置、升序排序、删除指定范围元素、查找公共节点、升序删除节点以及按奇偶分割链表。通过这些实例展示了链表操作的基本技巧和方法。
摘要由CSDN通过智能技术生成

单链表操作

抽象数据类型

//
// Created by 民 on 2021/9/26.
//
#include <iostream>

using namespace std;

typedef int Elem;

typedef struct LNode{
    Elem data;
    struct LNode* next;
}LNode,*LinkList;
//单链表
void Init_LinkList(LinkList &L){
    LNode *node = new LNode;//头结点
    node->data = 0;//存放表长
    node->next=NULL;
    L = node;
}
//获取长度
int Length(LinkList L){
    int len = 0;
    LNode *current = L->next;    //获取第一个节点
    while (current){
        len++;
        current=current->next;
    }
    return len;
}
//头插法
void head_insert_LinkList(LinkList &L){
    for (int i = 0; i < 10; ++i) {
        Elem e;
        LNode *node = new LNode ();
        cin>>e;
        node->data = e;
        node->next = L->next;
        L->next=node;
        L->data+=1;
    }
}
//尾插法
void tail_insert_LinkList(LinkList &L){
    LNode *tail=L;
    for (int i = 0; i < 10; ++i) {
        Elem e;
        LNode *node = new LNode ();
        cin>>e;
        node->data = e;
        node->next = NULL;
        tail->next = node;
        tail = node;
        L->data+=1;
    }
}
//输出链表
void print_LinkList(LinkList L){
    LNode *current = L->next;
    while (current){
        cout<<current->data<<" ";
        current = current->next;
    }
    cout<<endl;
}
//按序号查找节点
LNode *getElem(LinkList L,int i){
    int j=1;
    LNode *current = L->next;
    if (i==0)return L;
    if (i<0)return NULL;
    while (current&&j<i){
        current=current->next;
        j++;
    }
    return current;
}
//按值查找节点
LNode *LocateElem(LinkList L,Elem e){
    LNode *current = L->next;
    while(current && current->data!=e){
        current = current->next;
    }
    return current;
}
//插入指定位置-前插
void Insert_LinkList_head(LinkList &L,int pos,Elem e){
    LNode *node = new LNode;
    node->data = e;

    LNode *prior = getElem(L,pos-1);
    if (!prior)return;
    node->next = prior->next;
    prior->next = node;

}
//插入指定位置-前插
void Insert_LinkList_tail(LinkList &L,int pos,Elem e){
    LNode *node = new LNode;
    node->data = e;

    LNode *prior = getElem(L,pos);
    if (!prior)return;
    node->next = prior->next;
    prior->next = node;
}
void delete_LinkList(LinkList &L,int pos){
    LNode *prior = getElem(L,pos-1);
    if (!prior){return;}
//    prior->next = prior->next->next;
    LNode *q = prior->next;
    prior->next = q->next;
    delete q;
}

int main(){
    LinkList L1,L2,L3;
    Init_LinkList(L1);
    Init_LinkList(L2);
    Init_LinkList(L3);
    head_insert_LinkList(L1);
    int len = Length(L1);
    cout<<"L1的长度："<<len<<endl;
    Insert_LinkList_tail(L1,5,16);
    delete_LinkList(L1,2);
    print_LinkList(L1);


    tail_insert_LinkList(L2);
    len = Length(L2);
    cout<<"L2的长度："<<len<<endl;
    Insert_LinkList_head(L2,5,16);
    delete_LinkList(L2,2);
    print_LinkList(L2);

}

相关练习

第一题、递归删除值为x的节点


void del_x(LinkList &L,Elem e){
    LNode *p = NULL;
    if (L == NULL)return;
    if (L->data == e){
        p = L;
        L = L->next;
        delete p;
        del_x(L,e);
    } else{
        del_x(L->next,e);
    }
}
void test_1(){
    LinkList L;
    Init_LinkList(L);
    head_insert_LinkList(L);
    print_LinkList(L);
    del_x(L->next,2);
    print_LinkList(L);
}

第二题：带头结点单链表，删除所有值为x的节点

//法一：非递归
void del_x_1(LinkList &L,Elem e){
    LNode *current = L->next,*prior = L,*p=NULL;
    while(current){
        if (current->data == e){
            p = current;
            prior->next = current->next;
            current = prior->next;
            delete p;
        } else{
            prior = current;
            current = prior->next;
        }
    }
}

void test_2(){
    LinkList L;
    Init_LinkList(L);
    head_insert_LinkList(L);
    print_LinkList(L);
    del_x_1(L,2);
    print_LinkList(L);
    del_x(L,2);
    print_LinkList(L);
}

第三题：逆序输出链表


void reverse_print(LinkList L){
    LinkList L1;
    Init_LinkList(L1);
    LNode *current = L->next;
    while (current){
        LNode *p = new LNode ;
        p->data = current->data;
        p->next = L1->next;
        L1->next = p;

        current = current->next;
    }
    LNode *q = L1->next;
    while(q){
        cout<<q->data<<" ";
        q=q->next;
    }
    cout<<endl;
}

void test_3(){
    LinkList L;
    Init_LinkList(L);
    head_insert_LinkList(L);
    print_LinkList(L);
    reverse_print(L);
}

第四题：删除带头节点单链表min


void del_min(LinkList &L){
    LNode *current = L->next,*prior = L,*min = current,*min_pri=prior;
    while (current){
        if (current->data < min->data){
            min = current;
            min_pri = prior;
        }
        prior = current;
        current = prior->next;
    }
    min_pri->next = min->next;
    delete min;
}

void test_4(){
    LinkList L;
    Init_LinkList(L);
    head_insert_LinkList(L);
    print_LinkList(L);
    del_min(L);
    print_LinkList(L);
}

第五题：链表逆置


void reverse(LinkList &L){
    LNode *p=L->next,*r=NULL;
    L->next = NULL;
    while(p){
        r = p->next;
        p->next = L->next;
        L->next = p;
        p = r;
    }
    print_LinkList(L);
}
void test_5(){
    LinkList L;
    Init_LinkList(L);
    head_insert_LinkList(L);
    print_LinkList(L);
    reverse(L);
}

第六题、使链表升序


LNode *get_Elem_By_x(LinkList L,Elem e){
    LNode *current = L->next;
    LNode *prior = L;
    if (!current)return L;
    while (current!=NULL){
        if (current->data>=e){
            return prior;
        } else{
            prior = current;
            current = prior->next;
        }
    }
    return prior;
}
void sort_asc(LinkList &L){
    LNode *p = L->next,*r=NULL;
    L->next = NULL;
    while (p){
        r = p->next;
        LNode *node = get_Elem_By_x(L,p->data);
        p->next=node->next;
        node->next=p;
        p = r;
    }
}

//解法二：排序后尾插
void sort(LinkList &L){
    int len = Length(L);
    int A[len];
    int i=0;
    LNode *p = L->next;
    while (p){
        A[i++]=p->data;
        p=p->next;
    }
    LNode *tail = L;
    sort(A,A+len);
    for (int j = 0; j < len; ++j) {
        LNode *node = new LNode ;
        node->data = A[j];
        node->next = NULL;
        tail->next = node;
        tail = node;
    }

}


void test_6(){
    LinkList L;
    Init_LinkList(L);
    head_insert_LinkList(L);
    print_LinkList(L);
//    sort_asc(L);
//    print_LinkList(L);
    sort(L);
    print_LinkList(L);
}

第七题、删除无序链表中介于给定两个值之间的元素

void delete_elem_from_to(LinkList &L , Elem from,Elem to){
    LNode *prior = L,*current = L->next;
    while (current){
        if (current->data>=from && current->data<=to ){
            LNode *tmp = current;
            prior->next = current->next;
            current = current->next;
            delete tmp;
        } else{
            prior = current;
            current = current->next;
        }
    }
}

void test_7(){
    LinkList L;
    Init_LinkList(L);
    head_insert_LinkList(L);
    print_LinkList(L);
    delete_elem_from_to(L,5,10);
    print_LinkList(L);
}

第八题、找到两个节点的公共节点


LNode * find_common_node(LinkList L1, LinkList L2){
    LNode *maxNode,*minNode;
    int max=0,min=0;
    //1、找到min，max长度以及maxNode，minNode
    if (Length(L1)> Length(L2)){
        max = Length(L1);
        min = Length(L2);
        maxNode = L1->next;
        minNode = L2->next;
    } else{
        max = Length(L2);
        min = Length(L1);
        maxNode = L2->next;
        minNode = L1->next;
    }
    //2、将当前遍历节点移动至长度相同的位置
    while (max > min){maxNode = maxNode->next;max--;}
    //3、找共同节点
    while (maxNode){
        if (maxNode == minNode){return maxNode;}
        else{
            maxNode = maxNode->next;
            minNode = minNode->next;
        }
    }
    return NULL;
}

void test_8(){
    LinkList L,L2;
    Init_LinkList(L);
    Init_LinkList(L2);
    head_insert_LinkList(L);
    print_LinkList(L);
    head_insert_LinkList(L2);
    L2->next->next->next->next->next->next=L->next->next->next->next;
    print_LinkList(L2);

    LNode * node = find_common_node(L,L2);
    cout<<node->data<<endl;
}

第九题、升序删除节点

void delete_node_asc(LinkList &L){
    while (Length(L)>0){
        LNode *minPri = L,*min = L->next,*current = min,*current_pri=minPri;
        while (current){
            if (current->data < min->data){
                minPri = current_pri;
                min = current;
            }
            current = current->next;
        }
        cout<<"删除"<<min->data<<" ";
        minPri->next = min->next;
    }
    cout<<endl;
}
void test_9(){
    LinkList L;
    Init_LinkList(L);
    head_insert_LinkList(L);
    print_LinkList(L);
    delete_node_asc(L);
}

第十题：将链表按奇偶查分成两个链表

void divide_LinkList(LinkList &L1,LinkList &L2){
    int i = 1;
    LNode *current = L1->next,*L2_tail=L2,*L1_pri = L1;
    while (current){
        if (i%2==1){
            L1_pri = current;
            current = current->next;
        } else{
            L1_pri->next = current->next;
            current->next = NULL;
            L2_tail->next = current;
            L2_tail = current;
            current = L1_pri->next;
        }
        i++;
    }
}
void test_10(){
    LinkList L,L2;
    Init_LinkList(L);
    Init_LinkList(L2);
    head_insert_LinkList(L);
    print_LinkList(L);
    divide_LinkList(L,L2);
    print_LinkList(L);
    print_LinkList(L2);
}
孤傲的比熊
关注
专栏目录
盘点那些必问的数据结构算法题之链表
Java面试精选的博客
07-03 372
0 概述 链表作为一种基础的数据结构，在很多地方会用到。如在Linux内核代码，redis源码，python源码中都有使用。除了单向链表，还有双向链表，本文主要关注单向链表(含部分循环链表题目，会在题目中注明，其他情况都是讨论简单的单向链表)。双向链表在redis中有很好的实现，也在我的仓库中拷贝了一份用于测试用，本文的相关代码在 这里。 https://github.com/shishujuan/data-structure-algorithms 1 定义 先定义一个单向链表结构，如下，定义了链表
BUUCTF PWN-堆题总结 2021-09-27
m0_56897090的博客
09-27 2073
文章目录整体分析-2021-09-27新角度TcacheUAFFile结构体HourseOfForceUnlink经验新角度ciscn_2019_final_5分析EXPTCACHEhitcon_2018_children_tcache分析EXPUAFwustctf2020_easyfast分析EXPACTF_2019_babyheap分析EXPgyctf_2020_some_thing_interesting分析EXPbjdctf_2020_YDSneedGrirlfrien分析EXPciscn_2019
C语言单向链表的逆序输出
热门推荐
沉在海里的鱼的博客
07-12 1万+
最近在学习链表，看到书上说可以采取每次在链表头部插入新增节点的方法，将链表逆序，也就是建立的链表节点内容与数据的输入顺序相反。我便来了兴趣，想着试试看，结果没搞懂，于是开始百度。看了几遍博客后终于是明白了，而后写作的兴趣又上来了。。。。一个初学者就算再怎么来了兴趣，也不可能写得很好，所以有不对的地方，欢迎大家指出！顺便这里附上一篇写得很好的博客：点击蓝色字体。我正是看了这篇博客才大概弄懂了链表逆序，还自己手画链表才理解的。 博主要讲的单链表逆序...
链表逆序的三大方法（Python实现）
qq_43300880的博客
05-07 2948
链表逆序的三大方法 更多文章代码详情，可以查看博主： GitHub地址：https://github.com/TheAlgorithm-SimpleChinese/Python 个人网站：https://www.iwtmbtly.com 假设给定一个带头结点的单链表，要将其逆序。 即如果单链表原来为head->1->2->3->4->5->6->7，那么逆序后变为 head->7->6->5->4->3->2->1。 有什
逆序输出链表（C语言）
m0_51456787的博客
07-21 2343
逆序输出链表描述格式样例题解及详细注释 描述 根据给定的数据建立一个由n（1≤n≤1000）个元素组成的链表，然后按逻辑顺序逆序输出其中所有的数据。 每个元素节点由两个域组成：第一个域存储数据，第二个域存储后继元素所在的位置。特别的，头结点的第一个域用来存储整个链表的长度。例如头结点（5， 3）表示长度为5，后继元素在3号位置；元素节点（14，7）表示数据值为14，后继节点在7号位置。如果后继指针为0则表示链表结束。 例如： （6， 6）（673， 4）（428， 1）（685， 2）（170， 0）（48
链表的增删改查及逆序输出
qq_46380537的博客
04-12 334
链表一、链表是什么？二、链表的定义及增删改查1.链表定义2.增删1.在链表尾增加节点2.删除指定数据的节点3.改查1.修改指定节点的值2.查找链表中是否有数据三、链表的逆序打印 一、链表是什么？ 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 二、链表的定义及增删改查 1.链表定义 单向链表具有两种元素，第一是数据域，第二为下一节点的指针域 代码如下（示例）： struct ListNode { int m_Value; ListNode *
字节跳动2021年4月面试算法题库
Erazer_Control
05-01 2477
本文汇总了牛客2021.4.1~2021.4.30 两个月的牛客面经考到的Leetcode题目 最终的高频题榜单数据可以在CodeTop题库（https://codetop.cc）查询，支持按部门、岗位分类筛选。 CodeTop已包括字节跳动、腾讯、美团、快手等十余家公司，覆盖100多个部门。 字节跳动 测试 https://www.nowcoder.com/discuss/629499 2021.04.01 自己搜打家劫舍II 字节跳动 测试 https:
Teddy van Jerry 的导航页
Teddy van Jerry的博客
08-28 2322
C++ 的学习经历 C++ 的下载 下载 C++ (Visual Studio 2019) 的步骤 C++ Primer(5th Edition) 【C++ Primer(5th Edition) Exercise】练习程序 - Chapter1（第一章） 【C++ Primer(5th Edition) Exercise】练习程序 - Chapter2（第二章） 【C++ Primer(5th Edition) Exercise】练习程序 - Chapter3（第三章） 【C++ Primer(5th E
字节跳动3月面试遇到的高频算法题
Erazer_Control
05-01 1227
本文汇总了牛客2021.3.1~2021.3.30 两个月的牛客面经考到的Leetcode题目 最终的高频题榜单数据可以在CodeTop题库（https://codetop.cc）查询，支持按部门、岗位分类筛选。 CodeTop已包括字节跳动、腾讯、美团、快手等十余家公司，覆盖100多个部门。 字节跳动 数据研发 https://www.nowcoder.com/discuss/602031 2021.03.01 有100个方格，每个上面有毒蘑菇和体力蘑菇，毒蘑菇减体力体力
数据结构[树形结构和森林]二叉树、
Janyi_的博客
12-12 2297
Author:JaneOnly300 Date:2021：12.6 Categories: 数据结构(专升本) 本章参考王卓数据结构与算法基础 树结构和森林一、树的定义树的定义树的基本术语森林二、二叉树的定义二叉树的特点二叉树的5中形态三、树和二叉树的抽象数据类型定义重要操作:四、二叉树的性质和存储结构1. 性质12. 性质二3. 性质三特殊性质的二叉树满二叉树定义特点完全二叉树判断是否为完全二叉树特点性质1性质2五、二叉树的存储结构1. 二叉树的顺序存储小练习3. 顺序存储的特点2. 二叉树的链式存储.
链表逆序输出 ---九度1511
weixin_30443747的博客
07-05 131
题目描述： 输入一个链表，从尾到头打印链表每个节点的值。 输入： 每个输入文件仅包含一组测试样例。 每一组测试案例包含多行，每行一个大于0的整数，代表一个链表的节点。第一行是链表第一个节点的值，依次类推。当输入到-1时代表链表输入完毕。-1本身不属于链表。 输出： 对应每个测试案例，以从尾到头的顺序输出链表每个节点的值，每个值占一行。 样例输入： ...
【链表】逆序输出
编程就是在计算机中反应世界
08-29 989
#include #include using namespace std; #define maxsize 100 #define null 0 typedef struct node { int data; struct node * next; }node, *linklist; int strtonum(string s) { int i=0,len=s.length(); i
单向链表的逆序输出（java）
m0_53160995的博客
06-24 1580
将单向链表逆序输出，方法有三种： a.遍历链表，将每个节点的内容存入一个数组中，然后逆序输出数组(最简单的做法) b.使用栈来逆序输出 c.直接将链表逆序然后输出 先介绍c方法： 1). 若链表为空或只有一个元素，则直接返回； 2). 设置两个前后相邻的指针p,q. 将p所指向的节点作为q指向节点的后继； 3). 重复2),直到q为空 4). 调整链表头和链表尾 示例：以逆序A->B-&gt...
链表的逆序输出（链表）
weixin_52827539的博客
05-20 1438
链表的逆序输出（链表） 题目描述 按数字输入顺序创建单链表。不可借助数组、容器，不可改变原链表、不可开辟新结点空间。编程实现单链表的逆序输出。 输入 测试次数t 每组测试数据一行，格式如下： 数据个数n，后跟n个整数 输出 对每组测试数据，逆序输出单链表。 示例输入 2 10 1 2 3 4 5 6 7 8 9 10 4 19 20 15 -10 示例输出 10 9 8 7 6 5 4 3 2 1 -10 15 20 19 #include<iostream> using namespace s
单链表就地逆置
lavor_zl的专栏
01-08 1万+
题目：有一个线性表（a1,a2,a3,...,an），采用带头节点的单链表L存储，设计一个算法将其就地逆置，线性表变为(an,...a3,a2,a1)。所谓“就地”指辅助存储空间为O（1）。 解题思路： 如果是顺序存储的话，我们很容易想到解题思路，利用1个辅助变量让第1个元素与第n个元素交换，然后再利用这个辅助变量让第2个元素与第n-1个元素交换，...最后利用这个辅助变量让第n/2个元素与第
实现单链表的就地逆置
lingxiao的博客
10-15 4582
头文件和宏定义#include<iostream> #include<stdio.h> #include<stdlib.h> #include<malloc.h> using namespace std; #define TURE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBL
设计一个算法，通过遍历一趟，将链表中所有结点的链接方向逆转，仍利用原表的存储空间
weixin_45672225的博客
11-03 1万+
题目：设计一个算法，通过遍历一趟，将链表中所有结点的链接方向逆转，仍利用原表的存储空间。 代码如下： void reverse(Linklist& L) { Linklist q,p=L->next;//p为图中1结点 L -> next = NULL;//对应图中1结点后继置空 while (p) { q = p->next;//q为p后一结点，和p同样会后移 p->next = L->next;//p结点后继改为头结点的后继，刚开始为NULL，.
Reverse a LinkedList 链表倒置
yx2008302080的专栏
06-16 517
两种方法倒置一个链表1. 递归亮点在于构建一个假的head：newHead，代码如下：class RecursivelyReverseLinkedList{ ListNode newHead = new ListNode(0); public ListNode reverseList(ListNode head) { if(head == null) {
单链表的逆序输出
厚积薄发的博客
06-23 1252
迭代和递归的方式: import java.nio.file.FileStore; import java.util.HashMap; /** * @Description: * @Param: * @return: * @Author: fuguowen * @date: 2019-06-16 18:34 * @email: fuguowen@fantaike.ai */...
DS单链表--存储结构与操作
最新发布
03-30
DS单链表是一种线性数据结构，它由若干个节点组成，每个节点包括数据域和指针域，其中数据域用于存储数据，指针域用于指向下一个节点。DS单链表的存储结构如下： ``` typedef struct ListNode { int val; struct ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值