线性表练习之Example002-删除递增非空单链表中的重复值域节点

最新推荐文章于 2022-10-25 20:29:41 发布
最新推荐文章于 2022-10-25 20:29:41 发布
阅读量563 收藏 1
点赞数
分类专栏： 数据结构 文章标签： java c 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnds123321/article/details/123784414
版权

Example002

原文链接：Example002

题目

有一个递增非空单链表，设计一个算法删除值域重复的节点。例如，{1, 1, 2, 3, 3, 3, 4, 4, 7, 7, 7, 9, 9, 9} 经过删除后变成 {1, 2, 3, 4, 7, 9}。

分析

本题考查的知识点：

  • 单链表
  • 删除单链表中的节点

分析：

  • 从单链表的第一个节点开始循环单链表中的所有节点。
  • 在迭代的当前节点的后继节点存在的情况下，比较当前节点和其后继节点的数据域值是否相等，如果相等则表示重复。
  • 如果重复则删除其后继节点；如果不重复则继续判断比较下一个节点。

注意：

  • 只能删除连续重复值域的节点，不能删除非连续重复的节点。当然题目已经要求是递增非空单链表，所以重复节点一定会连续出现。
  • 如果只是纯 C 编译环境，那么参数列表中传入的单链表用指向指针的指针 **。如果是数据结构题目更倾向于使用引用 *&。

图解

请添加图片描述

C实现

核心代码：

/**
 * 删除单链表中的连续重复节点
 * @param list 单链表
 */
void deleteRepeat(LNode **list) {
    // 链表的第一个节点
    LNode *node = (*list)->next;
    // 循环单链表，删除节点
    while (node != NULL) {
        // 当前节点的后继节点
        LNode *nextNode = node->next;
        // 判断当前节点和当前节点的后继节点这两个相邻节点的值域是否相等，如果相等则删除当前节点的重复后继节点
        // 注意，必须在后继节点存在的情况下才能比较
        if (nextNode != NULL && node->data == nextNode->data) {
            // 删除重复节点
            node->next = nextNode->next;
        } else {
            // 如果不重复，则继续比较下一个节点
            node = node->next;
        }
    }
}

完整代码：

#include <stdio.h>
#include <malloc.h>

typedef struct LNode {
    int data;
    struct LNode *next;
} LNode;

/**
 * 使用尾插法创建单链表
 * @param list 单链表
 * @param nums 待插入到单链表中的数组
 * @param n 数组长度
 */
void createByTail(LNode **list, int nums[], int n) {
    // 初始化单链表
    *list = (LNode *) malloc(sizeof(LNode) * n);
    (*list)->next = NULL;
    // 链表的尾节点，初始时链表的尾节点就是头节点
    LNode *tailNode = (*list);
    // 循环数组 nums 中所有数据
    for (int i = 0; i < n; i++) {
        // 创建新节点并指定数据域和指针域
        LNode *newNode = (LNode *) malloc(sizeof(LNode));
        newNode->data = nums[i];
        newNode->next = NULL;
        // 将新节点插入到链表的尾部
        tailNode->next = newNode;
        tailNode = newNode;
    }
}

/**
 * 删除单链表中的连续重复节点
 * @param list 单链表
 */
void deleteRepeat(LNode **list) {
    // 链表的第一个节点
    LNode *node = (*list)->next;
    // 循环单链表，删除节点
    while (node != NULL) {
        // 当前节点的后继节点
        LNode *nextNode = node->next;
        // 判断当前节点和当前节点的后继节点这两个相邻节点的值域是否相等，如果相等则删除当前节点的重复后继节点
        // 注意，必须在后继节点存在的情况下才能比较
        if (nextNode != NULL && node->data == nextNode->data) {
            // 删除重复节点
            node->next = nextNode->next;
        } else {
            // 如果不重复，则继续比较下一个节点
            node = node->next;
        }
    }
}

/**
 * 打印单链表所有节点
 * @param list 单链表
 */
void print(LNode list) {
    printf("[");
    // 链表的第一个节点
    LNode *node = list.next;
    // 循环单链表所有节点，打印值
    while (node != NULL) {
        printf("%d", node->data);
        if (node->next != NULL) {
            printf(", ");
        }
        node = node->next;
    }
    printf("]\n");
}

int main() {
    LNode *list;
    int nums[] = {1, 1, 2, 3, 3, 3, 4, 4, 7, 7, 7, 9, 9, 9};
    int n = 14;

    // 创建单链表
    createByTail(&list, nums, n);
    print(*list);

    // 删除单链表中的连续重复节点
    deleteRepeat(&list);
    print(*list);
}

