数据结构（2-5~2-8）

news2024/11/17 7:25:18

2-5编写算法，在单链表中查找第一值为x的结点，并输出其前驱和后继的存储位置

#include<stdio.h>
#include<stdlib.h>

typedef int DataType; 
struct Node
{
    DataType      data; 
    struct Node*  next;  
};
typedef struct Node  *PNode;    
typedef struct Node  *LinkList;   


LinkList SetNullList_Link() //设置头结点
{
    LinkList head = (LinkList)malloc(sizeof(struct Node));
    if (head != NULL) head->next = NULL;
    else printf("alloc failure");
    return head; 
}

void CreateList_Tail(struct Node* head)//利用尾插法
{
    PNode p = NULL;
    PNode q = head;
    DataType data;
    scanf("%d", &data);
    while (data != -1)
    {   
        p = (struct Node*)malloc(sizeof(struct Node));
        p->data = data;
        p->next = NULL;
        q->next = p;
        q = p;
        scanf("%d", &data);
    }
}
int Inserch_num(LinkList head,int x)//找值 
{
   LinkList p;
   int i=0;
   p=head->next;
   while(p)//把前后特殊情况单列出来 
   {
    if(i==0&&p->data==x)
    {
     printf("The Prodrove node is head,the position of the rear  node is at position 2 of the linked list\n");
     return 0;
	}
	 if(p->data==x&&p->next==NULL)
	{
         printf("The Prodrove node is %d,there is no rear node\n ",i);
       return 0;
	}
	 if(p->data==x)
	{
	   printf("The Prodrove node is %d,he rear node is %d\n",i,i+2); 
      return 0;
	}
     i++;
     p = p->next;
   }
   return 0;
}
void print(LinkList head)   //打印
{
    PNode  p = head->next;
    while (p)
    {
        printf("%d ", p->data);
        p = p->next;
    }
}
void DestoryList_Link(LinkList head)  //销毁链表
{
    PNode  pre = head; 
    PNode p = pre->next;
    while (p)
    {
        free(pre);
        pre = p;
        p = pre->next;
    }
    free(pre);
}

int main()
{
    LinkList head = NULL;
    int x=0,a=0;
    head = SetNullList_Link();
    CreateList_Tail(head);
    print(head);
    printf("\n");
    printf("Please input the number you find:");
    scanf("%d",&x);
    a=x;
    Inserch_num(head,a);
   DestoryList_Link(head);
    return 0;
}

在这里插入图片描述

2-6在单循环链表中，编写算法实现将链表中数据域为奇数的结点移至表头，将链表中数据域为偶数的结点移至表尾

#include<stdio.h>
#include<stdlib.h>

typedef int DataType; 
struct Node {
    DataType      data; 
    struct Node*  next;  
};
typedef struct Node  *PNode;    
typedef struct Node  *LinkList;   

LinkList CreateList_Tail_loop()
{
    LinkList head = (LinkList)malloc(sizeof(struct Node));
    PNode cur = NULL;
    PNode tail = head;
    DataType data;
    scanf("%d", &data);
    while (data != -1)
    {   
        cur = (struct Node*)malloc(sizeof(struct Node));
        cur->data = data;
        tail->next = cur;
        tail = cur;
        scanf("%d", &data);
    }
    tail->next = head;
    return tail;
}
PNode Move_Odd_Even(LinkList tail)
{
    PNode head=tail->next,pre=head->next,q=pre->next;
    PNode pre1,head1=(PNode)malloc(sizeof(struct Node));
    PNode pre2,head2=(PNode)malloc(sizeof(struct Node));
    pre1=head1;
    pre2=head2;
    while(q!=head->next)
    {
        if(pre->data%2==0)
        {
            pre->next=pre1->next;
            pre1->next=pre;
            pre1=pre;
        }
        else
        {
            pre->next=pre2;
            pre2->next=pre;
            pre2=pre;
        }
    pre=q;
    q=q->next;
    }
head1=head1->next;
pre2->next=head1;
pre1->next=head2;
return pre1;
}
void print(LinkList tail)    
{
    PNode  head = tail->next;
    PNode p = head->next;
    while (p != head)
    {
        printf("%d ", p->data);
        p = p->next;
    }
}

void DestoryList_Link(LinkList tail)
{
    PNode pre = tail->next;
    PNode p = pre->next;
    while (p != tail)
    {
        free(pre);
        pre = p;
        p = pre->next;
    }
    free(pre);
    free(tail);
}

