[算法] 链表操作

最新推荐文章于 2022-05-17 18:50:38 发布
最新推荐文章于 2022-05-17 18:50:38 发布
阅读量178 收藏
点赞数
分类专栏： C/C++ 算法 文章标签： 算法 C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zkp_java/article/details/80617274
版权
算法 同时被 2 个专栏收录
13 篇文章 0 订阅
订阅专栏
C/C++
10 篇文章 0 订阅
订阅专栏

链表节点定义

链表相关的操作中我们定义链表节点和公共操作如LinkListCommon.hpp所示：

#ifndef LinkListCommon_hpp
#define LinkListCommon_hpp

#include <stdio.h>

typedef struct tagSNode {
    int value;
    tagSNode* pNext;

    tagSNode(int v) : value(v), pNext(NULL) {}
}SNode;

// 打印链表
void printLinkList(SNode* pHead) {
    if (pHead == NULL) {
        printf("No number....");
        return;
    }
    SNode* pCurr = pHead->pNext;
    while (NULL != pCurr && NULL != pCurr->pNext) {
        printf("%d->", pCurr->value);
        pCurr = pCurr->pNext;
    }
    printf("%d\n", pCurr->value);
}

// 回收链表
void destroyLinkList(SNode* pHead) {
    if (pHead == NULL) {
        return;
    }
    SNode* pCurr = pHead;
    SNode* pNext = pHead->pNext;
    while (pNext) {
        delete pCurr;
        pCurr = pNext;
        pNext = pNext->pNext;
    }
    if (pCurr) {
        delete pCurr;
    }
}

// 创建数字链表
SNode* createNodeList(int listLength, int radix) {
    SNode* pHead = new SNode(0);
    int i;
    for (i = 0; i < listLength; i++) {
        SNode* pNode = new SNode(rand() % radix);
        pNode->pNext = pHead->pNext;
        pHead->pNext = pNode;
    }
    return pHead;
}
#endif /* LinkListCommon_hpp */

链表相加

问题

给定两个链表，分别表示两个非负整数，他们的数字逆序存储在链表当中，且每个节点存储一个数字，计算两个数的和，并且返回和的链表头指针。例如：

输入：2->4->3、5->6->4，输出7->0->8

分析

  • 两个数都是逆序存储，正好可以从头向后依次相加，完成”两个数的的竖式计算”
  • 两个数字的求和范围是[0,18]，进位最大是1，因此第i位相加不会影响到第i+2位的计算。
  • 在发现一个链表为空后，直接结束for循环，最后只需进位和较长链表的当前节点相加，较长链表的其他节点直接拷贝至和和链家即得到最终结果。

代码实现

LinkListAdd.hpp

#ifndef LinkListAdd_hpp
#define LinkListAdd_hpp

#include <stdio.h>
#include <stdlib.h>
#include "LinkListCommon.hpp"

// 链表相加
SNode* add(SNode* pHead1, SNode* pHead2) {
    SNode* pSum = new SNode(0);
    pSum->value = 0;

    // 链表尾节点
    SNode* pTail = pSum;
    SNode* pCurrSum;

    SNode* pCurr1 = pHead1->pNext;
    SNode* pCurr2 = pHead2->pNext;

    // 进位值
    int carry = 0;
    int value;

    while (pCurr1 && pCurr2) {
        value = pCurr1->value + pCurr2->value + carry;
        carry = value / 10;
        value = value % 10;

        pCurrSum = new SNode(value);

        pTail->pNext = pCurrSum;
        pTail = pCurrSum;

        pCurr1 = pCurr1->pNext;
        pCurr2 = pCurr2->pNext;
    }

    // 将较长的链表连接到链表尾部
    SNode* pLeft = pCurr1 ? pCurr1 : pCurr2;
    while (pLeft) {
        value = pLeft->value + carry;
        carry = value / 10;
        value = value % 10;

        pCurrSum = new SNode(value);

        pTail->pNext = pCurrSum;
        pTail = pCurrSum;

        pLeft = pLeft->pNext;
    }
    return pSum;
}
#endif /* LinkListAdd_hpp */

测试代码main.cpp

#include "LinkListAdd.hpp"

int main(int argc, const char * argv[]) {
    // 测试链表数字相加
    SNode* pHead1 = createNodeList(6);
    SNode* pHead2 = createNodeList(9);
    printLinkList(pHead1);
    printLinkList(pHead2);

    SNode* pSum = add(pHead1, pHead2);
    printf("Result:\n");
    printLinkList(pSum);

    destroyLinkList(pHead1);
    destroyLinkList(pHead2);

    return 0;
}