执行结果：

[1, 1, 2, 3, 3, 3, 4, 4, 7, 7, 7, 9, 9, 9]
[1, 2, 3, 4, 7, 9]

注意：在数据结构题目中更倾向于使用 *& 引用来修改单链表，而不是使用指向指针的指针 **。尽管那属于 C++ 中的知识。

#include <stdio.h>
#include <malloc.h>

typedef struct LNode {
	int data;
	struct LNode *next;
} LNode;

/**
 * 使用尾插法创建单链表
 * @param list 单链表
 * @param nums 待插入到单链表中的数组
 * @param n 数组长度
 */
void createByTail(LNode *&list, int nums[], int n) {
	// 初始化单链表
	list = (LNode *) malloc(sizeof(LNode) * n);
	list->next = NULL;
	// 链表的尾节点，初始时链表的尾节点就是头节点
	LNode *tailNode = list;
	// 循环数组 nums 中所有数据
	for (int i = 0; i < n; i++) {
		// 创建新节点并指定数据域和指针域
		LNode *newNode = (LNode *) malloc(sizeof(LNode));
		newNode->data = nums[i];
		newNode->next = NULL;
		// 将新节点插入到链表的尾部
		tailNode->next = newNode;
		tailNode = newNode;
	}
}

/**
 * 删除单链表中的连续重复节点
 * @param list 单链表
 */
void deleteRepeat(LNode *&list) {
	// 链表的第一个节点
	LNode *node = list->next;
	// 循环单链表，删除节点
	while (node != NULL) {
		// 当前节点的后继节点
		LNode *nextNode = node->next;
		// 判断当前节点和当前节点的后继节点这两个相邻节点的值域是否相等，如果相等则删除当前节点的重复后继节点
		// 注意，必须在后继节点存在的情况下才能比较
		if (nextNode != NULL && node->data == nextNode->data) {
			// 删除重复节点
			node->next = nextNode->next;
		} else {
			// 如果不重复，则继续比较下一个节点
			node = node->next;
		}
	}
}

/**
 * 打印单链表所有节点
 * @param list 单链表
 */
void print(LNode list) {
	printf("[");
	// 链表的第一个节点
	LNode *node = list.next;
	// 循环单链表所有节点，打印值
	while (node != NULL) {
		printf("%d", node->data);
		if (node->next != NULL) {
			printf(", ");
		}
		node = node->next;
	}
	printf("]\n");
}

int main() {
	LNode *list;
	int nums[] = {1, 1, 2, 3, 3, 3, 4, 4, 7, 7, 7, 9, 9, 9};
	int n = 14;

	// 创建单链表
	createByTail(list, nums, n);
	print(*list);

	// 删除单链表中的连续重复节点
	deleteRepeat(list);
	print(*list);
}

Java实现

核心代码：

    /**
     * 删除链表中的所有连续值域重复节点
     */
    public void deleteRepeat() {
        // 链表的第一个节点
        Node node = list.next;
        // 遍历链表所有节点
        while (node != null) {
            // 当前节点的后继节点
            Node nextNode = node.next;
            // 如果当前节点的后继节点存在并且当前节点的数据域值等于其后继节点的数据域值，那么表示这两个相邻节点重复，则删除这个重复的后继节点
            if (nextNode != null && node.data == nextNode.data) {
                // 删除重复节点
                node.next = nextNode.next;
            } else {
                // 如果相邻节点不重复，则继续链表的下一个节点
                node = node.next;
            }
        }
    }

完整代码：

public class LinkedList {
    private Node list;

    /**
     * 通过尾插法创建单链表
     *
     * @param nums 创建单链表时插入的数据
     * @return 创建好的单链表
     */
    public Node createByTail(int... nums) {
        list = new Node();
        list.next = null;
        Node temp = list;

        for (int i = 0; i < nums.length; i++) {
            // 创建新节点，并指定数据域和指针域
            Node newNode = new Node();
            newNode.data = nums[i];
            newNode.next = null;
            // 将新节点插入到单链表的尾部
            temp.next = newNode;
            temp = newNode;
        }

        return list;
    }