int main()
{
    LinkList tail = NULL;
    LinkList p = NULL;
    tail = CreateList_Tail_loop();
    p = Move_Odd_Even(tail);
    print(p);
    DestoryList_Link(tail);
    return 0;
}

在这里插入图片描述

2-7将两个有序线性表LIST1=（a1,a2,…，an）和LIST2=（b1,b2,…,bn）链接成一个有序线性链表LIST3,并删除LIST3链表中相同的结点，即链接中若有多个结点具有相同的数据域，只保留一个结点，使得顺序表中所有结点的数据域都不相同。在采用顺序表和单链表两种形式下分别设计算法实现上述功能

#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 100

void mergeAndRemoveDuplicates(int list1[], int list2[], int n1, int n2, int list3[]) {
    int i = 0, j = 0, k = 0;
    
    while (i < n1 && j < n2) {
        if (list1[i] < list2[j]) {
            list3[k] = list1[i];
            i++;
            k++;
        } else if (list1[i] > list2[j]) {
            list3[k] = list2[j];
            j++;
            k++;
        } else {  // 相同元素
            list3[k] = list1[i];
            i++;
            j++;
            k++;
        }
    }
    
    while (i < n1) {
        list3[k] = list1[i];
        i++;
        k++;
    }
    
    while (j < n2) {
        list3[k] = list2[j];
        j++;
        k++;
    }
}

void removeDuplicates(int list[], int size) {
    int i, j, k;
    
    for (i = 0; i < size; i++) {
        for (j = i + 1; j < size;) {
            if (list[j] == list[i]) {
                for (k = j; k < size - 1; k++) {
                    list[k] = list[k + 1];
                }
                size--;
            } else {
                j++;
            }
        }
    }
}

int main() {
	int i = 0; 
    int list1[] = {1, 2, 3, 5, 7};
    int list2[] = {3, 4, 5, 6, 8};
    int n1 = sizeof(list1) / sizeof(list1[0]);
    int n2 = sizeof(list2) / sizeof(list2[0]);
    
    int list3[MAX_SIZE];
    
    mergeAndRemoveDuplicates(list1, list2, n1, n2, list3);
    removeDuplicates(list3, n1 + n2);
    
    printf("Merged and duplicates removed list: ");
    for ( i = 0; i <8; i++) {
        printf("%d \n", list3[i]);
    }
    printf("\n");
    
    return 0;
}

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>

struct ListNode {
    int val;
    struct ListNode* next;
};

struct ListNode* createNode(int val) {
    struct ListNode* newNode = (struct ListNode*)malloc(sizeof(struct ListNode));
    newNode->val = val;
    newNode->next = NULL;
    return newNode;
}

struct ListNode* mergeAndRemoveDuplicates(struct ListNode* list1, struct ListNode* list2) {
    struct ListNode* p = list1;
    struct ListNode* q = list2;
    struct ListNode* list3 = NULL; // 指向结果链表的头节点
    struct ListNode* tail = NULL; // 指向结果链表的尾节点
    
    while (p && q) {
        if (p->val < q->val) {
            // 若当前元素小于另一个表的当前元素，则将当前元素插入到结果链表中
            if (list3 == NULL) {
                list3 = tail = createNode(p->val);
            } else {
                tail->next = createNode(p->val);
                tail = tail->next;
            }
            p = p->next;
        } else if (p->val > q->val) {
            // 若当前元素大于另一个表的当前元素，则将当前元素插入到结果链表中
            if (list3 == NULL) {
                list3 = tail = createNode(q->val);
            } else {
                tail->next = createNode(q->val);
                tail = tail->next;
            }
            q = q->next;
        } else {  // 相同元素，只保留一个
            if (list3 == NULL) {
                list3 = tail = createNode(p->val);
            } else {
                tail->next = createNode(p->val);
                tail = tail->next;
            }
            p = p->next;
            q = q->next;
        }
    }
    
    // 将剩余的元素插入结果链表中
    while (p) {
        tail->next = createNode(p->val);
        tail = tail->next;
        p = p->next;
    }
    
    while (q) {
        tail->next = createNode(q->val);
        tail = tail->next;
        q = q->next;
    }
    
    // 删除结果链表中重复的元素
    struct ListNode* cur = list3;
    while (cur && cur->next) {
        if (cur->val == cur->next->val) {
            struct ListNode* temp = cur->next;
            cur->next = cur->next->next;
            free(temp);
        } else {
            cur = cur->next;
        }
    }
    
    return list3;
}