执行结果

2->0->8->3->9->7
7->2->2->5->0->9->3->8->4
Result:
9->2->0->9->9->6->4->8->4

链表翻转

问题

给定一个链表，翻转该链表从m到n的位置，要求直接翻转而分申请新空间。

  • 例如给定链表：1->2->3->4->5，m=2，n=4，返回 1->4->3->2->5。
  • 假定给出的参数满足：1<=m<=n<=链表长度。

分析

  • 空转m-1次，找到第m-1个节点，即开始翻转第一个节点的前驱，记为head；
  • 以head为起点遍历n-m次，将第i次时，将找到的节点插入到head的next中即可(头插法)。

代码实现

链表去重LinkListReversal.hpp

#ifndef LinkListReversal_hpp
#define LinkListReversal_hpp

#include <stdio.h>
#include "LinkListCommon.hpp"

void reverseLinkList(SNode* pHead, int from, int to) {
    SNode* pCurr = pHead->pNext;
    int i;
    // 空转form-1次，找到翻转起点的前一个节点和翻转的第一个节点
    for (i = 0; i < from - 1; i++) {
        pHead = pCurr;
        pCurr = pCurr->pNext;
    }
    // 起始翻转节点不需要翻转, 把后面的to-1个节点翻转
    SNode* pPre = pCurr;
    pCurr = pCurr->pNext;
    to--;
    SNode* pNext;
    for (; i < to; i++) {
        pNext = pCurr->pNext;
        pCurr->pNext = pHead->pNext;
        pHead->pNext = pCurr;
        pPre->pNext = pNext;
        pCurr = pNext;
    }
}
#endif /* LinkListReversal_hpp */

测试代码main.cpp

#include "LinkListAdd.hpp"
#include "LinkListReversal.hpp"

int main(int argc, const char * argv[]) {
    // 测试链表翻转
    SNode* pHead3 = createNodeList(15, 100);
    printLinkList(pHead3);
    printf("Reverse result:\n");
    reverseLinkList(pHead3, 6, 11);
    printLinkList(pHead3);
    destroyLinkList(pHead3);
    return 0;
}

执行结果

35->16->78->99->33->60->57->9->69->3->12->40->29->27->3
Reverse result:
35->16->78->99->33->12->3->69->9->57->60->40->29->27->3

排序链表去重

问题

给定排序的链表，删除重复的元素，重复元素只保留一个：

  • 给定： 2->3->3->5->7->8->8->8->9->9->10
  • 返回： 2->3->5->7->8->9->10

分析

有两种思路：

  1. 只保留重复元素的第一个节点，删除后面的重复元素节点
  2. 只保留重复元素的最后一个节点，删除前面的重复元素节点

两种实现方式均可，若要求删除全部重复元素，则使用第二种方法更加方便些。

代码实现

两种思路的实现代码如下所示

#ifndef LinkListDeleteDuplicateNode_hpp
#define LinkListDeleteDuplicateNode_hpp

#include <stdio.h>
#include "LinkListCommon.hpp"

// 链表去重:保留第一个重复元素
void deleteDuplicateNode1 (SNode* pHead) {
    SNode* pPre = pHead->pNext;
    SNode* pCur;
    while(pPre) {
        pCur = pPre->pNext;
        if(pCur && (pCur->value == pPre->value)) {
            pPre->pNext = pCur->pNext;
            delete pCur;
        }else {
            pPre = pCur;
        }
    }
}


// 链表去重：保留最后一个重复元素
void deleteDuplicateNode2(SNode* pHead) {
    SNode* pPre = pHead->pNext;
    SNode* pCur = pPre->pNext;
    SNode* pNext;
    while (pCur) {
        pNext = pCur->pNext;
        while (pNext && (pCur->value == pNext->value)) {
            pPre->pNext = pNext;
            delete pCur;
            pCur = pNext;
        }
        pPre = pCur;
        pCur = pNext;
    }
}
#endif /* LinkListDeleteDuplicateNode_hpp */

测试代码main.cpp

#include "LinkListDeleteDuplicateNode.hpp"