    /**
     * 删除链表中的所有连续值域重复节点
     */
    public void deleteRepeat() {
        // 链表的第一个节点
        Node node = list.next;
        // 遍历链表所有节点
        while (node != null) {
            // 当前节点的后继节点
            Node nextNode = node.next;
            // 如果当前节点的后继节点存在并且当前节点的数据域值等于其后继节点的数据域值，那么表示这两个相邻节点重复，则删除这个重复的后继节点
            if (nextNode != null && node.data == nextNode.data) {
                // 删除重复节点
                node.next = nextNode.next;
            } else {
                // 如果相邻节点不重复，则继续链表的下一个节点
                node = node.next;
            }
        }
    }

    /**
     * 打印单链表所有节点
     */
    public void print() {
        // 链表的第一个节点
        Node node = list.next;
        // 循环打印
        String str = "[";
        while (node != null) {
            str += node.data;
            if (node.next != null) {
                str += ", ";
            }
            node = node.next;
        }
        str += "]";
        System.out.println(str);
    }
}

class Node {
    /**
     * 链表的数据域，暂时指定为 int 类型，因为 Java 支持泛型，可以指定为泛型，就能支持更多的类型了
     */
    int data;
    /**
     * 链表的指针域，指向该节点的下一个节点
     */
    Node next;
}

测试代码：

/**
 * @author lcl100
 * @create 2022-02-24 10:05
 */
public class LinkedListTest {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        // 创建单链表
        list.createByTail(1, 1, 2, 3, 3, 3, 4, 4, 7, 7, 7, 9, 9, 9);
        list.print();

        // 删除重复节点
        list.deleteRepeat();
        list.print();
    }
}

执行结果：

