单链表相关问题总结

最新推荐文章于 2020-09-13 14:22:36 发布
最新推荐文章于 2020-09-13 14:22:36 发布
阅读量207 收藏
点赞数
分类专栏： 数据结构与常见算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32818935/article/details/105640298
版权 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnityEngine;

namespace Assets.Scripts.Structure
{

    public enum ListFuncType
    {
        Addpend,
        Insert,
        InsertPos,
        RemoveNode,
        RemoveNodeByValue,
        SelectNodeByIndex,
        selectNodeByValue,
        Count
    }
    class node
    {
        public int data;
        public node next;

        public node() { }

        public node(int data) { this.data = data; }
    }
    #region 链表基本操作
    class list
    {
        public node head;

        public int curNodeCount;

        public list() { }

        public list(node head) { this.head = head; }

        public void OutListFunc(ListFuncType type,int data=0,int index=1)
        {
            switch (type)
            {
                case ListFuncType.Addpend:
                    Addpend(data);
                    break;
                case ListFuncType.Insert:
                    Insert(data, index);
                    break;
                case ListFuncType.InsertPos:
                    InsertPos(data, index);
                    break;
                case ListFuncType.RemoveNode:
                    RemoveNode(index);
                    break;
                case ListFuncType.RemoveNodeByValue:
                    RemoveNodeByValue(data);
                    break;
                case ListFuncType.SelectNodeByIndex:
                    Debug.Log(SelectNodeByIndex(index).data);
                    break;
                case ListFuncType.selectNodeByValue:
                    Debug.Log(SelectNodeByValue(data));
                    break;
            }
        }


        void Addpend(int data)
        {
            if (head == null)
            {
                node d = new node(data);
                head = d;
                return;
            }

            node p = head;
            node q = new node(data);

            while (p.next != null)
            {
                p = p.next;
            }
            p.next = q;
        }

        void Insert(int data, int k)
        {
            if (head == null || k < 1) return;

            if (k == 1)
            {
                node d = new node(data);
                d.next = head;
                head = d;
                return;
            }

            node p = head;
            node q = new node();
            node r = new node(data);
            int j = 1;

            while (p.next != null && j < k)
            {
                ++j;
                q = p;
                p = p.next;
            }

            if (k == j)
            {
                q.next = r;
                r.next = p;
                return;
            }
        }

        void InsertPos(int data, int k)
        {
            if (head == null || k < 1) return;

            if (k == 1)
            {
                node d = new node(data);
                d.next = head.next;
                head.next = d;
                return;
            }


            node p = head;
            node q = new node(data);
            int j = 1;
            while (p.next != null && j < k)
            {
                ++j;
                p = p.next;
            }

            if (k == j)
            {
                q.next = p.next;
                p.next = q;
                return;
            }
        }

        node RemoveNode(int k)
        {
            if (head == null || k < 1) return null;

            if (k == 1)
            {
                node tempNode = head;
                head = head.next;
                return tempNode;
            }

            node p = head;
            node q = new node();
            int j = 1;
            node d = new node();
            while (p.next != null && j < k)
            {
                ++j;
                q = p;
                p = p.next;
            }

            if (k == j)
            {
                d = p;
                q.next = p.next;
            }
            return d;
        }

        int RemoveNodeByValue(int data)
        {
            if (head == null) return -1;

            node d = new node(data);

            node p = head;
            node q = new node();
            int j = 1;
            while (p.next != null&&!p.data.Equals(data))
            {
                ++j;
                q = p;
                p = p.next;
            }

            if (j == 1)
            {
                head = head.next;
                return 1;
            }

            q.next = p.next;
            return j;
        }

        node SelectNodeByIndex(int k)
        {
            if (head == null || k < 1) return null;

            node p = head;

            int j = 1;
            while (p.next != null && j < k)
            {
                ++j;
                p = p.next;
            }

            if (k == j)
            {
                return p;
            }

            return null;
        }

        int SelectNodeByValue(int data)
        {
            if (head == null) return -1;

            node p = head;
            int j = 1;
            while (p.next != null && !p.data.Equals(data))
            {
                ++j;
                p = p.next;
            }

            return j;
        }

        public void Print()
        {
            if (head == null) return;

            node p =head;
            while (p.next != null)
            {
                Debug.Log(p.data);
                p = p.next;
            }

            Debug.Log(p.data);
        }

