链表

最新推荐文章于 2024-08-13 14:59:01 发布
最新推荐文章于 2024-08-13 14:59:01 发布
阅读量482 收藏
点赞数
分类专栏： C/C++数据结构 
1.构造链表
2.逆序打印链表
     实现方法：
          a.用stack实现
          b.用递归实现
     测试用例：
          没有节点，只有一个节点,有多个节点
3.在O(1)时间删除节点
     实现方法：
          复制被删除节点的下一个节点，然后删除next节点
     测试用例：
          null,单个节点,多个节点
4.返回链表中倒数第k个节点
     实现方法：
          用两个指针,间距为k找到第k个节点.
     测试用例：
          空链表,链表长度小于k,链表长度等于k,链表长度大于k
5.链表反转
     实现方法：
          三个指针，指向前一个节点，中间节点，后一个节点
     测试用例：
          空链表，单个元素链表，两个元素链表，多个元素链表
6.合并两个已经排序的链表
     实现方法：
          设置三个指针，第一个指向已合并的链表的尾部，剩下两个分别指向链表的头
     测试用例：
          两个空链表，一个空链表，没有空链表
7.两个链表的第一个公共节点
     实现方法：
          遍历两个链表长度，求出链表长度之差，将问题转化为4:寻找链表的第k个节点
     测试用例：
          两个空链表，一个空链表，没有公共节点，公共节点为头节点，
          公共节点为尾节点，公共节点为中间节点
