算法题，删除特定值，逆置的三种方法，原地逆置，链表排序，求链表的公共结点，链表归并，链表匹配算法

最新推荐文章于 2022-12-03 11:30:41 发布
最新推荐文章于 2022-12-03 11:30:41 发布
阅读量87 收藏
点赞数
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32113889/article/details/108012643
版权 
#include <stdbool.h>
#include "stdio.h"
#include "stdlib.h"
/*学习心得，代码尽量自己想，没思路再去看答案，但是代码还是自己写，只是借鉴思路而已。做完，如果答案有不同的思路，就按照答案再做一遍*/
struct ListNode {
    int val;
    struct ListNode *next;
};
/*工具类，栈*/
int top=0;
void push(int a[],int val){
    a[top]=val;
    top++;
}
void pop(int a[]){
    top--;
}
int getTop(int a[]){
    return a[top-1];
}
//链表长度
int length(struct ListNode *L){
    struct ListNode *p=L;
    int len=0;
    while (p->next!=NULL){
        p=p->next;
        len++;
    }
    return len;
}

//生成一个链表，用来做测试用,n是你要填入的数据个数
struct ListNode* produceList(int n){
    struct ListNode *s=(struct ListNode *)malloc(sizeof(struct ListNode));
    struct ListNode *first=s;
    FILE *fp=fopen("test.txt", "r");//文件放在exe文件所在的目录下
    for (int i = 0; i < n; ++i) {
        struct ListNode *SNext=(struct ListNode *)malloc(sizeof(struct ListNode));
        s->next=SNext;
        s=SNext;
        fscanf(fp,"%d",&SNext->val);
    }
    s->next=NULL;
    return first->next;//返回了一个不带头链表
}
struct ListNode* produceList2(int n){
    struct ListNode *s=(struct ListNode *)malloc(sizeof(struct ListNode));
    struct ListNode *first=s;
    FILE *fp=fopen("test1.txt", "r");//文件放在exe文件所在的目录下
    for (int i = 0; i < n; ++i) {
        struct ListNode *SNext=(struct ListNode *)malloc(sizeof(struct ListNode));
        s->next=SNext;
        s=SNext;
        fscanf(fp,"%d",&SNext->val);
    }
    s->next=NULL;
    return first->next;//返回了一个不带头链表
}
struct ListNode* produceList_withHead(int n){
    struct ListNode *s=(struct ListNode *)malloc(sizeof(struct ListNode));
    struct ListNode *first=s;
    FILE *fp=fopen("test.txt", "r");//文件放在exe文件所在的目录下
    for (int i = 0; i < n; ++i) {
        struct ListNode *SNext=(struct ListNode *)malloc(sizeof(struct ListNode));
        s->next=SNext;
        s=SNext;
        fscanf(fp,"%d",&SNext->val);
    }
    s->next=NULL;
    return first;//返回了一个带头链表
}
void delete_x_withoutHead(struct ListNode *Node){

}
/*2*///单指针就够了，注意连续都是9的情况，删除节点后指针不能马上后移，这样有可能会导致跳过符合条件的元素
void delete_x_withHead(struct ListNode *Head){
    struct ListNode *p;
    struct ListNode *scan_pointer=Head;//扫描指针
    while (scan_pointer->next!=NULL){
        if (scan_pointer->next->val==9){
            p=scan_pointer->next;
            scan_pointer->next=p->next;
            free(p);
        } else//删除节点后指针不能马上后移，这样有可能会导致跳过符合条件的元素（连续是9的情况下就会跳过）
        scan_pointer=scan_pointer->next;
    }

}