int main(int argc, const char * argv[]) {
    // 测试链表去重:保留第一个重复元素
    SNode* pHead4 = new SNode(0);
    int data[] = {2, 3, 3, 5, 7, 8, 8, 8, 9, 9, 30};
    int size1 = sizeof(data) / sizeof(int);
    for (int i = size1 - 1; i >= 0; i--) {
        SNode* pNode = new SNode(data[i]);
        pNode->pNext = pHead4->pNext;
        pHead4->pNext = pNode;
    }
    printLinkList(pHead4);
    deleteDuplicateNode1(pHead4);
    printLinkList(pHead4);
    destroyLinkList(pHead4);

    printf("\n===============================================================\n");

    // 测试链表去重：保留最后一个重复元素
    SNode* pHead5 = new SNode(0);
    // int data[] = {2, 3, 3, 5, 7, 8, 8, 8, 9, 9, 30};
    int size2 = sizeof(data) / sizeof(int);
    for (int i = size2 - 1; i >= 0; i--) {
        SNode* pNode = new SNode(data[i]);
        pNode->pNext = pHead5->pNext;
        pHead5->pNext = pNode;
    }
    printLinkList(pHead5);
    deleteDuplicateNode1(pHead5);
    printLinkList(pHead5);
    destroyLinkList(pHead5);

    printf("\n===============================================================\n");

    return 0;
}

执行结果

===============================================================
2->3->3->5->7->8->8->8->9->9->30
2->3->5->7->8->9->30

===============================================================
2->3->3->5->7->8->8->8->9->9->30
2->3->5->7->8->9->30

===============================================================

去除全部重复元素

即若发现重复元素，则删除全部重复元素。用思路2解决该问题。用一个标志位记录当前元素是否为重复元素，实现代码如下所示：

void deleteAllDuplicateNode(SNode* pHead) {
    SNode* pPre = pHead;
    SNode* pCur = pPre->pNext;
    SNode* pNext;
    // 标志pCur是否为重复元素
    bool bDup;
    while (pCur) {
        pNext = pCur->pNext;
        bDup = false;
        while (pNext && (pCur->value == pNext->value)) {
            pPre->pNext = pNext;
            delete pCur;
            pCur = pNext;
            pNext = pCur->pNext;
            bDup = true;
        }
        if (bDup) { // pCur是重复的元素，删除
            pPre->pNext = pNext;
            delete pCur;
        } else { // pCur不是重复元素，pPre往后移
            pPre = pCur;
        }
        pCur = pNext;
    }
}

链表划分

问题

给定一个链表和一个值x，将链表划分成两部分，使得划分后小于x的节点在前，大于等于x的节点在后。这两部分中要保持原链表中出现的顺序，例如

给定链表1->4->3->2->5-2和x=3，返回1->2->2->4->3->5.

分析

分别申请两个指针p1和p2，小于x的添加到p1中，大于等于x的添加到p2中，最后将p2链接到p1的末端即可。
时间复杂度为O(N)，空间复杂度为O(1)，该问题要说明的是快速排序对于单链表存储结构仍然适用.

代码实现

代码实现如LinkListPartition.hpp所示

#ifndef LinkListPartition_hpp
#define LinkListPartition_hpp

#include <stdio.h>
#include "LinkListCommon.hpp"

void linkListPartition(SNode* pHead, int pivotKey) {
    // 两个链表的头指针
    SNode* pLeftHead = new SNode(0);
    SNode* pRightHead = new SNode(0);

    // 两个链表的尾指针
    SNode* left = pLeftHead;
    SNode* right = pRightHead;

    SNode* p = pHead->pNext;
    while (p) {
        if (p->value < pivotKey) {
            left->pNext = p;
            left = p;
        } else {
            right->pNext = p;
            right = p;
        }
        p = p->pNext;
    }

    // 将right链接到left尾部
    left->pNext = pRightHead->pNext;
    right->pNext = NULL;

    pHead->pNext = pLeftHead->pNext;

    delete pLeftHead;
    delete pRightHead;
}

#endif /* LinkListPartition_hpp */

测试代码main.cpp如下所示：

#include "LinkListPartition.hpp"

int main(int argc, const char * argv[]) {
    // 测试链表划分
    SNode* pHead6 = createNodeList(20, 100);
    printLinkList(pHead6);
    linkListPartition(pHead6, 50);
    printLinkList(pHead6);
    return 0;
}

执行结果，执行结果如下所示

