精华内容
下载资源
问答
  • 单链表中输出指定值的节点

    千次阅读 2015-09-20 18:11:58
    输入一个单向链表和一个节点的,从单向链表删除等于该的节点,删除后如果链表无节点则返回空指针。 链表结点定义如下: struct ListNode { int m_nKey; ListNode* m_pNext; }; 详细描述: 本题为...

    描述
    输入一个单向链表和一个节点的值,从单向链表中删除等于该值的节点,删除后如果链表中无节点则返回空指针。
    链表结点定义如下:
    struct ListNode
    {
    int m_nKey;
    ListNode* m_pNext;
    };
    详细描述:
    本题为考察链表的插入和删除知识。
    链表的值不能重复
    构造过程(x->y表示x插在y的后面),例如
    1 -> 2
    3 -> 2
    5 -> 1
    4 -> 5
    7 -> 2
    最后的链表的顺序为 2 7 3 1 5 4
    删除 结点 2
    则结果为 7 3 1 5 4

    知识点 链表,指针,结构体
    运行时间限制 10M
    内存限制 128
    输入
    1 输入链表结点个数
    2 输入头结点的值
    3 按照格式插入各个结点
    4 输入要删除的结点的值
    输出
    输出删除结点后的序列
    样例输入 5 2 3 2 4 3 5 2 1 4 3
    样例输出 2 5 4 1
      解答如下:
      //SqLink.cpp  

    #include <stdio.h>
    #include <stdlib.h>
    
    struct ListNode
    {
        int       m_nKey;
        ListNode* m_pNext;
    };
    
    int insert(struct ListNode* head,int data[]){
        struct ListNode *p=head,*q;
        while(p!=NULL){
    
            if (p->m_nKey == data[1])
            {
                q=(struct ListNode*)malloc(sizeof(struct ListNode));
                q->m_nKey = data[0];
                q->m_pNext = p->m_pNext;
                p->m_pNext = q;
                return 0;
            }
            p = p->m_pNext;
        }
        return 1;
    }
    
    //删除元素
    struct ListNode* del(struct ListNode *head,int datadet)
    {
        struct ListNode *p=head,*q=NULL;
        while(p!=NULL){
            //删除第一个结点
            if (p==head && p->m_nKey==datadet)
            {
                if(p->m_pNext==NULL) return NULL;
                head = p->m_pNext;
                free(p);
                return head;
            }
            else if (p->m_nKey == datadet)
            {
                q->m_pNext = p->m_pNext;
                free(p);
                return head;
            }
            q=p;
            p = p->m_pNext;
    
        }
        return NULL;
    
    }
    
    
    void main()
    {
        //int n;
        int data[2],num=0,shu=0,num2=0;
        struct ListNode *LsNode = (struct ListNode*)malloc(sizeof(struct ListNode));
    
        scanf("%d%d",&shu,&num2);
    
        LsNode->m_nKey=num2;
        LsNode->m_pNext=NULL;
    
        int j=0;
        for (j=0;j<shu-1;j++)
        {
            scanf("%d %d",&data[0],&data[1]);
            insert(LsNode,data);
        }
    
        scanf("%d",&num);
        LsNode=del(LsNode,num);
    
        while(LsNode!=NULL){
            printf("%d ",LsNode->m_nKey);
            LsNode = LsNode->m_pNext;
        }
        printf("\n");
    
    }

    效果如下:

    这里写图片描述

    展开全文
  • TypeScript数据结构与算法专题 - [单链表9] 单链表统计 :返回指定值在单链表结点的出现次数 李俊才 CSDN:jcLee95 邮箱:291148484@163.com 专题目录:...
    TypeScript数据结构与算法专题 -
    [单链表9] 单链表统计 :
    返回指定值在单链表结点中的出现次数

    李俊才
    CSDNjcLee95
    邮箱:291148484@163.com

    专题目录https://blog.csdn.net/qq_28550263/article/details/115718216


    【导读】:本节在前文的基础删为我们的单链表类添加统计某个元素在该链表中出现次数的方法count()

    这个功能比较简单,只要对列表的结点从头到尾进行一次遍历,在每到一个结点处比较该结点数据域中的内容与给定内容是否一致。如果一致则以为着该节点数据域中存储的数据匹配成功,表示统计出现次数的计数器加1。
    它看起来实现后时这个样子的:
    【code-1】

    count(x:any):number{
        /**
         * 返回链表中结点的值域存储内容与x内容相同的结点的个数
         * @param x {any} 用于比较的数据
         * @returns counter {number} 被统计对象在链表数据域中出现的次数
         */
        let counter = 0;
        let pointer:Lnode = this.head.next;
                                    
        while(pointer){
            if(pointer.data == x){      // 当结点数据域 与 x 内容相匹配时
                    counter++;          // 则技术
            };
            pointer = pointer.next;
        };
        
        return counter;
    };
    

    我们来试一试效果吧,给出下面的测试:
    【test-1】

    import * as slist from "./LinkList/singly_linked_list_02"    // 导入单链表
    
    let a = [1,1,2,4,5,7,5,6]
    let list = new slist.LinkList(a);
    console.log(list.count(1));
    

    Out[]:

    2
    

    好像时符合预期的。不过,我们对上述测试代码略做修改:
    【test-2】

    import * as slist from "./LinkList/singly_linked_list_02"    // 导入单链表
    
    let a = [1,1,2,4,5,7,5,6,"1"]
    let list = new slist.LinkList(a);
    console.log(list.count(1));
    

    Out[]:

    3
    

    发现结果为3。其原因在于在语句pointer.data == x1:number"1":string认为是相等的。而在很多时候,我们是希望对类型进行严格区别的。为了达到区别的目的,可以,默认使用一个较为严格的比较模式对类型进行比较。实现代码如下:
    【code-2】

    count(x:any,strict:boolean=true):number{
        /**
         * 返回链表中结点的值域存储内容与x内容相同的结点的个数
         * @param x {any} 用于比较的数据
         * @param strict? {boolean} 是否开启严格模式,如果不开启严格模式在统计时相同的不同类型
         * 可能同时被统计,如数字 1 和字符串 "1"
         * @returns counter {number} 被统计对象在链表数据域中出现的次数
         */
        let counter = 0;
        let pointer:Lnode = this.head.next;
                                    
        while(pointer){
            if(pointer.data == x){
                if(!strict){                 // 不严格判断类型模式
                    counter++;
                }
                else{                        // 严格判断类型模式
                    if(typeof(pointer.data)==typeof(x)){
                        counter++;
                    }
                }
            };
            pointer = pointer.next;
        };
        
        return counter;
    };
    

    现在我们再来试试运行的效果:
    【test-3】

    import * as slist from "./LinkList/singly_linked_list_02"    // 导入单链表模块2
    let a = [1,1,2,4,5,7,5,5,"1",3,4,7,7,3,2,4]
    let list = new slist.LinkList(a);
    console.log(list.count(1,false));     // 不严格校验类型
    console.log(list.count(1,true));      // 严格校验类型
    

    Out[]:

    3
    2
    

    符合我们的预期。

    展开全文
  • 以f为头指针的单链表中搜索其等于给定x的结点 void Search(LinkNode *f,T& x){ if (f==NULL) return; else if (f->date==x)return f; else Search(f->link,x); } 课本上的代码, 返回值是空类型 与return f...
  • 3、按序号查找结点 4、按值查找表结点 5、插入结点操作 6、删除操作 7、求表长 本篇博客的结点数据结构如下: typedef struct LNode { ElemType data; struct LNode *next; }LNode,*LinkList; 1...

    目录

    1、采用头插法建立单链表

    2、尾插法建立单链表

    3、按序号查找结点值

    4、按值查找表结点

    5、插入结点操作

    6、删除操作

    7、求表长


    本篇博客的结点数据结构如下:

    typedef struct LNode
     
    {
        ElemType data;
     
        struct LNode *next;
     
    }LNode,*LinkList;
     

    1、采用头插法建立单链表

    该方法从一个空表开始,生成新结点,并将读取到的数据存放到新结点的数据域中,然后将新结点插入到当前链表的表头,即头结点之后。如图9-1所示

                                                         图9-1  头插法建立单链表

    头插法建立单链表的代码如下:

    #include <iostream>
    
    using namespace std;
    
    typedef struct LNode
    {
        int data;
        struct LNode *next;
    }LNode, *LinkList;
    
    
    LinkList List_HeadInsert(LinkList &L)
    {
        int data;
        cout << "请输入元素值:" ;
        cin >> data;
        while(data != 10086)
        {
            LNode *node = new LNode();
            node->data = data;
            node->next = L->next;
            L->next = node;
            node = NULL;
            cout << "请输入元素值(10086表示结束):";
            cin >> data;
        }
        return L;
    }
    
    int main()
    {
        LNode headNode;
        headNode.next = NULL;
        LinkList L;
        L = &headNode;
        List_HeadInsert(L);
        return 0;
    }

    输入:

    运行结果:

    2、尾插法建立单链表

    尾插法和头插法的区别在于,头插只需要在头结点之后插入就行,而尾插要依次遍历完链表,找到最后一个结点,插在它的后面(即找到结点next为空的那个结点,然后next指针指向新插入的结点)

    尾插法建立单链表的代码如下:

    #include <iostream>
    
    using namespace std;
    
    typedef struct LNode
    {
        int data;
        struct LNode *next;
    }LNode, *LinkList;
    
    LinkList List_TailInsert(LinkList &L)
    {
        L = new LNode;
        L->next = NULL;
    
        int data;
        LinkList pTail = L;  //用来指向链表最后一个结点的指针
        cout << "请输入元素值:";
        cin >> data;
        while (data != 10086)
        {
            LNode *node = new LNode();
            node->data = data;
            pTail->next = node;
            pTail = pTail->next;
            node = NULL;
            cout << "请输入元素值(10086表示结束):";
            cin >> data;
        }
        return L;
    }
    
    int main()
    {
        LinkList L;
        List_TailInsert(L);
        return 0;
    }

    输入:

    运行结果:

    3、按序号查找结点值

    从单链表的第一个结点出发,顺指针next域逐个往下搜索,直到找到第i个结点为止,否则返回最后一个结点指针域(NULL),

    这个时候就体现了前面说的头结点里存放链表长度的好处了。

    代码:

    #include <iostream>
    
    using namespace std;
    
    typedef struct LNode
    {
        int data;
        struct LNode *next;
    }LNode, *LinkList;
    
    LinkList List_TailInsert(LinkList &L)
    {
        L = new LNode;
        L->next = NULL;
    
        int data;
        LinkList pTail = L;  //用来指向链表最后一个结点的指针
        cout << "请输入元素值:";
        cin >> data;
        while (data != 10086)
        {
            LNode *node = new LNode();
            node->data = data;
            pTail->next = node;
            pTail = pTail->next;
            node = NULL;
            cout << "请输入元素值(10086表示结束):";
            cin >> data;
        }
        return L;
    }
    
    LNode *GetElem(LinkList L, int i) 
    {
        L = L->next;
        int j = 0;
        while (L) 
        {
            j++;
            if (j == i)
                return L;
            L = L->next;
        }
        return NULL;
    }
    
    int main()
    {
        LinkList L;
        List_TailInsert(L);
        LinkList p = GetElem(L,2);
        return 0;
    }

    输入:

    运行结果:

    写完全代码太浪费时间了,后面只写操作的主要代码

    4、按值查找表结点

    从单链表的第一个结点开始,由前往后依次比较表中各结点的数据域的值,若某结点数据域的值等于给定值e,则返回该结点的指针,若整个单链表中都没有这样的结点,则返回NULL。

    算法如下:

    LNode *LocateElem(LinkList L, ElemType e) 
    {
        L = L->next;
        while (L && L->data != e)
            L = L->next;
        return L;        
    }

    5、插入结点操作

    链表p上的结点a和b之间

    s->next = p->next;

    p->next = s;

    6、删除操作

    q = p->next;

    p ->next = q->next;

    free(q);

    7、求表长

    顺次遍历,记得不要把头结点算进去就行

     

     

    人,总是要有一点精神的,不是吗

     

     

     

    展开全文
  • 单链表查找操作 一. 按序号查找 #include<iostream> using namespace std; typedef struct LNode { int data; struct LNode *next; } *LinkList,LNode; // 尾插建立单链表 LinkList List_ToolInsert ...

    单链表的查找操作

    一. 按序号查找
    #include<iostream>
    using namespace std;
    typedef struct LNode {
    	int data;
    	struct LNode *next;
    } *LinkList,LNode;
    
    
    //	尾插建立单链表
    LinkList List_ToolInsert (LinkList &L){
    	int x;
    	L = (LinkList)malloc (sizeof(LNode));
    	LNode *s,*r = L;
    	cin >> x;
    	while(x!=999){
    		s = (LNode *)malloc(sizeof(LNode));
    		s->data = x;
    		r->next = s;
    		r = s;
    		cin >> x;
    	}
    	r->next = NULL;
    	return L;
    
    }
    
    //	输出单链表
    void List_print(LinkList &L){
    	LNode *s = L;
    	while(s->next!=NULL){
    		s = s->next;
    		cout << s->data << " ";
    	}
    }
    
    //	按序号查找
    LNode *GetElem(LinkList L,int i){
    	int j=1;
    	LNode *p = L->next;
    	if(i==0)
    		return L;
    	if(i<1){
    		return NULL;
    	}
    	while(p&&j<i){
    		p = p->next;
    		j++;
    	}
    	return p;
    }
    
    
    int main(){
    	LinkList L;
    	int x;
    	L = List_ToolInsert(L);
    	cout << "则单链表为:";
    	List_print(L);
    	cout << endl << "请输入需要查找的序号:";
    	cin >> x;
    	LNode *s = GetElem(L,x);
    	cout << "查找的节点为:"  << s->data << endl;
    	return 0;
    }
    

    时间复杂度O(n)

    二. 按值查找
    #include<iostream>
    using namespace std;
    typedef struct LNode {
    	int data;
    	struct LNode *next;
    } *LinkList,LNode;
    
    
    //	尾插建立单链表
    LinkList List_ToolInsert (LinkList &L){
    	int x;
    	L = (LinkList)malloc (sizeof(LNode));
    	LNode *s,*r = L;
    	cin >> x;
    	while(x!=999){
    		s = (LNode *)malloc(sizeof(LNode));
    		s->data = x;
    		r->next = s;
    		r = s;
    		cin >> x;
    	}
    	r->next = NULL;
    	return L;
    
    }
    
    //	输出单链表
    void List_print(LinkList &L){
    	LNode *s = L;
    	while(s->next!=NULL){
    		s = s->next;
    		cout << s->data << " ";
    	}
    }
    
    //	按值查找
    LNode *LocateElem(LinkList L,int x){
    	LNode *p = L->next;
    	while(p!=NULL && p->data!=x){
    		p = p->next;
    	}
    	return p;
    }
    
    
    int main(){
    	LinkList L;
    	int x;
    	L = List_ToolInsert(L);
    	cout << "则单链表为:";
    	List_print(L);
    	cout << endl << "请输入需要查找的值:";
    	cin >> x;
    	LNode *s = LocateElem(L,x);
    	cout << "查找的节点为:"  << s->data << endl;
    	return 0;
    }
    

    时间复杂度O(n)

    展开全文
  • 单链表查找–带头结点 按位查找值查找 按位查找 /** * 按位查找,返回第i个节点 * 带头结点 * @param L * @param i * @return */ LNode * GetElem(LinkList L, int i){ if (i<0){ return NULL;...
  • 单链表查找运算

    2021-01-06 21:19:16
    查找操作 按序号查找指定值查找 按序号查找单链表的第一个元素结点起, 判断当前结点是否是第i个,若是,则返回该结点的指针,...{ //在单链表L中查找第i个元素结点 LNode *p; int j; p=L->next; //
  • 本题要求实现一个函数,可统计带头结点的单链表中大于指定值的元素个数。 函数接口定义: int GetLarger( LinkList L,ElemType e ); L是带头结点的单链表的头指针,e是要比较的元素值。函数GetUp返回单链表中大于e...
  • C语言查找某数据在单链表中出现的次数 【问题描述】接收输入数据创建一个带头结点的单链表查找某数据单链表中出现的次数并输出。 【输入形式】1.链表数据的数量;2.链表的数据元素;3.待查找的元素 【输出...
  • public class LinkNode { //单链表的结点 String key; //结点的关键字 int data; //结点的数据 LinkNode nextNode; //指向下一个结点 public LinkNode( LinkNode node){ this.nextNode = node; } public...
  • 单链表查找和建立

    2021-04-25 19:37:52
    GetElem(L,i):按位查找,获取表L第i个位置的元素的 LNode * GetElem(LinkLIst L,int i){ if(i<0) return NULL; LNode *p;//指针p指向当前扫描到的结点 int j=0;//当前p指向的是第几个结点 p=L;//L指向头...
  • 单链表查找操作

    千次阅读 2014-09-01 19:19:49
    单链表查找算法的实现 "line-height: 28px;">InputDescription "font-family: 宋体; font-size: 12pt; mso-ascii-font-family:" times="" new="" mso-hansi-font-family:="Times" new="" mso-font-k
  • } int chazhao(Linklist &L,int x)//查找指定 { Linklist p=new Link; p=L; int i=1; p=p->next; while(p!=NULL&&p->scores!=x) { p=p->next; i++; } if(p==NULL) { cout找不到这个数"; return 0; } else { ...
  • 建立一个长度为n的带头结点的单链表该表寻找第i个结点,若找到,则输出ok,否则输出error。处理数据类型为整型。 输入 第一行为链表的长度n; 第二行为链表的数据元素; 第三行为要找的结点i。 输出 找到就...
  • #include#include#define ERROR -40000using namespace std;typedef struct LNODE{int data;struct LNODE *next;}Lnode;Lnode *Input(int n){Lnode *head,*p,*q;head=p=(Lnode*)malloc(sizeof(Lnode));...
  • 目的:删除链表的某个节点的value 实现思路:新建一个新节点p,指向头节点。遍历链表,循环条件是遍历的节点的next的value与给定的value进行相比较,如果不相等,就遍历下一个;找到删除的节点后,将其前一个...
  • 先上函数模块 按序号查找结点 //按序号查找结点 LNode *GetElem(LinkList L,int i){ int j=1; LNode *p=L->next; if(i==0) return L; if(i<1) return NULL; while(p&&...按值查找
  • 单链表的删除指定节点解析

    千次阅读 2017-09-10 14:17:25
    删除指定,或者根据stack来实现删除节点我并没有写。 package com.sun.myapplication; /** * Created by sunxin on 2017/9/10. */ public class StackUtils { public class Node{ int data; Node ...
  • } } //单链表查找算法 bool GetElem_L(LinkList L, int pos, int &e) { LNode *p = L->next;int k = 1; while(p&&knext; k++; } if(!p||k>pos)//分别对应小于最低位置和大于最高位置时 return false; e = p->data; ...
  • 删除单链表中指定的节点

    千次阅读 2011-09-15 16:30:00
    //查找元素为target的节点 Node *FindNode(Node *head, int target) { Node *res = NULL; while (head->pNext != NULL) { if (head->pNext->pos == target) { return head->pNext; } head = head->...
  • 单链表是数据结构较为“简单”的一部分,但是它却是很重要的一部分。二叉树,线索二叉树,哈希函数等等的相关操作都离不开链表,因此搞懂单链表显得尤为重要。下面是我对链表简单操作的一些理解。(本文所有链表...
  • 可供操作 printf("\n输入你要选择的... printf("5、查找信息\n"); printf("6、删除信息\n"); printf("7、退出\n"); 代码使用了后插入法 #define _CRT_SECURE_NO_WARNINGS #include "stdio.h" #include "s.
  • /*查找单链表中的特定序列i,特定元素key*/ #include<stdio.h> #include<stdlib.h> #include<malloc.h> #define Max 20 typedef struct Node{ char data; struct Node*next; }Node,*Linklist;/...
  • bool DeListFirstElem(LinkList &L,ElemType x){ LNode *pre=L; LNode *p=pre->...=NULL){//找为x的结点,找不到pre和p都后移一位 pre=p; p=p->next; } if(p!=NULL){//找到p pre->next=
  • 数据结构-单链表查找按序号查找

    千次阅读 2017-09-13 15:55:09
    cout输入查找序号:"; cin>>num; int find_data=FindData(p,num); if(find_data!=ERROR) { cout查找结果为:"; } else { cout无法查询结果"; } } } return 0; }
  • 编写算法函数linklist delallx(linklist head, int x),删除带头结点单链表head所有为x的结点。 */ linklist delallx(linklist head,int x) {  linklist p=head->next,q=NULL;  while(p!=NULL)  {  ...
  • 查找单链表中的倒数第m个结点

    千次阅读 2014-12-20 16:44:54
    例4,设计一个算法求出单链表的倒数第m个结点,要求不得求出链表长度,不得对链表进行逆转,如果找到该结点就返回它的地址,否则就返回NULL。  【分析】该题目要求求出单链表的倒数第m个结点,但又不能逆转单链表。...
  • 单链表获取指定位置元素

    千次阅读 2019-03-09 12:45:05
    p == NULL 代表链表为空,pos == 0 时表示我们要找的是链表第一个元素的位置,满足这两个条件时都返回头指针head。 for (int i = 0; p &amp;&amp; i &lt; pos; i++) { p = p-&gt;next; ...
  • 分析:对于单链表A的每个元素e,在单链表B进行查找,如果B存在与A相同的元素,则将元素从A删除 算法实现 /** 算法描述:*/ /** A-B算法的实现 */ void DeleteElement(LinkList A, LinkList B) { int ...
  • 在单链表中删除指定的结点。这里单链表是用尾插法建立的,因为尾插法输出的顺序与输入的顺序是相同的。 #include using namespace std; typedef struct node { int data; struct node *next; }no; int main() { no *...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,990
精华内容 6,396
关键字:

在单链表中查找指定值