[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
//list.h  
#ifndef __LIST__  
#define __LIST__  
  
struct link_node{  
    int m_val;  
    link_node *next;  
  
    link_node(int val,link_node* p){  
        m_val =val;  
        next = p;  
    }  
};  
  
class link_list {  
public:  
    link_list();  
    ~link_list();  
  
    /**  将节点插入到链表头 **/  
    void head_insert_node(link_node *p);  
  
    /**  将节点插入到链表尾**/  
    void tail_inster_node(link_node *p);  
  
    /**  插入链表节点 **/  
    void normal_insert_node(link_node* p,link_node *insert_node);  
  
    /**  逆序打印链表**/  
    void print_list_reserve();  
  
    /**   删除链表尾节点**/  
    void head_delete_node();  
  
    /**   删除链表头结点**/  
    void tail_delete_node();  
  
    /**  删除链表中p节点**/  
    void normal_delete_node(link_node* p);  
  
    /**   获取第链表第k个节点**/  
    link_node* get_kth_node(int k);  
  
    /**   创建链表节点**/  
    link_node* create_link_node(int val);  
  
    /**  反转链表 **/  
    void reserve_list();  
  
    /**  合并两个已排好序(非递增)的链表 **/  
    void merge_list(link_list *head);  
  
    /** 打印链表节点**/  
    void print_list();  
  
private:  
    link_node *phead;  
  
private:  
    /** 逆序打印链表--内部递归函数 **/  
    void print_list_reserve(link_node *);  
};  
#endif  
[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
//list.cpp  
#include <iostream>  
#include "list.h"  
  
/** 函数名：    link_list 
   *    功能描述：   构造函数 
   *    参数列表：   无 
   *    返回值  ：    
   */   
link_list::link_list ()  
    :phead(NULL)  
{  
    std::cout<<"构造函数"<<std::endl;  
}  
  
/** 函数名：    ~link_list 
   *    功能描述：   析构函数 
   *    参数列表：   无 
   *    返回值  ：    
   */   
link_list::~link_list()  
{  
    std::cout<<"析构函数"<<std::endl;  
    while ( phead  ){  
        head_delete_node();  
    }  
}  
  
/** 函数名：    ~head_insert_node 
   *    功能描述：   将节点插入到链表头 
   *    参数列表：   待插入节点 
   *    返回值  ：    
   */   
void link_list::head_insert_node(link_node *p)  
{  
    std::cout<<"将节点插入到链表头"<<std::endl;  
    if ( p ){  
        p->next = phead;  
        phead   = p;  
    }  
}  
  
/** 函数名：    tail_inster_node 
   *    功能描述：   将节点插入到链表尾 
   *    参数列表：   待插入节点 
   *    返回值  ：    
   */   
void link_list::tail_inster_node(link_node *p)  
{  
    std::cout<<"将节点插入到链表尾"<<std::endl;  
    if ( p ){  
        if ( phead ){  
            link_node *ptail = phead;  
            while ( ptail->next ){  
                ptail = ptail->next;  
            }  
            ptail->next = p;  
            p->next = NULL;  
        } else {  
            phead = p;  
            p->next = NULL;  
        }  
    }  
}  
  
/**  插入链表节点 **/  
/** 函数名：    normal_insert_node 
   *    功能描述：   插入链表节点 
   *    参数列表：   查找链表中节点p，在节点p后面插入节点insert_node 
                     若链表中存在p,则插入其后，否则do nothing 
   *    返回值  ：   无 
   */   
  
void link_list::normal_insert_node(link_node* p,link_node *insert_node)  
{  
    std::cout<<"插入链表节点"<<std::endl;  
    if ( phead && insert_node && p ){  
        link_node *curr_node = phead;  
        while ( curr_node && curr_node!=p){  
            curr_node = curr_node->next;  
        }  
        if ( curr_node ){  
            insert_node->next  = curr_node->next;  
            curr_node->next    = insert_node;  
        }  
    }  
}  
  
/**  逆序打印链表**/  
/** 函数名：    print_list_reserve 
   *    功能描述：   逆序打印链表 
   *    参数列表：   无 
   *    返回值  ：    
   */   
void link_list::print_list_reserve()  
{  
    std::cout<<"逆序打印链表"<<std::endl;  
    if ( phead ){  
        link_node *p = phead;  
        print_list_reserve(p);  
        std::cout<<std::endl;  
    } else {  
        std::cout<<"链表为空."<<std::endl;  
    }  
      
}  
  
/**  逆序打印链表**/  
/** 函数名：    print_list_reserve 
   *    功能描述：   逆序打印链表--内部递归函数 
   *    参数列表：   当前链表节点 
   *    返回值  ：    
   */   
void link_list::print_list_reserve(link_node *p)  
{  
    if ( p->next ){  
        print_list_reserve(p->next);  
    }  
    std::cout<<p->m_val<<" ";  
}  
  
/**   打印链表**/  
/** 函数名：    head_delete_node 
   *    功能描述：   打印链表 
   *    参数列表：   无 
   *    返回值  ：    
   */   
void link_list::print_list()  
{  
    std::cout<<"正序打印链表节点"<<std::endl;  
    link_node* p =phead;  
    while ( p ){  
        std::cout<<p->m_val<<" ";  
        p = p->next;  
    }  
    std::cout<<std::endl;  
}  
/**   删除链表头节点**/  
/** 函数名：    head_delete_node 
   *    功能描述：   删除链表头节点 
   *    参数列表：   无 
   *    返回值  ：    
   */   
void link_list::head_delete_node()  
{  
    std::cout<<"删除链表头节点"<<std::endl;  
    if ( phead ){  
        link_node *p =phead->next;  
        delete phead;  
        phead = p;  
    }  
}  
  
/**   删除链表尾结点**/  
/** 函数名：    tail_delete_node 
   *    功能描述：   删除链表尾结点 
   *    参数列表：   无 
   *    返回值  ：    
   */   
void link_list::tail_delete_node()  
{  
    std::cout<<"删除链表尾结点"<<std::endl;  
    if ( phead ){  
        if ( phead->next ){  
            link_node *p = phead;  
            while ( p->next->next ){  
                p = p->next;  
            }  
            delete p->next;  
            p->next = NULL;  
        } else {  
            delete phead;  
            phead = NULL;  
        }  
    }  
}  
  
/**  删除链表中p节点**/  
/** 函数名：    normal_delete_node 
   *    功能描述：   删除链表中p节点 
   *    参数列表：   无 
   *    返回值  ：    
   */   
void link_list::normal_delete_node(link_node* p)  
{  
    std::cout<<"删除链表中p节点"<<std::endl;  
  
    if ( phead && p ){  
        link_node* curr = phead;  
        if ( phead == p ){  
            curr = curr->next;  
            delete phead;  
            phead = curr;  
        }else if ( p->next ){  
            curr = p->next;  
            p->m_val = p->next->m_val;  
            p->next = p->next->next;  
            delete curr;  
        } else {  
            while ( curr->next && curr->next!=p ){  
                curr = curr->next;  
            }  
            if ( curr->next == p ){  
                curr->next = curr->next->next;  
                delete p;  
            }  
        }  
    }  
}  
  
/** 函数名：    get_kth_node 
   *    功能描述：   获取第链表第k个节点 
   *    参数列表：   第k个节点 
   *    返回值  ：    
   */   
link_node* link_list::get_kth_node(int k)  
{  
    std::cout<<"获取第链表第k个节点"<<std::endl;  
    link_node *p1 = phead;  
    link_node *p2 = phead;  
    int i = 0;  
    while ( p1 && i<k  ){  
        p1 = p1->next;  
        i++;  
    }  
    while ( p1 ){  
        p1 = p1->next;  
        p2 = p2->next;  
    }  
    return i == k ? p2:NULL;  
}  
  
/**   创建链表节点**/  
/** 函数名：    create_link_node 
   *    功能描述：   创建链表节点 
   *    参数列表：   节点的值 
   *    返回值  ：    
   */   
link_node* link_list::create_link_node(int val)  
{  
    std::cout<<"创建链表节点"<<std::endl;  
    link_node * p = new link_node(val,NULL);  
    return p;  
}  
  
/**  反转链表 **/  
/** 函数名：    reserve_list 
   *    功能描述：   反转链表 
   *    参数列表：   无 
   *    返回值  ：    
   */   
void link_list::reserve_list()  
{  
    std::cout<<"反转链表"<<std::endl;  
    link_node *pre = NULL;  
    link_node *curr = phead;  
    link_node *last = NULL;  
  
    while ( curr ){  
        last          = curr->next;  
        curr->next    = pre ;  
        pre           = curr;  
        curr          = last ;  
    }  
    phead = pre ;  
}  
  
/**  合并两个已排好序的链表 **/  
/** 函数名：    merge_list 
   *    功能描述：   合并两个已排好序的链表 
   *    参数列表：   无 
   *    返回值  ：    
   */   
void link_list::merge_list(link_list *list)  
{  
    std::cout<<"合并两个已排好序的链表"<<std::endl;  
    if ( list ){  
        link_node *phead1   = phead;  
        link_node *phead2  = list->phead;  
        link_node *tail_node    = NULL;   
        if ( phead1 == NULL ){  
            phead = phead2;  
        }   
        if ( phead1 && phead2 ){  
            if (  phead1->m_val > phead2->m_val ){  
                phead = phead1;  
                phead1 = phead1->next;  
            } else {  
                phead = phead2;  
                phead2 = phead2->next;  
            }  
            tail_node = phead;    
        }  
  
        while ( phead1 && phead2 ){  
            if (  phead1->m_val > phead2->m_val ){  
                tail_node->next = phead1;  
                phead1 = phead1->next;  
            } else {  
                tail_node->next = phead2;  
                phead2 = phead2->next;  
            }  
            tail_node = tail_node->next;   
        }  
        if ( tail_node ){  
            tail_node->next = phead1->next == NULL   
                ? phead2 : phead1;  
        }  
        list->phead = NULL;  
    }  
      
}  

[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
//main  
#include <iostream>  
#include "list.h"  
  
using namespace std;  
  
  
int main()  
{  
      
    link_list myList ;  
  
    //测试空链表的删除  
    myList.get_kth_node(7);  
  
    //测试空链表反转  
    myList.reserve_list();  
  
    myList.head_insert_node(myList.create_link_node(1));  
    myList.print_list();  
  
  
    myList.get_kth_node(7);  
  
    //测试链表反转  
    myList.reserve_list();  
    myList.print_list();  
  
    link_list listTemp ;  
    for ( int i=0 ; i<10; i++ ){  
        myList.head_insert_node(myList.create_link_node(i));  
    }  
    //myList.reserve_list();  
    myList.tail_delete_node();  
    myList.print_list();  
      
    for ( int i=0 ; i<10; i++ ){  
        listTemp.tail_inster_node(listTemp.create_link_node(i));  
    }  
    listTemp.reserve_list();  
    listTemp.print_list();  
    listTemp.merge_list(&myList);  
  
    listTemp.print_list();  
    return 0;  
}  





          
           

更多 0

u010944926
关注
专栏目录
静态链表
Minix的博客
03-27 2317
静态链表 静态链表（static linked list）是用数组来表示单链表，用数组元素的下标来模拟单链表的指针。这种描述方法称为游标（cursor）实现法。 静态链表，也是线性存储结构的一种，它兼顾了顺序表和链表的优点于一身，可以看做是顺序表和链表的升级版。 在链表的指针实现中有两个重要的特点： 数据存储在一组结构体中，每一个结构体包含有数据以及指向下一个结构体的指针； 一个新的结构体可以通过调用 malloc() 函数从系统全局内存得到，并可通过调用 free() 函数而被释放。 游标法必须能够模
PTA 两个有序链表序列的合并
10-07
在编程领域，有序链表序列的合并是一个常见的问题，尤其在数据结构和算法的学习中占有重要地位。这个题目“PTA 两个有序链表序列的合并”主要涉及到链表的操作和合并策略，这对于理解和掌握链表操作有极大的帮助。...
链表基础知识详解（非常详细简单易懂）
qq_61672347的博客
07-10 18万+
数据结构链表详解，创建，遍历，释放，节点的查找，节点的删除，插入节点，链表排序等操作，非常详细
C语言—链表
weixin_73588765的博客
01-01 2万+
【C语言】—链表 创建,遍历,增删改查 链表是一种数据结构，是一种数据存放的思想；
c语言链表详解（超详细）
热门推荐
Endeavor_G的博客
06-03 62万+
链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类，头结点和一般节点，头结点是没有数据域的。链表中每个节点都分为两部分，一个数据域，一个是指针域。说到这里你应该就明白...
反转链表详解
Weirdo的博客
06-14 1835
这些数据项通常以链表的形式组织起来，其中最近使用的数据项位于链表的头部，最久未使用的数据项位于链表的尾部。反转链表指的是将链表的头尾节点对调，使得原本链表的第一个节点变为最后一个节点，原本链表的最后一个节点变为第一个节点，其他节点的相对位置也进行相应调整。通过对反转链表算法的深入理解和实践应用，我们可以更好地掌握链表的基本操作和指针的使用，并提高编程能力和解决问题的能力。然而，锁的使用会降低程序的性能。在实际应用中，我们可能需要在反转链表的同时进行其他操作，例如计算链表长度、检查链表中的重复元素等。
Python链表
sikh_0529的博客
09-12 1万+
链表是一系列数据元素，通过链接连接在一起。 每个数据元素都以指针的形式包含到另一个数据元素的连接。 Python在其标准库中没有链接列表。 我们使用前一章讨论的节点概念来实现链表的概念。 我们已经知道如何创建节点类以及如何遍历节点的元素。 在本章中，将学习链表的类型:单链表。 在这种类型的数据结构中，任何两个数据元素之间只有一个链接。 创建一个链表并使用一些方法来插入，更新和从列表中移除元素。通过使用在上一章中学习的节点类来创建链表。创建一个对象并创建另一个类来使用这个节点对象。 通过节点对象传递适当的值来
数据结构——链表
2301_80373479的博客
08-13 2585
轻松无痛玩转链表
链表逆置详细讲解（图文）
qq_51366188的博客
02-26 3万+
链表逆置   前言 链表逆置是初学时有困扰到我的难点. 由于链表头结点可放可不放数据，所以写代码时候**->next**用的云里雾里。 这里讲解头结点与第一结点区分的情况，即头结点你把它看作这个 链表的“文件名” 就行。 若头结点为L，则第一结点为L->next。   代码 void listReverse(linkedList &L) { node *p,*s; //1. p = L->next; L->next = NULL; while
C语言链表详解附实例
xiaoxiaodawei的博客
03-11 2万+
链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。链表和数组比较，不用事先确定存储空间，而是根据需要开辟内存单元。本文章实现了用C语言编写学生管理系统，可以实现添加、删除、增加..,等功能
07丨链表（下）：如何轻松写出正确的链表代码？1
08-03
【链表】是一种重要的数据结构，它不像数组那样在内存中连续存储，而是通过节点间的指针连接起来。链表的每个节点包含数据和指向下一个节点的指针，这种结构使得链表在插入和删除操作上相比数组更具优势，但同时也...
链表填空题（打印）1
08-08
【链表基础知识】 链表是一种线性数据结构，与数组不同，它不连续存储数据，而是通过节点间的指针连接。每个节点包含数据部分和一个指向下一个节点的指针。链表分为单向链表、双向链表和循环链表等类型。 1. **...
Python单向链表和双向链表原理与用法实例详解
09-20
链表是一种重要的数据结构，它不同于数组，不连续存储元素，而是通过节点之间的引用关系连接。在Python中，我们可以自定义链表结构来实现单向链表和双向链表。 单向链表（Single Linked List）的特点是每个节点只...
毕业设计论文SpringBoot+Vue毕业生信息招聘平台.docx
10-16
毕业设计论文
PHP-006教务选课学生选课成绩管理系统毕业课程源码设计+论文资料
10-16
编号：306 作为php高校院务学生选课成绩管理系统，在系统中有学生信息和教师信息以及课程信息需要管理员分类管理。 (1)学生管理：管理员登录系统后可以添加学生，查询学生，修改学生，删除学生信息。 (2)教师管理：管理员登录系统后可以添加教师，查询教师，修改教师，删除教师信息。 (3)课程管理：管理员登录系统后可以登记新的课程信息，查询修改课程信息，删除课程信息. (4)授课信息管理：管理员登录系统后可以分配课程由哪个老师教授。 (5)班级信息管理：管理员可以在系统其他功能运行前先把班级信息设置好。 (6)选课管理：学生登录系统后可以对课程进行选择。 (7)成绩管理：教师登录系统后，可以查询自己教授的课程并对学生的成绩打分。 (8)系统管理： 修改登录密码，关于系统说明
在线教育视频&JAVA&基于SpringBoot的在线视频教育平台的设计与实现（毕业论文+开题）
10-16
本系统采用的数据库是Mysql，使用SpringBoot框架开发， 使用在线视频教育平台分为管理员和用户、教师三个角色的权限模块。 管理员所能使用的功能主要有：首页、个人中心、用户管理、教师管理、课程信息管理、课程类型管理、我的收藏管理、系统管理、订单管理等。 用户可以实现首页、个人中心、课程信息管理、我的收藏管理、订单管理等。 教师可以实现首页、个人中心、课程信息管理、我的收藏管理等。
个性化影片推荐系统.zip
最新发布
10-16
随着科学技术的飞速发展，社会的方方面面、各行各业都在努力与现代的先进技术接轨，通过科技手段来提高自身的优势，个性化影片推荐系统当然也不能排除在外。 个性化影片推荐系统，在个性化影片推荐系统可以查看首页、热门电影、新闻资讯、我的、跳转到后台、客服等内容
Uniapp发现的Bug，用于重现project_Uniapp Bug.zip
10-16
Uniapp发现的Bug，用于重现project_Uniapp Bug
链表基础与单向链表解析
"链表是一种动态数据结构，与数组相比，它允许在程序运行时根据需要增加或减少元素，克服了数组预设长度和插入删除效率低的问题。链表主要由节点组成，每个节点包含数据域和指针域，指针域指向下一个节点。单向链表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值