void printList(struct ListNode* head) {
    struct ListNode* cur = head;
    while (cur != NULL) {
        printf("%d ", cur->val);
        cur = cur->next;
    }
    printf("\n");
}

int main() {
    struct ListNode* list1 = createNode(1);
    list1->next = createNode(2);
    list1->next->next = createNode(3);
    list1->next->next->next = createNode(5);
    list1->next->next->next->next = createNode(7);
    
    struct ListNode* list2 = createNode(3);
    list2->next = createNode(4);
    list2->next->next = createNode(5);
    list2->next->next->next = createNode(6);
    list2->next->next->next->next = createNode(8);
    
    struct ListNode* list3 = mergeAndRemoveDuplicates(list1, list2);
    
    printf("Merged and duplicates removed list: ");
    printList(list3);
    
    // 释放链表的内存空间
    struct ListNode* temp;
    while (list3) {
        temp = list3;
        list3 = list3->next;
        free(temp);
    }
    
    return 0;
}

在这里插入图片描述

2-8设双链表中的结点包括4个部分：前驱指针llink，后继指针rlink，数据域data，访问频度freq，初始时将各结点的freq设置为0。当对某结点访问时使该结点的freq增加1，并且将链表按照访问freq递减的顺序进行排序。请编写算法实现以上功能

#include <stdio.h>
#include <stdlib.h>

struct DoubleListNode {
    int data;
    int freq;
    struct DoubleListNode* llink;
    struct DoubleListNode* rlink;
};

struct DoubleListNode* createNode(int data) {
    struct DoubleListNode* newNode = (struct DoubleListNode*)malloc(sizeof(struct DoubleListNode));
    if (newNode == NULL) {
        printf("Memory allocation failed.\n");
        exit(1);
    }
    newNode->data = data;
    newNode->freq = 0;
    newNode->llink = NULL;
    newNode->rlink = NULL;
    return newNode;
}

void insertNode(struct DoubleListNode** head, int data) {
    struct DoubleListNode* newNode = createNode(data);
    
    if (*head == NULL) {
        *head = newNode;
        return;
    }
    
    // 插入到链表头部
    newNode->rlink = *head;
    (*head)->llink = newNode;
    *head = newNode;
}

void increaseFreq(struct DoubleListNode** head, int data) {
    if (*head == NULL) {
        return;
    }
    
    struct DoubleListNode* cur = *head;
    
    while (cur != NULL) {
        if (cur->data == data) {
            cur->freq++;
            
            // 调整链表顺序
            struct DoubleListNode* prev = cur->llink;
            while (prev != NULL && prev->freq < cur->freq) {
                struct DoubleListNode* next = cur->rlink;
                
                if (prev->llink) {
                    prev->llink->rlink = cur;
                }
                cur->llink = prev->llink;
                
                cur->rlink = prev;
                prev->llink = cur;
                
                if (next) {
                    next->llink = prev;
                }
                prev->rlink = next;
                
                prev = cur->llink;
            }
            
            break;
        }
        
        cur = cur->rlink;
    }
}

void printList(struct DoubleListNode* head) {
    struct DoubleListNode* cur = head;
    while (cur != NULL) {
        printf("(%d,%d) ", cur->data, cur->freq);
        cur = cur->rlink;
    }
    printf("\n");
}

void freeList(struct DoubleListNode* head) {
    struct DoubleListNode* cur = head;
    while (cur != NULL) {
        struct DoubleListNode* temp = cur;
        cur = cur->rlink;
        free(temp);
    }
}

int main() {
    struct DoubleListNode* head = NULL;
    
    insertNode(&head, 3);
    insertNode(&head, 5);
    insertNode(&head, 2);
    insertNode(&head, 8);
    
    printf("Original list: ");
    printList(head);
    
    increaseFreq(&head, 2);
    increaseFreq(&head, 5);
    increaseFreq(&head, 3);
    
    printf("Updated list: ");
    printList(head);
    
    // 释放链表的内存空间
    freeList(head);
    
    return 0;
}

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1066828.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【高并发优化手段】基于Springboot项目

【高并发优化手段】基于Springboot项目

文章目录 一、概述二、服务器配置1. 选择合适的机器2. 配置服务器参数&#xff08;1&#xff09;TCP网络层参数如何配置 &#xff08;2&#xff09;文件系统参数仅根据硬件配置&#xff0c;估算机器的最大性能修改配置 &#xff08;3&#xff09;内存参数 三、Tomcat配置1. 调整…
阅读更多...
11.2 基本电路和基本分析方法

11.2 基本电路和基本分析方法