        int CurNodeCount
        {
            get
            {
                if (head == null)
                    return -1;

                node p = head;
                while (p.next != null)
                {
                    ++curNodeCount;
                    p = p.next;
                }
                ++curNodeCount;
                return curNodeCount;
            }
        }
        #endregion

        #region 单链表翻转
        public void ReverList()
        {
            if (head == null) return;

            node p = head.next;
            node q = new node();
            head.next = null;

            while (p != null)
            {
                q = p;
                p = p.next;
                q.next = head;
                head = q;
            }
        }
        //2.
        #endregion

        #region 中点
        public node BackMidNode()
        {
            if (head == null) return null;

            #region 没有限制遍历次数

            int nodeCunt = CurNodeCount;

            int midIndex = 1;
            if (curNodeCount % 2 != 0)
            {
                midIndex = (curNodeCount + 1) / 2;
            }
            else
            {
                midIndex = (curNodeCount - 1) / 2;
            }
            #endregion

            #region 限制遍历次数 遍历一次 节点数为偶数
            node fastNode = head.next.next;
            node lowNode = head.next;
            while (lowNode != null && fastNode != null)
            {
                fastNode = fastNode.next.next;
                lowNode = lowNode.next;
            }
            #endregion

            #region 限制遍历次数 遍历一次 节点数为奇数
            node fastNode1 = head.next.next;
            node lowNode1 = head.next;
            while (lowNode1 != null && fastNode1.next != null)
            {
                fastNode = fastNode.next.next;
                lowNode = lowNode.next;
            }
            #endregion

            return lowNode;
        }
        #endregion

        #region 删除倒数第N个节点
        public node RemoveByPosIndex(int k)
        {
            int index = curNodeCount - k;
            return RemoveNode(index);
        }
        #endregion

        #region 删除重复节点

        public void RemoveRepeatNode()
        {
            if (head == null) return;

            node p = head;

            while (p != null)
            {
                node q = p;

                while (q.next != null)
                {
                    if (q.next.data.Equals(p.data))
                    {
                        q.next = q.next.next;
                    }
                    else
                    {
                        q = q.next;
                    }
                }
                p = p.next;
            }
        }
        #endregion

        #region 环的问题 https://www.cnblogs.com/dancingrain/p/3405197.html
        //1.判断链表是否有环
        bool IsExitLoop()
        {
            node fastNode = head.next.next;
            node slowNode = head.next;
            //快指针跟慢指针相遇，有环
            while (slowNode != null && fastNode.next != null)
            {
                fastNode = fastNode.next.next;
                slowNode = slowNode.next;

                if (fastNode == slowNode)
                {
                    return true;
                }
            }
            return false;
        }

        //2，如果链表存在环，找出环的入口点

        node FindFirstNode()
        {
            node fastNode = head.next.next;
            node slowNode = head.next;

            while (fastNode.next != null && slowNode != null)
            {
                fastNode = fastNode.next.next;
                slowNode = slowNode.next;
                if (fastNode == slowNode) break;
            }

            if (fastNode.next == null || slowNode == null) return null;

            node pre1 = head;
            node pre2 = slowNode;

            while (pre1 != pre2)
            {
                pre1 = pre1.next;
                pre2 = pre2.next;
            }

            return pre1;//环的入口点
        }
        //3.环上的节点数
        int NodeCountLoop()
        {
            node fastNode = head.next.next;
            node slowNode = head.next;
            node tempNode = new node();
            while (slowNode != null && fastNode.next != null)
            {
                fastNode = fastNode.next.next;
                slowNode = slowNode.next;

                if (slowNode == fastNode)
                {
                    tempNode = slowNode;
                    break;
                }
            }

            if (slowNode == null || fastNode.next == null) return -1;
            int j = 1;
            while (slowNode != tempNode)
            {
                ++j;
                slowNode = slowNode.next;
            }

            return j;
        }