[1, 1, 2, 3, 3, 3, 4, 4, 7, 7, 7, 9, 9, 9]
[1, 2, 3, 4, 7, 9]
二木成林
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表的链式实现-----单链表
07-02
LinkList.h与LinkList.c。使用c语言实现单链表数据结构。注释详细。
算法设计 删除无序单链表中的值域重复的结点
GU
02-25 3465
删除无序单链表中的值域重复的结点 题目： 有一个带头结点的单链表head，其中可能出值域重复的结点，设计一个算法删除值域重复的结点。要求在主函数中调用设计的算法，给出结果。 思路：删除某个结点值的重复结点，只需要遍历单链表找到与之相同的结点删除即可。删除多个不同结点值的重复结点，可以按链表顺序一个一个调用删除函数即可。因此可以使用递归实现。 测试数据： 样例1：1、2、3、4、5、6、7、8、9、...
单链表-删除重复节点（递增链表）
muyu_muyu的博客
12-22 562
单链表的存储结构： typedef struct LinkList{ int data; LinkList * next; } 分析： 这里删除重复节点，分两种情况： 1.第一种是链表本身递增的 2.第二种是链表可能是无序的 无序的更复杂些，递增更简单些。 这里是递增，说明重复的结点是在一起的，连续的。 既然要删除结点，肯定要定义两个指针，pre,p 思路： 1.定义两个指针pre,p ,pre一开始指向第一个节点，p暂且不指向 2.通过while循环,条件为p !
C语言实现数据结构代码（一）-线性表-单链表-去除单链表中的重复结点
Don-Talk的博客
12-10 553
一、去除单链表中的重复结点 #include <iostream> #include <stdio.h> #include <stdlib.h> #include <time.h> using namespace std; //删除单链表中的重复结点 typedef struct LNode //单链表结点定义 { int data; LNode *next; }LNode; //创建一个单链表结点 void CreateLNode(LNod
有序链表删除重复数字节点c语言,删除顺序线性表中重复元素（C语言），求解...
weixin_39722692的博客
05-17 448
该楼层疑似违规已被系统折叠隐藏此楼查看此楼帮你改好了：#include #include#define MAXSIZE 20typedef int datatype;typedef struct{datatype data[MAXSIZE];int last; /*顺序表中最后一个元素的序号*/}SeqList;/*创建顺序表*/void input(S...
删除一个递增非空单链表中值域重复的结点
qq_43648337的博客
07-21 990
要求：删除一个递增非空单链表中值域重复的结点 void delete(LNode *L) { LNode *p,*q; p = L->next;//p指向第一个结点 while(p != NULL) { if(p->data == p->next->data)//如果相等则删除q指向的结点 { q = p->next;//q指向要删除的结点 p->next = q->next; free(q); } else {
数据结构-删除重复结点
慢慢来有点快
06-11 1668
删除重复结点（链表） 有一个递增非空单链表，设计一个算法删除值域重复的结点。例如，{1，1，2，3，3，3，4，4，7，7，7，9，9，9}经过删除后变成{1，2，3，4，7，9}. 思路一： 可以用一个指针p指向起始结点，如果p所指的值等于后继结点的值，则删除后继节点；否则p就指向后继节点。重复以上过程，直到p的后继节点为空。 代码一： void delsl1 (LNode *L){ LNode *p=L->next,*q; //定义两个指针，其中q指向起始结点 while
删除单链表中值域重复的点
happy_bigqiang的博客
11-11 2247
题目描述：有一个递增非空单链表，设计一个算法删除值域重复的结点；例如{1,1,2,3,3,3，4,4,4,7,7,7,9,9,9}经过删除后变成{1，2,3,4，7,9}———-亲测有效#include <stdio.h> #include <stdlib.h>#define ERROR NULL typedef enum {false, true} bool; typedef int Elemen
【C++编程题】链表删除重复节点
西木的博客
10-25 981
C++编程实现链表删除重复节点
数据结构---线性表之单链表（C语言）
03-28
数据结构---线性表之单链表，包括单链表的创建、插入、删除等，C语言编写
实验1-2 线性表-单链表.doc
最新发布
04-11
实验1-2 线性表-单链表.doc
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc
12-02
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc
第二章 线性表 有序表删除重复元素
Cgxxxxxxxxxxxxxx的博客
01-18 192
#include <stdio.h> using namespace std; #define Max 50 struct SqlList{ int a[Max]={1,2,3,3,3,5,5,7,7,8,9,10,11,11,22,22,23}; int length=17; }; void delCommen(SqlList &s){ int k=0; if(s.length==0){ printf("线性表为空\n"); ...
线性表——删除重复元素
qq_53318060的博客
09-17 4211
题目：移除线性表中的所有重复元素；不要使用额外的数组空间，在使用 O(1) 额外空间的条件下完成。 typedef int DataType; struct seqList { int MAXNUM; // 能存放的最大元素个数 int curNum; // 数据元素的个数 DataType *element; }; typedef struct seqList *PseqList; 实现的两种思路 void delDuplicate_seq(PseqList L
双向链表删除节点时间复杂度_Task 38. 链表：237. 删除链表中的节点
weixin_39608613的博客
12-03 123
Task 38. 链表：237. 删除链表中的节点237. 删除链表中的节点 - 力扣（LeetCode）​leetcode-cn.com题目描述：请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。现有一个链表 -- head = [4,5,1,9]，它可以表示为:示例 1:输入: head = [4,5,1,9], node = 5 输出: [4,1,9]...
有序单链表删除值域重复结点算法
weixin_45959708的博客
08-20 2635
已知一个有序单链表L（允许出现值域重复的结点），设计一个高效算法删除值域重复的结点，并分析算法的时间复杂度。 解：由于是有序单链表，所以相同值域的结点都是相邻的。用p扫描递增单链表，若p所指结点的值域等于后继点的值域，则删除后者。 实现代码如下： #include <stdio.h> #include <malloc.h> typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *next;
考研数据结构之线性表（1.7）——练习题之删除单链表重复值域（C表示）
二木成林
05-21 1141
题目 有一个递增非空单链表，设计一个算法删除值域重复的结点。例如，{1，1，2，3，3，3，4，4，7，7，7，9，9，9}经过删除后变成{1，2，3，4，7，9}。 分析 定义指针p指向起始结点。将p所指的当前结点值域和其直接后继结点值域做比较。如果当前结点值域等于后继结点值域，则删除后继结点;否则p指向后继结点。重复以上过程，直到p的后继结点为空。 代码 #include <stdio.h> #include <stdlib.h> // 声明单链表结构体 str.
考研数据结构之查找（9.8）——练习题之将关键字序列{7,8,30,11,18,9,14}散列存储到散列表中（C表示）
热门推荐
二木成林
06-09 1万+
题目 将关键字序列{7,8,30,11,18,9,14}散列存储到散列表中,散列表的存储空间是一个下标从0开始的一维数组，散列函数为H(key)=(key*3) Mod 7，处理冲突采用线性探测再散列法，要求装填因子为0.7. （1）请画出所构造的散列表。 （2）分别计算等概率情况下，查找成功和查找不成功时的平均查找长度。 分析 ...
线性表-顺序存储-删除重复元素
03-31
思路：遍历线性表，将不重复的元素依次存放在前面的位置上，记录不重复元素的个数，最后将多余的元素删除。 具体实现： 1. 初始化一个变量count表示不重复元素的个数，初始值为1，因为第一个元素一定不重复。 2. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值