57->94->91->28->45->85->36->93->72->67->21->79->49->79->33->10->67->12->26->97
28->45->36->21->49->33->10->12->26->57->94->91->85->93->72->67->79->79->67->97

单链表公共节点问题

问题

给定两个单向链表，计算两个链表的第一个公共节点，若没有公共节点，则返回空。

分析

令两链表长度为m、n，不妨认为m>=n，由于两个链表从第一个公共节点到链表的尾节点是完全重合的，所以前面的m-n个节点一定没有公共节点。
先分别遍历两个链表得到他们的长度m和n，长链表空转|m-n|次，同步遍历两链表，直到找到相同节点或到链表结束。
时间复杂度为O(m+n)。

代码实现

代码实现如LinkListFindFirstCommonNode.hpp所示：

#ifndef LinkListFindFirstCommonNode_hpp
#define LinkListFindFirstCommonNode_hpp

#include <algorithm>
#include <stdio.h>
#include "LinkListCommon.hpp"

int calculateLength(SNode* pHead) {
    int length = 0;
    while (pHead) {
        length++;
        pHead = pHead->pNext;
    }
    return length;
}

SNode* findFirstCommonNode(SNode* pHead1, SNode* pHead2) {
    pHead1 = pHead1->pNext;
    pHead2 = pHead2->pNext;

    int length1 = calculateLength(pHead1);
    int length2 = calculateLength(pHead2);

    if (length1 > length2) {
        std::swap(pHead1, pHead2);
        std::swap(length1, length2);
    }
    // 长的链表空转length2-length1次
    for (int i = 0; i < length2 - length1; i++) {
        pHead2 = pHead2->pNext;
    }
    while (pHead1) {
        if (pHead1 == pHead2) {
            return pHead1;
        }
        pHead1 = pHead1->pNext;
        pHead2 = pHead2->pNext;
    }
    return NULL;
}
#endif /* LinkListFindFirstCommonNode_hpp */

扩展

单链表公共节点问题中，如果链表存在环，则需要使用快慢指针的方式计算公共节点(两个指针，每次分别移动一个/两个节点)。