/*3*/
//逆置链表，头插法逆置
void reverse(struct ListNode *Head){
//    struct ListNode *NewHead=(struct ListNode *)malloc(sizeof(struct ListNode));
    struct ListNode *p=Head->next;//扫描指针
    Head->next=NULL;//初始化它的next为null
    while (p!=NULL){
        struct ListNode *s=(struct ListNode *)malloc(sizeof(struct ListNode));//不能直接操作p，采取的方法是把p复制一份，s是放进去的块
        *s=*p;
        s->next=Head->next;
        Head->next=s;
        p=p->next;
    }
}
//原地逆置无头链表
//由于要改变头结点，也就是要改变头结点的指针，因此需要传入头结点指针的地址
void reverse_withoutHead(struct ListNode **L){
    struct ListNode *p=*L,*Head=(struct ListNode *)malloc(sizeof(struct ListNode)),*temp;
    Head->next=NULL;//初始化它的next为null
    while (p!=NULL){
        temp=p;
        p=p->next;
        temp->next=Head->next;
        Head->next=temp;
    }
    *L=Head->next;
}

//栈
void stack(struct ListNode *Head){
    int a[10];
    struct ListNode *p=Head->next;//扫描指针
    while (p!=NULL){
        push(a,p->val);
        p=p->next;
    }
    while (top!=0){
        printf("%d",getTop(a));
        pop(a);
    }
}
//递归
void R_print(struct ListNode *Node){
    if (Node==NULL)
        return;
    R_print(Node->next);
    printf("%d",Node->val);
}

/*6*/
void subject_6(struct ListNode *Head){
    struct ListNode *p=Head->next;//扫描指针
    while (p->next!=NULL){
        struct ListNode *s=Head->next;//用于比较大小的扫描指针
        struct ListNode *temp;//暂存
        if (p->val > p->next->val){
            temp=p->next;
            p->next=p->next->next;//删除节点p->next
            while (s!=p){
                if (s->val < temp->val && s->next->val > temp->val){//找到插入位置
                    temp->next=s->next;
                    s->next=temp;
                    break;
                }
                s=s->next;//没有找到插入位置，后移
            }
        } else//完成一次比较并插入后，要暂留一下
        p=p->next;
    }
}

//算法不熟练，练习一遍
void subject_61(struct ListNode *Head){
    struct ListNode *p=Head->next;
    while (p->next != NULL){
        struct ListNode *s=Head->next;
        struct ListNode *temp;
        if (p->val > p->next->val){
            temp=p->next;
            p->next=p->next->next;
            while (s!=p){
                if (s->val < temp->val && s->next->val >temp->val){
                    temp->next=s->next;
                    s->next=temp;
                    break;
                }
                s=s->next;
            }
        } else
            p=p->next;
    }
}