        //如果存在环，链表的长度
        int GetNodeCount()
        {
            if (head == null) return -1;

            node fastNode = head.next.next;
            node slowNode = head.next;
            node tempNode = new node();

            int j = 1;

            while (fastNode.next != null && slowNode != null)
            {
                ++j;
                fastNode = fastNode.next.next;
                slowNode = slowNode.next;
                if (fastNode == slowNode)
                {
                    tempNode = slowNode;
                    break;
                }
            }

            if (fastNode.next == null || slowNode == null) return j;

            int h = 1;
            while (slowNode != tempNode)
            {
                ++h;
                slowNode = slowNode.next;
            }


            int L = 1;

            node pre1 = head;
            node pre2 = tempNode;

            while (pre1 != pre2)
            {
                ++L;
                pre1 = pre1.next;
            }

            return h + L;
        }


        #endregion

        #region 合并的问题（无环）

        public node MerageList(node head1,node head2)
        {
            if (head1 == null && head2 == null)
                return null;
            else if (head1 == null)
                return head2;
            else if (head2 == null)
                return head1;

            node newNode = new node();
            node p = head1;
            node q = head2;

            while (p.next != null && q.next != null)
            {
                if (p.data > q.data)
                {
                    newNode.next = q;
                    q = q.next;
                }
                else
                {
                    newNode.next = p;
                    p = p.next;
                }
                newNode = newNode.next;
            }

            while (p.next != null)
            {
                newNode.next = p;
            }

            while (q.next != null)
            {
                newNode.next = q;
            }
            return newNode;
        }