zkp_java
关注
专栏目录
单链表的应用1（去重）
而濡木染
04-03 1092
题目要求：在一个递增有序的线性表中，有数值相同的元素存在。若存储方式为单链表，设计算法去掉数值相同的元素，使表中不再有重复的元素。 #include #include #include #include using namespace std; typedef struct node { int data; struct node*next; } Linkli
算法之链表
yaoyao071500的博客
03-11 1976
`链表简单算法题 1.将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成。（附leetcode 21.) //方法一 struct ListNode *mergeTwoLists(struct ListNode* l1, struct ListNode* l2){ if(!l1) return l2; if(!l2) return l1; struct ListNode *head=(struct ListNode*
链表去重操作-两种方法的实现
dreamzuora的博客
11-13 6076
#include #include typedef struct list { int data; list *next; }List; void create_list(list *&head,int len) { list *p=head; for(int i=0;i<len;i++) { list *pnew=(list*)malloc
如何从链表中删除重复数据
Mason97的博客
02-16 159
这是Node结点类 public class Node { int val; Node next; Node(int x) { val = x; } } 这是删除重复结点的方法 public void deleteDuplecate(Node head) { Node p = head; while (p != null) { Node q = p; while...
链表的简单操作（插入，删除，置反，输出，合并，去重）
口中冰的博客
10-11 1869
链表的核心就是指针，初接触可能不太熟悉。不会用就多用，熟能生巧 定义一个结构体类型，其中由数据类型和指针构成。有指针就相当于知道了门牌号，可以依次知道下个元素 typedef struct node{ int data; struct node *next; }Node,*LinkList; 链表的初始化，分配内存，判断是否有内存，头结点为空勿忘 LinkList initai
链表——基本算法
sy2453的博客
02-09 2080
1、反转链表 给出3个指针，一个cur，用于遍历链表中的每个节点，一个prev，用于保存cur指向的节点的上一个节点地址，还有一个after，用于保存cur指向的节点的下一个节点地址，链表操作遵循先连后断，即 ...
算法（Java）——链表
小朱小朱绝不认输的博客
03-15 1011
链表是除数组外，另一个常用的数据结构，算法中经常会对链表进行处理，主要是指针的用法。 链表 链表结构： public class ListNode { int val; ListNode next; ListNode(int x) { val = x; } }
C语言链表超详解
k666499436的博客
05-17 12万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
leetcode算法题-链表操作（两数相加）
12-20
这道题目考察了链表操作、进位运算以及问题抽象的能力，是理解和运用链表结构的一个好例子。通过解决此类问题，可以提升编程能力和算法思维，对于面试和日常工作中的数据结构处理都有很大的帮助。
Java实现链表的常见操作算法详解
08-25
Java中的链表是一种重要的数据结构，它通过节点之间的引用关系形成线性序列。与数组不同，链表不依赖于连续的内存空间，因此在插入和删除操作上...在实际开发中，根据需求，还可以扩展更多的链表操作，如排序、分隔等。
Java算法实例-双向链表操作
08-22
双向链表与单链表相比，其独特之处在于每个节点不仅包含指向下一个节点的指针，还包含指向前一个节点的指针，这使得在链表中的前进和后退操作变得相对高效。 双向链表的操作主要包括创建、插入、删除、遍历等。下面...
常用算法链表堆栈二叉树.docx
09-07
插入操作可以在链表的任意位置插入一个新的结点，而删除操作可以删除链表中的任意一个结点。查找操作可以根据给定的值查找链表中的结点。 2. 链表的实现 链表的实现可以使用Java中的 Node 类，每个 Node 对象都...
算法链表.docx
09-11
链表反转是常见的链表操作。对于单链表，可以使用迭代或递归的方法实现。这里我们展示一个迭代的实现： ```java void reverse() { Node prev = null; Node current = head; while (current != null) { Node ...
100道经典的c语言面试题
热门推荐
wjw博客
07-26 13万+
100 条经典C语言笔试题目   题目来源： 1、中兴、华为、慧通、英华达、微软亚洲技术中心等中 外企业面试题目； 2、C 语言面试宝典(林锐《高质量编程第三版》)。 说明： 1、部分C 语言面试题中可能会参杂部分和C++ 相关的知 识，为了保持题目的灵活性故保留，但选题最终还是 会以C 语言题目为主体； 2、以上公司的面试题目已成为国内中小型企业公司出题 模板； 3、由于本人的能力有限加上...
[算法] 最短路径条数问题
zkp_java的专栏
06-15 4765
问题 给定如图所示的无向连通图，假定图中所有边的权值均为1，显然，从源点A到终点T的最短路径有多条，求不同的最短路径数目。 分析 权值相同的最短路径问题，则单源点DijkstraDijkstraDijkstra算法退化为BFS广度优先算法， 使用DijkstraDijkstraDijkstra算法只能求的到各个节点的最短路径，但不能求得最短路径的条数。假定起点为0，终点为N，数组step...
[算法] 入栈出栈问题
zkp_java的专栏
06-20 3878
问题 给定无重复元素的两个等长数组，分别表述入栈序列和出栈序列，请问：这样的出栈序列是否可行： 例如：入栈序列为”ABCDEFG”、出栈序列为”BAEDFGC”，则可行； 入栈序列为”ABCD”、出栈序列为”BDAC”，不可行； 分析 使用一个栈S来模拟压栈出栈的操作，栈顶元素即为s，记入栈序列为A，出栈序列为B，遍历B的每个元素b： 初始状态：栈s为空，认为栈顶元素与b相等，将A...
[算法] 括号匹配问题
zkp_java的专栏
06-16 1388
问题 给定字符串，仅由”()[]{}”六个字符组成，设计算法，判断该字符串是否有效。其中括号以正确的顺序配对称之为有效，如：”()”、”()[]”都是有效的，但”([)]”是无效的。...
[算法] 逆波兰表达式(栈实现)
zkp_java的专栏
06-19 1149
问题 计算给定的逆波兰表达式的值，有效操作只有+−∗/+−∗/+-*/，每个操作数都是整数; 例如： ”2”, “1”, “+”, “3”, “*” : 9，(2+1)*3 “4”, “13”, “5”, “/”, “+” : 6，4+(13/5) 分析 对于逆波兰表达式abc-d*； 若当前字符是操作数，则压栈； 若当前字符是操作符，则弹出栈中的两个操作数，计算后仍然压入栈中：...
链表操作实用代码总结
"这篇文章主要介绍了如何操作链表，包括创建、定位、插入、删除和查询链表节点的方法。" ...理解并熟练掌握链表操作是成为一名优秀程序员的基础，因为链表在各种数据结构和算法中都扮演着关键角色。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值