//空间换时间策略，快速排序
void quickSort(struct ListNode *Head){

}
/*8*///逻辑检查，算法单步调试
struct ListNode * search_common(struct ListNode *L1,struct ListNode *L2){
    int len1=length(L1),len2=length(L2);
    struct ListNode *p1=L1,*p2=L2;
    if (len1<len2){
        int dist=len2-len1;
        for (int i = 0; i < dist; ++i) {
            p2=p2->next;
        }
        while (p1!=p2){
            p1=p1->next;
            p2=p2->next;
        }
        return p1;
    } else{
        int dist=len1-len2;
        for (int i = 0; i < dist; ++i) {
            p1=p1->next;
        }
        while (p1!=p2){
            p1=p1->next;
            p2=p2->next;
        }
        return p2;

    }
}
/*13*/
void Union(struct ListNode *L1,struct ListNode *L2){
    //和归并排序一样，有三个指针
    struct ListNode *p1=L1,*p2=L2;
    struct ListNode *Head,*p3;
    if (p1->val < p2->val){
        Head=p1;
        p1=p1->next;
    } else{
        Head=p2;
        p2=p2->next;
    }
    p3=Head;
    while (p1!=NULL && p2!=NULL){
        if (p1->val < p2->val){
            p3->next=p1;
            p1=p1->next;
        } else{
            p3->next=p2;
            p2=p2->next;
        }
        p3=p3->next;
    }
    if (p1==NULL){
        p3->next=p2;
    } else{
        p3->next=p1;
    }
}
/*14*/
struct ListNode * get_common(struct ListNode *L1,struct ListNode *L2){
    struct ListNode *p1=L1,*p2=L2;
    struct ListNode *p3=(struct ListNode *)malloc(sizeof(struct ListNode)),*Head=p3;
    while (p1!=NULL && p2!=NULL){
        if (p1->val < p2->val){
            p1=p1->next;
        } else if (p1->val > p2->val){
            p2=p2->next;
        } else{
            struct ListNode *s=(struct ListNode *)malloc(sizeof(struct ListNode));
            s->val=p1->val;
            p3->next=s;
            p1=p1->next;
            p2=p2->next;
            p3=p3->next;
        }
    }
    return Head;
}
/*16*///判断L2是不是子串
//朴素匹配模式
bool pattern(struct ListNode *L1,struct ListNode *L2){
    struct ListNode *p1=L1,*p2=L2;
    while (p2!=NULL && p1!=NULL){
        if(p1->val==p2->val){
            p1=p1->next;
            p2=p2->next;
        } else{
            p2=L2;
            p1=p1->next;
        }
    }
    if (p1==NULL)
        return false;
    else
        return true;

}
/*21*///创新的使用了两个指针在同一链表上扫描
int get_k(struct ListNode *L){
    struct ListNode *p=L,*p_k=NULL;
    int k=3;
    for (int i = 0; i < 3; ++i) {
        p=p->next;
    }
    p_k=L;
    while (p!=NULL){
        p=p->next;
        p_k=p_k->next;
    }
    if (p_k==NULL)
        return 0;
    else {
        printf("%d",p_k->val);
        return 1;
    }
}
/*25*/
void changeList(struct ListNode *L,int n){
    struct ListNode *p=L;//扫描指针，用于分割链表
    for (int i = 0; i < n/2; ++i) {
        p=p->next;
    }
    struct ListNode *newHead;//新的链表头
    if (n%2==0)
        newHead=p;
    else
        newHead=p->next;
    struct ListNode *s=(struct ListNode *)malloc(sizeof(struct ListNode));
    reverse_withoutHead(&newHead);
    struct ListNode *p1=L,*p2=newHead,*temp;//链表1指针，链表2指针，暂存变量
    for (int i = 0; i < n/2; i++) {
            temp=p2;//暂存p2指针
            p2=p2->next;//移动p2指针
            //插入p2
            temp->next=p1->next;
            p1->next=temp;
            p1=p1->next->next;//移动p1指针
    }
}
/*63页思考题*/
//先用基数排序
int get_elem(int n,int pos){//这个函数用来得到第几位数，如n=539，pos=2，返回5
    int a[3];
    a[0]=n%100;
    a[1]=(n%10)/10;
    a[2]=n/100;
    return a[n];
}

void twoSum(int a[],int len){
    //直接利用链表结构体
    struct ListNode b[10];
    for (int k = 0; k < 3; ++k) {
        for (int i = 0; i < len; ++i) {
            b[get_elem(a[i],k)].next->val=get_elem(a[i],k);
        }
    }

}
int main(){
    struct ListNode *firstNode=produceList(6);
    struct ListNode *head=produceList_withHead(6);
    //创建一个交叉链表
    struct ListNode *head1=produceList_withHead(8);
    struct ListNode *s=head->next;
    struct ListNode *p=head1->next;
    for (int i = 0; i < 4; ++i) {
       p=p->next;
    }
    for (int i = 0; i < 2; ++i) {
        s=s->next;
    }
    p->next=s;
    search_common(head1,head);
    //创建两个无头链表
    struct ListNode *L1=produceList(6);
    struct ListNode *L2=produceList2(3);
    struct ListNode *L3=get_common(L1,L2);
    changeList(L1,6);
    int a[20]={7,20,13,19,14,20,27,22,20,40,998,653,45,13,654,216,77,112,336,444};

    return 0;
}

 