        #endregion

    }
}
程序员小胖
关注
专栏目录
单链表问题汇总
weixin_42568742的博客
12-09 431
一、分析 若有交点，则交点后元素相同 二、思路一 求出两个链表各自长度，判断两个链表的长短。 若长度相同，则直接进行比较 若长短不同，使用长度长的减短的。 三、思路二 两个链表逐个进行比较 若长度相同，直接求出交点 若长度不同，则长的遍历完直接遍历短链表， 短的遍历完，继续遍历长链表，交替遍历 ...
单链表相关问题
fanfan_fighting的博客
04-08 339
问题1：打印两个有序链表的公共部分 【题目】 给定两个有序链表的头指针head1和head2，打印两个链表的公共部分。 解题思路： 1.准备两个指针，分别代表两个链表的头部； 2.谁小谁向前走，遇到相等的就打印，并且两个指针同时向前走一步； 3.直到任意一个指针走到空 ，停止。 问题2：判断一个链表是否为回文结构 【题目】 给定一个链表的头节点head，请判断该链表是否为回文结构。 解题思路： ...
单链表问题总结
zlp1992的专栏
08-25 2892
Leetcode 单链表相关问题解决 判断链表是否存在环 找出环的入口节点
单链表问题
wwhhff11
03-16 249
给定一个单链表，只给出头指针h： 1、如何判断是否存在环？ 2、如何知道环的长度？ 3、如何找出环的连接点在哪里？ 4、带环链表的长度是多少？解法： 1、对于问题1，使用追赶的方法，设定两个指针slow、fast，从头指针开始，每次分别前进1步、2步。如存在环，则两者相遇；如不存在环，fast遇到NULL退出。 2、对于问题2，记录下问题1的碰撞点p，slow、fast从该点开始，再次碰
数据结构--单链表操作实验报告
04-12
1.从键盘输入顺序任意的5个整数，按有序插入的要求生成第一个有序单链表，将该链表输出显示。 2.再从键盘输入顺序任意的5个整数，按有序插入的要求生成第二个有序单链表，将该链表输出显示。 3.将这两个有序单链表...
单链表的有关操作
11-13
### 单链表的有关操作 #### 概述 单链表是一种常见的线性数据结构，在计算机科学领域有着广泛的应用。本文将详细解释基于C++实现的单链表中的各种基本操作，包括创建、遍历、获取长度、插入元素、删除元素以及逆置...
单链表-C++数据结构之单链表实现.zip
03-13
在C++中实现单链表，需要理解链表的基本概念、节点结构以及相关的操作。以下是对这一主题的详细讲解： 1. **链表概念**： 链表是一种动态数据结构，与数组不同，它不连续存储数据。每个链表元素（也称为节点）包含...
数据结构实验-单链表的相关运算
最新发布
05-12
### 数据结构实验——单链表的相关运算 #### 实验目的 1. **理解单链表的概念**：在计算机科学中，链表是一种基础的数据结构，它由一系列节点组成，每个节点包含实际的数据以及指向下一个节点的链接。单链表是最...
图书管理系统设计以及论文（单链表）
12-20
总结，图书管理系统设计与单链表的结合，既锻炼了学生的编程技能，也使他们对数据结构有了更直观的理解。在实训中，学生不仅能够实现一个实用的系统，还能深入体会C语言的精髓，提升自己的编程素养。
单链表的一些问题
Mars1997的博客
04-27 245
1.单链表的逆置 public Entry reverse(){ Entry newHead = null; Entry prev = null; Entry cur = head; while(cur != null){ Entry curNext = cur.next; i...
单链表的三个典型问题
acm20648的博客
10-15 245
链表的结点结构struct Node{int data ;Node *next ;};typedef struct Node Node ; （1）已知链表的头结点head,写一个函数把这个链表逆序 Node * ReverseList(Node *head) //链表逆序{if ( head == NULL || head->next == NULL )return head;...
单链表系列问题
小林玩大数据
08-09 721
. 问题描述 这道题目主要讨论单链表相交的一系列问题。在本题中，单链表可能有环，也可能无环。给定两个单链表的头节点 head1 和 heda2 ，这两个链表可能相交，也可能不相交。请实现一个函数，如果两个链表相交，请返回相交的第一个节点；如果不相交返回 null 即可。 要求：如果链表 1 的长度为N，链表 2 的长度为 M，时间复杂度请达到 O(N+M),空间复杂带请达到 O(1)。
单链表问题集合
小Z的博客
12-28 282
主要解决的问题有// 逆序打印单链表 void PrintListFromTail2Head(PNode pHead);// 删除单链表的非尾结点 void DeleteNonEnd(PNode pos);// 在无头单链表某节点前插入值为data新节点 void InsertFront(PNode pos, DataType data);// 用单链表模拟实现约瑟夫环 void Josep
单链表的经典问题
weixin_42168411的博客
09-08 536
使用尾插法（头插法）创建一个带头节点（不带头节点）的单链表 单链表中的节点类型描述如下： typedef struct link { int data; link* next; }node,*linklist; 使用尾插法（头插法）创建一个带头节点的单链表 void Creat_list_Head(linklist& L) {//创建一个带头节点的单链表 //尾插法 /*int x; L = (node*)malloc(sizeof(node*));//先创建一个头节点 L->
单链表常见问题
杨星的博客
10-19 2207
Node* Reverse(Node* head) { Node *p, *q; q = head; head = NULL; while(q) { p = q; q = q->next; p->next = head; head = p; } return(head); }  参考：1）http://hi.baidu.com/van_%D0%A1%CD%B0/blog/item/3fd42713b82ce45bf819b882.ht
单链表典型问题总结
qq_41185460的博客
11-14 1322
1、删除链表中等于给定值**val**的所有节点。 思路分析： 定义两个辅助指针 prev 和 cur，当prev.next.data= val时删除即可 主要是别忘了处理第一个节点 public void removeAllKey(int key) { ListNode prev = this.head; ListNode cur = t...
单链表经典问题3
weixin_42168411的博客
09-13 660
单链表中节点类型定义如下： typedef struct link { int data; link* next; }node,*linklist; 1.试编写在带头节点的单链表L中删除一个最小值节点的高效算法（假设最小值节点时唯一的） void delete_MinX(linklist& L) { //试编写在带头节点的单链表L中删除一个最小值节点的高效算法（假设最小值节点时唯一的） node* min_pre = L;//记录最小节点的前一个节点 node* min_p=L->ne
单链表的经典问题2
weixin_42168411的博客
09-09 611
单链表中节点类型定义如下： typedef struct link { int data; link* next; }node,*linklist; 1.将一个头指针为head且不带头节点的单链表改造为一个含头节点且头指针为head的单循环链表。 void fun(linklist& head) {//将一个头指针为head且不带头节点的单链表改造为一个含头节点且头指针为head的单循环链表。 node* s = (node*)malloc(sizeof(node*));//先增加头节点 s
单链表递归遍历与操作总结
在这个题目中，主要关注的是单链表的遍历，特别是逆序打印，以及相关的递归实现。递归遍历方法涉及到了函数的递归调用，其中函数`ListTraverse2`是核心，其接受一个链表`L`和一个访问函数`visit`作为参数。当函数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值