一、基本电路 电路类型电路名称特点和典型功能指标参数或功能描述方法基本放大电路共射放大 ∣ A ˙ ∣ |\dot A| ∣A˙∣大&#xff1b;适用于小信号电压放大 A ˙ u \dot A_u A˙u​、 R i R_i Ri​、 R o R_o Ro​、 f L f_L fL​、 f H f_H fH​、 f b w f_{bw} fbw​共集…
阅读更多...
echarts的bug，在series里写tooltip，不起作用，要在全局先写tooltip：{}才起作用，如果在series里写的不起作用就写到全局里

echarts的bug，在series里写tooltip，不起作用，要在全局先写tooltip：{}才起作用，如果在series里写的不起作用就写到全局里

echarts的bug&#xff0c;在series里写tooltip&#xff0c;不起作用&#xff0c;要在全局先写tooltip&#xff1a;{show:true}才起作用&#xff0c;如果在series里写的不起作用就写到全局里 series里写tooltip不起作用&#xff0c;鼠标悬浮在echarts图表上时不显示提示 你需要…
阅读更多...
（一）Log4Net - 介绍

（一）Log4Net - 介绍

0、相关概念 Log4j 几乎每个大型应用程序都包含自己的日志记录或跟踪 API。根据这一规则&#xff0c;E.U. SEMPER &#x1f339;项目决定编写自己的跟踪 API。那是在 1996 年初。经过无数次的增强、几个化身和大量的工作&#xff0c;API 已经发展成为 log4j —— 一个流行的 Ja…
阅读更多...
LabVIEW利用以太网开发智能液位检测仪

LabVIEW利用以太网开发智能液位检测仪

LabVIEW利用以太网开发智能液位检测仪 目前&#xff0c;工业以太网接口在国内外的发展已经达到了相当深入的程度&#xff0c;特别是在自动化控制和工业控制领域有着非常广泛的应用。在工业生产过程中&#xff0c;钢厂的连铸机是前后的连接环节&#xff0c;其中钢水从大钢包进入…
阅读更多...
ToBeWritten之改进威胁猎杀：自动化关键角色与成功沟通经验

ToBeWritten之改进威胁猎杀：自动化关键角色与成功沟通经验

也许每个人出生的时候都以为这世界都是为他一个人而存在的&#xff0c;当他发现自己错的时候&#xff0c;他便开始长大 少走了弯路&#xff0c;也就错过了风景&#xff0c;无论如何&#xff0c;感谢经历 转移发布平台通知&#xff1a;将不再在CSDN博客发布新文章&#xff0c;敬…
阅读更多...
C ++ 1

C ++ 1

阅读更多...
uni-app--》基于小程序开发的电商平台项目实战（四）

uni-app--》基于小程序开发的电商平台项目实战（四）

&#x1f3cd;️作者简介&#xff1a;大家好&#xff0c;我是亦世凡华、渴望知识储备自己的一名在校大学生 &#x1f6f5;个人主页&#xff1a;亦世凡华、 &#x1f6fa;系列专栏&#xff1a;uni-app &#x1f6b2;座右铭&#xff1a;人生亦可燃烧&#xff0c;亦可腐败&#xf…
阅读更多...
八大排序详解(默认升序)

八大排序详解(默认升序)

一、直接插入排序 直接插入排序&#xff1a;直接插入排序就是像打扑克牌一样&#xff0c;每张牌依次与前面的牌比较&#xff0c;遇到比自己大的就将大的牌挪到后面&#xff0c;遇到比自己小的就把自己放在它后面(如果自己最小就放在第一位)&#xff0c;所有牌排一遍后就完成了排…
阅读更多...
PX4仿真添加world模型文件，并使用yolov8进行跟踪

PX4仿真添加world模型文件，并使用yolov8进行跟踪

前言 目的：我们是为了在无人机仿真中使用一个汽车模型，然后让仿真的无人机能够识别到这个汽车模型。所以我们需要在无人机仿真的环境中添加汽车模型。 无人机仿真中我们默认使用的empty.world文件，所以只需要将我们需要的模型添加到一起写进这个empty.world文件中去就可以…
阅读更多...
电脑多开微信教程，可以多开n个

电脑多开微信教程，可以多开n个

下载地址 链接&#xff1a;https://pan.baidu.com/s/1uWXIhfTZ-aD0A4RBxrI8bg?pwdy2s5 提取码&#xff1a;y2s5 效果如图&#xff1a;
阅读更多...
地下水数值模拟软件如何选择？GMS、Visual MODFLOW Flex、FEFLOW、MODFLOW