qq_32113889
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
双向链表和单向链表的原地逆置(反向) 头插法 C语言
桑秋斯的博客
03-22 857
双向链表 和 单向链表的原地逆置(反向) 使用头插法 C语言
链表逆置+算法+详解介绍
09-17
链表逆置是计算机科学中一个重要的算法问题，它涉及到链表数据结构的操作和算法设计。在本文中，我们将详细讨论链表逆置的背景、原理、不同方法以及实际应用。 链表是一种常见的数据结构，用于存储一系列元素，其中...
单链表反转（逆置）——（四种方法实现）
热门推荐
m0_58397166的博客
04-19 6万+
链表逆置就是把最后以一个提到坐前面，倒数第二个放到第二个……直到第一个到最后一个。 由于链表没有下标，所以不能借助下表来实行数据的逆置，要靠空间的转移来完成链表的逆置 这里采用没有头节点的链表来实现逆置。 第一种——头插法 算法思想：逆置链表初始为空，表中节点从原链表中依次“删除”，再逐个插入逆置链表的表头（即“头插”到逆置链表中），使它成为逆置链表的“新”的第一个结点，如此循环，直至原链表为空。 #include <stdio.h> #include <stdli...
链表逆置的两种方法
lxylxylxy的博客
12-03 7636
头插法逆置和三指针原地反转
链表逆置(三种方法详解)
Achievek的博客
03-23 2万+
@Achievk 6-1 单链表逆转 （20 point(s)) 本题要求实现一个函数，将给定的单链表逆转。 ##函数接口定义： List Reverse( List L ); 其中List结构定义如下： typedef struct Node PtrToNode; struct Node { ElementType Data; / 存储结点数据 / PtrToNode Next; / 指向下...
链表逆置详细讲解（图文）
qq_51366188的博客
02-26 3万+
链表逆置   前言 链表逆置是初学时有困扰到我的难点. 由于链表头结点可放可不放数据，所以写代码时候**->next**用的云里雾里。 这里讲解头结点与第一结点区分的情况，即头结点你把它看作这个 链表的“文件名” 就行。 若头结点为L，则第一结点为L->next。   代码 void listReverse(linkedList &L) { node *p,*s; //1. p = L->next; L->next = NULL; while
链表逆置的三种方法
m0_63852285的博客
11-21 3730
三指针法 思路： 先定义三个指针q,p,r。p=head->next,q保存后继点。 将第一个结点变为尾节点。p->next = NULL; 使用while循环，条件为q（即q！=NULL）。 r = q; q = r->next; //保存后继点 r->next = p; //改变指针指向 p = r; //指针后移 连接头节点。head=r。 代码： void Reverse(LinkList head) { Node *p, *q, *r=NULL; p =
链表就地逆置
qq_41027398的博客
12-30 1919
文章目录带头结点链表就地逆置不带头结点链表就地逆置 带头结点链表就地逆置 基本思想： 将原链表分离为两个链表，一个head后带一个结点p，一个q带剩余结点 将q所在链表的每一个结点依次插入到head之后即可完成就地逆置 关键代码： LinkList reverse(LinkList &head){//带头结点链表就地逆置 if(head==NULL){//空链表直接返回 return NULL; } LinkList p, q, l; p = head->next;//将链表分
链表逆置三种方法总结（C）
Master_YD的博客
12-14 833
1.通过建立一个新链表实现 struct ListNode *reverse(struct ListNode *head) { struct ListNode *head1=NULL,*p=NULL; while(head) { p=(struct ListNode*)malloc(sizeof(struct ListNode));//申请内存 p->data=head->data; p->next=head1; //利用
双向链表逆置 c语言,【总结】逆置双向链表的三种方法
weixin_35861265的博客
05-22 1059
双向链表的遍历要比单向链表方便很多，所以逆置方法要比单链表丰富很多，因为可以从后向前遍历，所以可以像逆置数组一样进行操作，也可以根据单链表的特性进行逆置，也可以用双链表独有的特性进行逆置。具体方法如下：链表的类定义如下：typedefintDataType;classDSNode{public:friendclassDNSList;DSNode(DataTypex=0):_data(x...
链表的逆置
10-18
链表的逆置，完全由自己完成的，算法自我感觉还不错，十分简洁。自我实现的算法，挺开心。
C 语言链表逆置，递归算法.pdf
最新发布
11-13
部分逆置 pta c语言
顺序表 链表 双链表的增删查改操作及链表逆置等常用线性表算法.zip
08-16
代码主要实现了顺序表 链表 双链表的增删查改操作及链表逆置等常用线性表算法
逆置数组实现和链表实现（C语言实现） 数组和链表.pdf
04-18
“逆置数组实现和链表实现（C语言实现）” 本资源主要讲解了数组和链表的逆置操作的C语言实现，包括数组逆置和链表逆置两部分。下面是对该资源的详细知识点解释： 一、数组逆置 数组逆置是将数组中的元素按照逆序...
云台调节
qq_32113889的博客
11-20 965
云台调试 云台imu姿态解算 imu里面有acc和gyro，读取数据并通过开源算法得到姿态。经过滤波处理得到需要的姿态信息。姿态信息用于pid的反馈与测算 串级pid 串级pid调参顺序，内环，p，d。外环，p，d。 pid的正弦响应 ```mermaid graph TD; A-->B; B-->C; ...
Git学习笔记
qq_32113889的博客
11-15 801
Git学习笔记 关于maven Maven是一个共享包软件,通过mvn命令可以建立不同的maven风格的项目,通常idea上面有模板 关于Git 诞生于Linux版本控制 Git是一个分布式版本管理系统,一个项目的每个开发者的电脑上都有个完整的版本库 git开始步骤 进入项目文件夹,git init创建空仓库,目录下增加了一个.git文件 Git add *(文件名),把文件添加到仓库 git commit -m “备注” git命令 Git status查看被.
二叉树的顺序存储，链式存储，先，中，后，层序遍历。链队列
qq_32113889的博客
07-25 585
#include <stdio.h> #include <stdbool.h> #include <stdlib.h> #define MaxSize 100 typedef struct { int id; }ElemType; /*以下为顺序存储二叉树，由于只有当树为完全二叉树的时候，树的结点和数组下标有关系 * 但当不是完全二叉树的时候，就要花费大量的空间去存储空值，造成了大量的内存浪费 * 因此一般不用顺序存储*/ struct Tree{ .
顺序队列
qq_32113889的博客
07-20 448
#include <stdio.h> #include <stdbool.h> #include <stdlib.h> #define MaxSize 10 typedef struct { char name[20]; }ElemType; typedef struct { ElemType data[MaxSize]; int front,rear; // int size; 这种方法可以不浪费那个多出来的空间，不过却多了一.
jetbrain系的快捷键用法
qq_32113889的博客
07-22 360
/* ctrl+shift+/ * * 快捷键 * ctrl+r replace * ctrl+y delete * ctrl+p 函数参数提示 * ctrl+d 复制到下一行 * ctrl+w * ctrl+b 进入定义处 * ctrl+j 自定义模板 * ctrl+- 折叠代码 * ctrl+[ 移动到花括号开始的位置 * ctrl+f1 显示错误信息 * ctrl+f4 下班 * ctrl+delete 删除后面中文句或单词 backspace反之 * ctrl+左方向.
编写算法逆置一个带头结点的双链表，编写双链表的创建和输出算法
03-31
逆置双链表算法： 1. 如果链表为空或只有一个结点，则无需逆置，直接返回原链表头节点； 2. 否则，从头结点的下一个节点开始，依次将每个节点的前驱和后继交换，直到交换到尾结点； 3. 交换完毕后，将原链表的头...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值