精华内容
下载资源
问答
  • 循环链表c++

    2018-06-10 11:26:37
    使用c++语言实现的循环链表,功能齐全,包括插入、删除、寻找等功能
  • 合并两个有序链表 C++ 思路: 顺序遍历,并逐个比较两个链表结点, 将值小的链表结点添加到结果链表尾部,指针后移继续遍历; 重复上述比较和添加操作,直至其中一个链表遍历结束; 将未遍历完的链表直接添加到结果...

    leetcode 21.合并两个有序链表 C++

    思路:

    1. 顺序遍历,并逐个比较两个链表结点,
    2. 将值小的链表结点添加到结果链表尾部,指针后移继续遍历;
    3. 重复上述比较和添加操作,直至其中一个链表遍历结束;
    4. 将未遍历完的链表直接添加到结果链表尾部;

    代码:

    class Solution {
    public:
        ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
            if(l1==nullptr) return l2;
            if(l2==nullptr) return l1;
            
            
            ListNode* head=new ListNode(-1);
            ListNode* rear=head;
    
            while(l1!=nullptr && l2!=nullptr){
    	        if(l1->val < l2->val){
                    rear->next=l1;
                    l1=l1->next;
                }else{
                    rear->next=l2;
                    l2=l2->next;
                }
                rear=rear->next;
            }
            if(l1==nullptr)	rear->next=l2;
            else rear->next=l1;
    
            return head->next;
        }
    };
    

    复杂度:

    • 时间复杂度:O(n+m)O(n+m) 即遍历次数不超过两个链表长度之和。
    • 空间复杂度:O(1)O(1) 不需要开辟额外的空间。
    展开全文
  • 剑指offer之反转链表C++解法方法一:头插法方法二:调整指针方向 输入一个链表,反转链表后,输出新链表的表头。 方法一:头插法 有两种情况:一是链表带有头结点,利用头结点可以很方便地用头插法插入新结点,即把...

    剑指offer之反转链表C++解法

    输入一个链表,反转链表后,输出新链表的表头。

    方法一:头插法

    有两种情况:一是链表带有头结点,利用头结点可以很方便地用头插法插入新结点,即把新结点插入到头结点的下一个结点的位置即可;二是链表不带有头结点,每次头插结点时把新的结点插入到表头的前一个位置,但要注意更新表头指向新插入的最新结点。
    此题不带有头结点。

    class Solution {
    public:
        ListNode* ReverseList(ListNode* pHead) {
            ListNode* newHead=NULL;//新表的表头
            ListNode* p=pHead;
            while(p){
                ListNode* q=p->next;//q用来保存p后面的结点
                p->next=newHead;//头插结点
                newHead=p;//更新表头
                p=q;//下一个结点,重复上述操作
            }
            return newHead;
        }
    };
    

    方法二:调整指针方向

    调整链表中指针的方向,也就是把每个结点指向原本下一个结点的指针调整为指向原本前一个结点,所以需要知道当前结点的前一个结点,还需要保存其下一个结点防止链表断开。因此,需要3个指针,分别指向当前遍历到的结点,它的前一个结点以及后一个结点。当遍历到最后一个结点时,即结点没有下一个结点时,该结点即为新表的表头,此时反转链表结束,返回新表头。

    class Solution {
    public:
        ListNode* ReverseList(ListNode* pHead) {
            ListNode* newHead=NULL;//新表的表头
            ListNode* p=pHead;//当前结点
            ListNode* ppre=NULL;//当前结点的前一个结点
            while(p){
                ListNode* pnext=p->next;//当前结点的后一个结点
                if(pnext==NULL)//最后一个结点为新表的表头
                    newHead=p;
                p->next=ppre;//调整指针指向
                ppre=p;
                p=pnext;
            }
            return newHead;
        }
    };
    
    展开全文
  • 链表C++实现

    万次阅读 多人点赞 2017-03-03 01:11:45
    查找元素e在链表什么位置(下标位置,从0开始) int LinkList ::LocateElem (int e) { int i = 0 ; NODE * p = head; while (p != NULL ) { if (p -> data == e) return i; else p ...

    节点定义:

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

    类定义

    class LinkList
    {
    private:
        NODE *head;
    public:
        LinkList() { head = NULL; }
        ~LinkList();
        bool clearSqList();
        bool isEmpty() { return head == NULL; }
        int Length();
        void GetElem(int i, int *e);
        int LocateElem(int e);
        bool PriorElem(int cur_e, int *pre_e);
        bool NextElem(int cur_e, int *next_e);
        bool Insert(int i, int e);
        bool Delete(int i, int *e);
        NODE * Reverse();
    };

    各个函数的作用参见下面的实现注释

    实现

    析构函数

    //析构函数
    LinkList::~LinkList()//和清空一样
    {
        NODE *p = head;
        while (head)
        {
            p = head;
            head = head->next;
            delete(p);
        }
    }

    清空函数

    bool LinkList::clearSqList()//清空函数,和析构一样
    {
        NODE *p = head;
        while (head)
        {
            p = head;
            head = head->next;
            delete(p);
        }
    }

    获取链表长度

    //获取链表长度
    int LinkList::Length()
    {
        NODE *p = head;
        int len = 0;
        while (p != NULL)
        {
            len++;
            p = p->next;
        }
        return len;
    }

    获取指定位置的元素

    bool LinkList::GetElem(int i, int *e)//*e是返回的元素
    {
        NODE *p = head;
        int j = 0;
        while (p&&j < i)
        {
            p = p->next;
            j++;
        }
        if (p == NULL) return false;
        *e = p->data;
        return true;
    }

    查找元素e在链表什么位置(下标位置,从0开始)

    int LinkList::LocateElem(int e)
    {
        int i = 0;
        NODE *p = head;
        while (p != NULL)
        {
            if (p->data == e)
                return i;
            else p = p->next;
            i++;
        }
        std::cout << "表中不存在指定元素" << std::endl;
        exit(1);
    }

    取上一个元素

    bool LinkList::PriorElem(int cur_e, int *pre_e)
    {
        NODE *p = head;
        if (p->data == cur_e) return false;//是头结点,不存在上一个元素
        while (p->next != NULL)
        {
            if (p->next->data == cur_e)
            {
                *pre_e = p->data;
                return true;
            }
            else
                p = p->next;
        }
        return false;//遍历完不存在或者只有一个头结点
    
    }

    取下一个元素

    bool LinkList::NextElem(int cur_e, int *next_e)
    {
        NODE *p = head;
        if (head == NULL || head->next == NULL) return false;
        while (p->next != NULL)
        {
            if (p->data == cur_e)
            {
                *next_e = p->next->data;
                return true;
            }
            else
                p = p->next;
        }
        return false;
    }

    在指定位置插入元素e

    void LinkList::Insert(int i, int e)
    {
        NODE *p = head,*s;
        int j = 0;
        if (i == 0)
        {
            s = (NODE *)new NODE[1];
            s->data = e;
            s->next = p;
            head = s;
            return true;
        }
        while (p&&j < i - 1)
        {
            p = p->next;
            j++;
        }
        if (p == NULL)
            return false;//到队尾了
        s= (NODE *)new NODE[1];
        s->data = e;
        s->next = p->next;
        p->next = s;
        return true;
    }

    //删除指定位置的元素,并把删除的元素赋给*e

    bool LinkList::Delete(int i, int *e)
    {
        NODE *p = head, *s;
        if (p == NULL) return false;
        int j = 0;
        if (i == 0)
        {
            head = head->next;
            *e = p->data;
            delete p;
            p = NULL;
            return true;
        }
        while (p&&j < i - 1)
        {
            j++;
            p = p->next;
        }
        if (p == NULL)
            return false;
        s = p->next;
        p->next = p->next->next;
        *e = s->data;
        delete s;
        s = NULL;
        return true;
    }

    //反转一个链表

    NODE* LinkList::Reverse()
    {
        if (head == NULL || head->next == NULL) return head;
        NODE *p = head,*q=head->next,*r;
        head->next = NULL;
        while (q)
        {
            r = q->next;
            q->next = p;
            p = q;
            q = r;
        }
        head = p;
        return head;
    }

    验证

    #include<iostream>
    #include"LinkList.h"
    using namespace std;
    int main()
    {
        int a = 0;
        int *p = &a;
        LinkList li;
        li.Insert(0, 5);
        li.Insert(1, 4);
        li.Insert(2, 12);
        li.Insert(3, 5);
        li.Insert(3, 6);
        li.Insert(1, 7);
        cout <<"链表长度"<< li.Length()<<endl;
        cout << "各个元素的值是:";
        for (int i = 0;i < li.Length();i++)//遍历该链表
        {
    
            if (li.GetElem(i, p))
                cout << *p<<"   ";
        }
        cout << endl;
        cout << "反转后各个元素的值是:";
        NODE* re_li=li.Reverse();
        while (re_li)
        {
            cout << re_li->data << "   ";
            re_li = re_li->next;
        }
        cout << endl;
    }

    这里写图片描述

    展开全文
  • 数据结构循环链表的头文件 已经测试过 可以使用 c++语言 凑不够50字了 这规定让人无语 这咋凑这么多字 希望有帮助
  • 反转链表 c++

    2018-06-29 20:22:36
    反转链表 题目描述:输入一个链表,反转链表后,输出新链表的表头 解题思路:一种是递归方法,一种非递归方法,递归方法比较简单,从头结点开始,依次将剩下的结点作为递归中新的链表,找到最后一个结点,结尾反转...

    反转链表

    题目描述:输入一个链表,反转链表后,输出新链表的表头
    解题思路:一种是递归方法,一种非递归方法,递归方法比较简单,从头结点开始,依次将剩下的结点作为递归中新的链表,找到最后一个结点,结尾反转链表的新表头。非递归方法想要实现反转链表,需要声明一个只能用来存放,下一个结点,以使得链表指针可以反向,一个指针用来指向当前遍历的只能,一个指针指向当前结点的下一个结点。

    递归法

    示例代码如下:

    struct ListNode {
        int val;
        struct ListNode *next;
        ListNode(int x) :
                val(x), next(NULL) {
        }
    };
    class Solution {
    public:
        ListNode* ReverseList(ListNode* pHead) {
            if(pHead==nullptr||pHead->next==nullptr)
                return pHead;
            ListNode* pRHead = ReverseList(pHead->next);
            pHead->next->next = pHead;
            pHead->next = nullptr;
            return pRHead;
        }
    };

    非递归法

    示例代码如下:

    struct ListNode {
        int val;
        struct ListNode *next;
        ListNode(int x) :
                val(x), next(NULL) {
        }
    };
    class Solution {
    public:
        ListNode* ReverseList(ListNode* pHead) {
            if(pHead==nullptr||pHead->next==nullptr)
                return pHead;
            ListNode* pRHead = ReverseList(pHead->next);
            pHead->next->next = pHead;
            pHead->next = nullptr;
            return pRHead;
        }
    };
    展开全文
  • list链表c++源代码

    2015-08-25 17:18:19
    使用C++ 代码编写的一个链表,类似于C++ STL中的容器list。可以放入任何类型的数据,通过迭代器访问链表。涉及到的技术很多。
  • 模拟链表c++

    2018-07-26 16:08:34
    链表相似,只不过将链表的next域用一个数组表示。数组data用来存放具体数字,而另一个数组right用来存放当前序列中每一个元素右边的元素在数组data中的位置的。 初始化(如下图) for(int i=1; i&lt;=n; i+...
  • 链表环入口节点
  • 反转链表 C++解法

    2019-05-12 14:57:00
    输入一个链表,反转链表后,输出新链表的表头。 方法一: #include<stdio.h> #include<malloc.h> typedef struct Node { int data; struct Node *pnext; } Node,*pnode; pnode CreateNode() {...
  • 链表 C++描述

    2015-07-30 15:07:06
    链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分:...
  • 合并有序链表C++

    2016-09-06 22:29:54
    /* Author: Victor LV ...* C++:将两个升序排列的链表合并成一个升序排列的链表(不开辟新的链表,直接将原链表重新组合) * 输入:两个list的头指针 * 返回:新的list头指针 */ ListNode* find(ListNod
  • leetcode排序链表c++

    2019-04-23 21:45:35
    排序链表 在 O(n log n) 时间复杂度和常数级空间复杂度下,对链表进行排序。 示例 1: 输入: 4->2->1->3 输出: 1->2->3->4 示例 2: 输入: -1->5->3->4->0 输出: -1->0->3->4...
  • 循环链表 c++实现

    2019-07-12 16:53:25
    问题描述: 已知n个人,围坐一个圆桌周围。...循环链表的实现: // letcode.cpp : 定义控制台应用程序的入口点。 // #include"stdafx.h" #include<iostream> #include<stdio.h> #i...
  • 双向链表C++实现代码

    2019-09-06 16:26:32
    1、双向链表和单链表 单链表是在每个节点只有一个指向下一节点的指针,所以遍历时候需要从头开始,而双向链表的每个节点有两个指针,一个指向...单链表C++实现 #include <string> #include <iostream>...
  • 设计链表 c++ 鼓励作者

    千次阅读 多人点赞 2019-06-13 14:45:01
    如果要使用双向链表,则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能: get(index):获取链表中第 index 个节点的值。如果索引无效,则返回-1...
  • LeetCode环形链表C++

    2019-06-13 22:18:22
    为了表示给定链表中的环,我们使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果 pos 是 -1,则在该链表中没有环。 示例 1: 输入:head = [3,2,0,-4], pos = 1 输出:true 解释:链表中有一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,059
精华内容 8,423
关键字:

链表c++

c++ 订阅