地下水数值模拟软件如何选择？GMS、Visual MODFLOW Flex、FEFLOW、MODFLOW

强调模块化教学&#xff0c;分为前期数据收集与处理&#xff1b;三维地质结构建模&#xff1b;地下水流动模型构建&#xff1b;地下水溶质运移模型构建和反应性溶质运移构建5个模块&#xff1b;采用全流程模式将地下水数值模拟软件GMS的操作进行详细剖析和案例联系。不仅使学员…
阅读更多...
Android中的RxJava入门及常用操作符

Android中的RxJava入门及常用操作符

文章目录 1.定义2.作用3.特点4.使用4.1创建被观察者&#xff08;Observable&#xff09;4.2创建观察者&#xff08;Observer&#xff09;4.3订阅&#xff08;Subscribe&#xff09;4.4Dispose 5.操作符5.1操作符类型5.2just操作符5.2链式调用5.3 fromArray操作符5.4 fromIterab…
阅读更多...
服务器文件备份

服务器文件备份

服务器上&#xff0c;做好跟应用程序有关的文件备份&#xff08;一般备份到远程的盘符&#xff09;&#xff0c;有助于当服务器发生硬件等故障时&#xff0c;可以对系统进行进行快速恢复。 下面以Windows服务器为例&#xff0c;记录如何做文件的备份操作。 具体操作如下&#…
阅读更多...
贷款行业，教你如何直接沟通客户

贷款行业，教你如何直接沟通客户

信贷行业拓展业务的人力与时间成本非常高。如是做小微贷款业务的公司可能在寻找贷款客户、筛选客户资质这两项初始工作上花掉超过50%的精力。 并且由于行业特殊性&#xff0c;金融信贷受政策的影响比较大&#xff0c;没法形成固定的推广渠道&#xff0c;线上营销不好做&#x…
阅读更多...
什么是站内搜索引擎？如何在网站中加入站内搜索功能？

什么是站内搜索引擎？如何在网站中加入站内搜索功能？

在当今数字时代&#xff0c;用户体验对于网站的成功起着至关重要的作用。提升用户体验和改善整体网站性能的一种方法是引入站内搜索引擎。站内搜索引擎是一种强大的工具&#xff0c;它的功能类似于Google或Bing等流行搜索引擎&#xff0c;但它专注于实施自己网站上的内容。用户…
阅读更多...
工业路由器项目应用(4g+5g两种工业路由器项目介绍)

工业路由器项目应用(4g+5g两种工业路由器项目介绍)

引言&#xff1a; 随着工业智能化的不断发展&#xff0c;工业路由器在各个领域的应用越来越广泛。本文将介绍两个工业路由器项目的应用案例&#xff0c;一个是使用SR500 4g工业路由器&#xff0c;另一个是使用SR800 5g工业路由器。 详情&#xff1a;https://www.key-iot.com/i…
阅读更多...
IPO观察丨重新启动上市，“小而美”能让科迪乳业再次出圈吗？

IPO观察丨重新启动上市，“小而美”能让科迪乳业再次出圈吗？

如今&#xff0c;乳制品市场俨然是一片红海&#xff0c;尽管市场竞争激烈&#xff0c;但对于一些企业而言&#xff0c;发展机会仍然相当可观。 近日举办的2023年中工作会议上&#xff0c;科迪乳业母公司科迪集团对外表示&#xff0c;要部署好下个阶段的重点工作&#xff0c;为…
阅读更多...
Jenkins 添加节点Node报错JNI error has occurred UnsupportedClassVersionError

Jenkins 添加节点Node报错JNI error has occurred UnsupportedClassVersionError

节点日志 报错信息如下 Error: A JNI error has occurred, please check your installation and try again Exception in thread “main” java.lang.UnsupportedClassVersionError: hudson/remoting/Launcher has been compiled by a more recent version of the Java Runtime…
阅读更多...
阿里云服务器通用算力型、经济型、七代云服务器实例、倚天云服务器实例区别参考

阿里云服务器通用算力型、经济型、七代云服务器实例、倚天云服务器实例区别参考

目前阿里云服务器的实例规格中&#xff0c;既有五代六代实例规格&#xff0c;也有七代和八代倚天云服务器&#xff0c;同时还有通用算力型及经济型这些刚推出不久的新品云服务器实例&#xff0c;其中第五代实例规格已经不是主推的实例规格了&#xff0c;现在主售的实例规格是七…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023