链表头插法尾插法，反转单链表，C代码

已于 2022-05-19 17:21:00 修改
阅读量649 收藏 6
点赞数 2
分类专栏： C语言 文章标签： 链表 c语言 list
于 2022-05-19 10:09:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45079974/article/details/124857409
版权
本文介绍了链表的基本操作，包括头插法创建链表、尾插法创建链表，以及链表的遍历、长度计算、元素计数、翻转、插入、删除、去重、查找和合并。通过实例展示了如何在C语言中实现这些功能，并探讨了相关算法的应用和优化。
摘要由CSDN通过智能技术生成 
#include <stdio.h>
#include <stdlib.h>

typedef struct node{
    int data;
    struct node *next;
}lnode;

// 头插法创建链表
lnode* createHead(){
    lnode *head,*p,*q;
    head=p=(lnode *)malloc(sizeof(lnode));
    p->next=NULL;
    for (int i = 0; i < 10; i++) {
        q=(lnode *)malloc(sizeof(lnode));
        q->data=i;
        q->next=p->next;
        p->next=q;
    }
    return head;
}


// 尾插法创建链表
lnode* createTail(){
    lnode *head,*p,*q;
    head=p=(lnode *)malloc(sizeof(lnode));
    for (int i = 0; i < 10; i++) {
        q=(lnode *)malloc(sizeof(lnode));
        q->data=i;
        q->next=NULL;
        p->next=q;
        p=q;
    }
    return head; //head是头
}


//遍历链表
void print(lnode *list){
    lnode *p=list->next;
    while(p!=NULL){
        printf("%d\n",p->data);
        p=p->next;
    }
}
int main()
{
    lnode *list;
    list=createTail();//创建一个单链表，尾插法
    print(list);
    return 0;
}

定义结构体

//typedef 给struct node 起了个名字叫 lnode
// lnoe qw 等价于 struct node
typedef struct node{
    int data; //存放数据域
    struct node *next;//存放指针域
}lnode;

头插法(插入是逆序)

// 头插法创建链表
lnode* createHead(){
	//定义了三个指针类型的lnode head是头指针
    lnode *head,*p,*q;
    head=p=(lnode *)malloc(sizeof(lnode));
    p->next=NULL;
    for (int i = 0; i < 10; i++) {
        q=(lnode *)malloc(sizeof(lnode));
        q->data=i;
        q->next=p->next;
        p->next=q;
    }
    return head;
}

尾插法（插入是正序）


// 尾插法创建链表
lnode* createTail(){
    lnode *head,*p,*q;
    head=p=(lnode *)malloc(sizeof(lnode));
    for (int i = 0; i < 10; i++) {
        q=(lnode *)malloc(sizeof(lnode));
        q->data=i;
        q->next=NULL;
        p->next=q;
        p=q;
    }
    return head; //head是头
}

遍历链表

//遍历链表
void print(lnode *list){
    lnode *p=list->next;
    while(p!=NULL){
        printf("%d\n",p->data);
        p=p->next;
    }
}

计算单链表长

int listlen(lnode *list){
    lnode *p=list->next;
    int len =0;
    while(p!=NULL){
        len++;
        p=p->next;
    }
    return len;
}

统计链表中 x出现的次数

int  count_x_in_list(lnode *list,int x){
    lnode *p=list->next;
    int count=0;
    while(p!=NULL){
        if(p->data==x)
            count++;
        p=p->next;
    }
    return count;
}

翻转链表思路1

将原先链表遍历一遍，放到数组中，然后使用头插法，将这个数组构建成单链表
1.遍历原先链表，数据放到数组中

//翻转链表 1,2,3,4,5 变成 5,4,3,2,1
lnode* fan(lnode *list){
    lnode *test,*p=list->next;
    int a[1000];
    int i=0;
    while(p!=NULL){
        a[i++]=p->data;
        p=p->next;
    }
    test=headcr(a,i);
    return test;
}

2.使用头插法，根据数据构建一个新的链表

//头插法建立,根据数组建立单链表
lnode* headcr(int a[],int len){
    lnode *head,*p,*q;
    head=p=(lnode *)malloc(sizeof(lnode));
    p->next=NULL;
    for (int i = 0; i < len; i++) {
        q=(lnode *) malloc(sizeof(lnode));
        q->data=i;
        q->next=p->next;
        p->next=q;
    }
    return head;
}

翻转链表思路2 新建两个指针一前一后 逐个断链再链接

// 翻转链表
lnode* reverse(lnode *list){
    // p是当前 ,prev是前一个 ,next是后一个
    lnode *p,*prev,*next;
    prev=NULL;
    p=list->next;
    while(p){
        next=p->next;
        p->next=prev;
        prev=p;
        p=next;
    }
    return prev;
}

链表的插入

// 链表的插入
void insert(lnode *list,int i,int e){
    lnode *p,*q;
    int j=0;
    p=list;
    while(p!=NULL && j<i-1){
        j++;
        p=p->next;
    }
    q=(lnode *)malloc(sizeof(lnode));
    q->data=e;
    q->next=p->next;
    p->next=q;
}

链表的按序号删除

//链表的删除按序号删除
void delete1(lnode *list,int i){
    lnode *p,*q;
    p=list;
    int j=0;
    while(p && j<i-1){
        j++;
        p=p->next;
    }
    q=p->next;
    p->next=q->next;
    free(q);
}

删除第一个元素

void delete2(lnode *list,int key){
    lnode *p,*q;
    p=list;
    q=list->next;
    while(p && q){
        if(q->data==key){
            p->next=q->next;
            free(q);
            break;
        }
        p=p->next;
        q=q->next;
    }
    
}

删除表中所有值为x的

//删除单链表中所有值为key的结点
void delete3(lnode *list,int key){
    lnode *p,*q;
    p=list;
    q=p->next;
    while(p && q){
        if(q->data==key){
            p->next=q->next;
            free(q);
            q=p->next;
        }
        p=p->next;
        q=q->next;
    }
}

单链表去重

//单链表去重
void divsum(lnode *list){
    lnode *p;
    p=list->next;
    while(p){
        delete3(p,p->data);
        p=p->next;
    }
}

链表查找算法

//查找算法 查找第i个位置上的(按位查找)
void find(lnode *list,int i){
    lnode *p;
    p=list;
    int j=0;
    while(p && j<i){
        j++;
        p=p->next;
    }
    if(j==i)
        printf("查找成功 :%d",p->data);
    else
        printf("查找失败");
}

//按值查找 找给给指定相等的第一个节点
void findfirst(lnode *list,int key){
    lnode *p;
    p=list;
    int i=0;
    while(p){
        if(p->data==key){
              printf("查找成功 %d",i);
              break;
        }
        p=p->next;
        i++;
    }
    if(p==NULL)
        printf("查找失败");
}

合并单链表

//合并两个有序单链表 {1,3,5,7,9} {2,4,6,7,8,10}
//第一步后  先按照顺序插入到链表位置 {1,2,3,4,5,6,7,7,8,9}
//第二部 将剩余结点插入到pc链表中  {1,2,3,4,5,6,7,7,8,9,10}
//第三步 单链表去重 {1,2,3,4,5,6,7,8,9,10}
lnode* mergelinkList(lnode *la,lnode *lb){

    lnode *pa=la->next,*pb=lb->next;
    lnode *pc,*p,*q;
    pc=p=(lnode *)malloc(sizeof(lnode));
    p->next=NULL;
    printf("\n");
    // 先按照顺序插入到链表位置
    while(pa!=NULL && pb!=NULL){
        if(pa->data > pb->data)
        {
            q=(lnode *)malloc(sizeof(lnode));
            q->data=pb->data;
            q->next=NULL;
            p->next=q;
            p=q;
            
            pb=pb->next;
        }
        if(pa->data <= pb->data)
        {
            q=(lnode *)malloc(sizeof(lnode));
            q->data=pa->data;
            q->next=NULL;
            p->next=q;
            p=q;
            
            pa=pa->next;
        }

    }
    //将剩余结点插入到pc链表中
    if(pa!=NULL)
        p->next=pa;
    else
        p->next=pb;
        
        
    //单链表去重
    divsum(pc);
    return pc;
}

总体

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

//结构体
typedef struct node{
    int data;
    struct node *next;
}lnode;

// 头插法创建链表
lnode* createHead(){
    lnode *head,*p,*q;
    head=p=(lnode *)malloc(sizeof(lnode));
    p->next=NULL;
    for (int i = 0; i < 10; i++) {
        q=(lnode *)malloc(sizeof(lnode));
        q->data=i;
        q->next=p->next;
        p->next=q;
    }
    return head;
}

// 尾插法创建链表
lnode* createTail(){
    lnode *head,*p,*q;
    head=p=(lnode *)malloc(sizeof(lnode));
    for (int i = 0; i < 10; i++) {
        q=(lnode *)malloc(sizeof(lnode));
        q->data=i;
        q->next=NULL;
        p->next=q;
        p=q;
    }
    return head; //head是头
}

//遍历链表（带头结点）
void print(lnode *list){
    lnode *p=list->next;
    while(p!=NULL){
        printf("%d  ",p->data);
        p=p->next;
    }
}

//遍历链表（不带头结点）
void print1(lnode *list){
    lnode *p=list;
    while(p!=NULL){
        printf("%d  ",p->data);
        p=p->next;
    }
}

// 计算链表长度
int listlen(lnode *list){
    lnode *p=list->next;
    int len =0;
    while(p!=NULL){
        len++;
        p=p->next;
    }
    return len;
}

//计算单链表中出现x的次数
int  count_x_in_list(lnode *list,int x){
    lnode *p=list->next;
    int count=0;
    while(p!=NULL){
        if(p->data==x)
            count++;
        p=p->next;
    }
    return count;
}

//头插法建立,根据数组建立单链表
lnode* headcr(int a[],int len){
    lnode *head,*p,*q;
    head=p=(lnode *)malloc(sizeof(lnode));
    p->next=NULL;
    for (int i = 0; i < len; i++) {
        q=(lnode *) malloc(sizeof(lnode));
        q->data=i;
        q->next=p->next;
        p->next=q;
    }
    return head;
}
//尾插法建立,根据数组建立单链表
lnode* endcr(int a[],int len){
    lnode *head,*p,*q;
    head=p=(lnode *)malloc(sizeof(lnode));
    p->next=NULL;
    for (int i = 0; i < len; i++) {
        q=(lnode *) malloc(sizeof(lnode));
        q->data=a[i];
        q->next=NULL;
        p->next=q;
        p=q;
    }
    return head;
}

//翻转链表 1,2,3,4,5 变成 5,4,3,2,1
lnode* fan(lnode *list){
    lnode *test,*p=list->next;
    int a[1000];
    int i=0;
    while(p!=NULL){
        a[i++]=p->data;
        p=p->next;
    }
    test=headcr(a,i);
    return test;
}
// 翻转链表
lnode* reverse(lnode *list){
    // p是当前 ,prev是前一个 ,next是后一个
    lnode *p,*prev,*next;
    prev=NULL;
    p=list->next;
    while(p){
        next=p->next;
        p->next=prev;
        prev=p;
        p=next;
    }
    return prev;
}
// 链表的插入
void insert(lnode *list,int i,int e){
    lnode *p,*q;
    int j=0;
    p=list;
    while(p!=NULL && j<i-1){
        j++;
        p=p->next;
    }
    q=(lnode *)malloc(sizeof(lnode));
    q->data=e;
    q->next=p->next;
    p->next=q;
}
//链表的删除按序号删除
void delete1(lnode *list,int i){
    lnode *p,*q;
    p=list;
    int j=0;
    while(p && j<i-1){
        j++;
        p=p->next;
    }
    q=p->next;
    p->next=q->next;
    free(q);
}

//删除单链表中值为key的第一个数字
void delete2(lnode *list,int key){
    lnode *p,*q;
    p=list;
    q=list->next;
    while(p && q){
        if(q->data==key){
            p->next=q->next;
            free(q);
            break;
        }
        p=p->next;
        q=q->next;
    }
    
}
//删除单链表中所有值为key的结点
void delete3(lnode *list,int key){
    lnode *p,*q;
    p=list;
    q=p->next;
    while(p && q){
        if(q->data==key){
            p->next=q->next;
            free(q);
            q=p->next;
        }
        p=p->next;
        q=q->next;
    }
}

//单链表去重
void divsum(lnode *list){
    lnode *p;
    p=list->next;
    while(p){
        delete3(p,p->data);
        p=p->next;
    }
}

//查找算法 查找第i个位置上的(按位查找)
void find(lnode *list,int i){
    lnode *p;
    p=list;
    int j=0;
    while(p && j<i){
        j++;
        p=p->next;
    }
    if(j==i)
        printf("查找成功 :%d",p->data);
    else
        printf("查找失败");
}
//按值查找 找给给指定相等的第一个节点
void findfirst(lnode *list,int key){
    lnode *p;
    p=list;
    int i=0;
    while(p){
        if(p->data==key){
              printf("查找成功 %d",i);
              break;
        }
        p=p->next;
        i++;
    }
    if(p==NULL)
        printf("查找失败");
}
//合并两个有序单链表 {1,3,5,7,9} {2,4,6,7,8,10}
//第一步后  先按照顺序插入到链表位置 {1,2,3,4,5,6,7,7,8,9}
//第二部 将剩余结点插入到pc链表中  {1,2,3,4,5,6,7,7,8,9,10}
//第三步 单链表去重 {1,2,3,4,5,6,7,8,9,10}
lnode* mergelinkList(lnode *la,lnode *lb){

    lnode *pa=la->next,*pb=lb->next;
    lnode *pc,*p,*q;
    pc=p=(lnode *)malloc(sizeof(lnode));
    p->next=NULL;
    printf("\n");
    // 先按照顺序插入到链表位置
    while(pa!=NULL && pb!=NULL){
        if(pa->data > pb->data)
        {
            q=(lnode *)malloc(sizeof(lnode));
            q->data=pb->data;
            q->next=NULL;
            p->next=q;
            p=q;
            
            pb=pb->next;
        }
        if(pa->data <= pb->data)
        {
            q=(lnode *)malloc(sizeof(lnode));
            q->data=pa->data;
            q->next=NULL;
            p->next=q;
            p=q;
            
            pa=pa->next;
        }

    }
    //将剩余结点插入到pc链表中
    if(pa!=NULL)
        p->next=pa;
    else
        p->next=pb;
        
        
    //单链表去重
    divsum(pc);
    return pc;
}



int main()
{
    // lnode *list;    
    // list=createTail();//创建一个单链表，尾插法
    // print(list);    //打印单链表
    // printf("\n");
    // int len=listlen(list);//计算单链表长度
    // printf("单链表长度:%d\n",len);
    // int countx=count_x_in_list(list,5);
    // printf("x 在链表中出现的次数%d\n",countx);
    
    //翻转链表
    // lnode* newlist= reverse(list);
    // print1(newlist);
    
    //在链表的第2个位置插入99
    // print(list);
    // printf("\n");
    
    
    //删除第2个结点
    // delete1(list,2);
    // print(list);
    
    // 删除元素2
    // delete2(list,99);
    
    //单链表去重
    // divsum(list);
    // print(list);
    
    //查找操作
    // find(list,4);
    // findfirst(list,8);
    
    //合并两个有序单链表
    //先创建两个
    int arr[]={1,3,5,7,9};
    int brr[]={2,4,6,7,8,10};
    lnode *la,*lb,*lc;
    
    la=endcr(arr,5);
    lb=endcr(brr,6);
    print(la);
    printf("\n");
    print(lb);
    
    lc=mergelinkList(la,lb);
    printf("\n");
    print(lc);
    return 0;
}
黑白子2000
关注
专栏目录
206. 反转链表（206.1尾插法建立链表）
weixin_45784564的博客
12-06 352
#include<stdio.h> #include<stdlib.h> #include<iostream> #pragma warning(disable:4996) using namespace std; struct ListNode { int val; struct ListNode* next; }; void List_TailInsert(ListNode** head)//尾插法建立带有头节点的链表 { *head = (L
单链表算法(增删改查、头插法、尾插法、单链表逆置、求倒数第k个节点值、找中间节点、删除单链表中最大值节点、分割单链表）、)
06-25 909
单链表简介： 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 代码： #include <stdio.h> #include "stdlib.h" typedef int ElemType; typedef struct Node { ElemType data; stru
单链表建立头插法(C语言源代码)
09-17
有错误和更好的建议请指出,大家一起学习!!
头插法带头结点建立单链表
m0_62846132的博客
08-19 142
printf("请输入你要插入的结点值:");printf("请输入你要插入的结点个数:");不啰嗦，以下是我的代码，比较适合新手吧。//带头结点的头插法。
头插法和尾插法（用c语言实现）
正在学算法的小朋友的博客
09-12 921
相关代码: #include<stdio.h> #include<stdlib.h> typedef struct Node { int data; struct Node *next; }Node; //头插法建立链表 带有head头结点的情况。 Node *create1(int n){ Node *head ,*s; int i; head=(Node *)malloc(sizeof(Node)); //head节点申请了一个内存空间。 h..
链表尾插法
11-18
尾插法的简单例子，
C语言创建单链表（头尾插法） 详细分析附源码
喜欢数学建模的大一小白
11-14 1223
C语言创建单链表 头插法 尾插法
Java数据结构之链表——头插法逆置单链表
weixin_45700507的博客
04-25 723
单链表的就地逆置是指辅助空间O(1)的逆置方法，使用头插法。 定义单链表的基本操作 package Link; class Node{ // 定义单链表借点类 public int value; // 该结点所保存的值 public Node next; // da该结点下一个结点指针 public Node(int data){ value = data; next = null; } public Node(){.
单链表操作 头插入 尾插入 链表反转
laymenISmouse的专栏
02-01 525
// TTest.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include "stdafx.h" #include "iostream" #include #include using namespace std; typedef struct LNode { int data; struct LNode *next; } L
不带头结点的单链表反转 三种不同方法实现
漂客的博客
02-26 2594
typedef struct LinkList{ struct LinkList *next; int data; }LinkList; //头插法创建单链表 不带头结点(1+1 指针数，1个保存头结点+1个遍历指针) LinkList *creatLinkList(int n) {//创建一个含n个元素的单链表 LinkList *head = (LinkList *)...
反转单链表总结 多种方法图解
Janway-Win
05-02 412
要求反转一个单链表，例如： 输入：1->2->3->4->5->NULL 输出：5->4->3->2->1->NULL 方法一、双指针 ● 定义两个指针：pre和cur，pre在前面，cur在后面。 ● 每次让pre的next指向cur，实现一次局部反转。 ● 局部反转完成之后，pre和cur同时往前移动一个位置。 ● 循环上述过程，直至...
单链表尾插法(C++源代码)
10-31
单链表尾插法(C++源代码)单链表尾插法(C++源代码)单链表尾插法(C++源代码)单链表尾插法(C++源代码)单链表尾插法(C++源代码)单链表尾插法(C++源代码)单链表尾插法(C++源代码)单链表尾插法(C++源代码)单链表尾插法(C++源代码)单链表尾插法(C++源代码)单链表尾插法(C++源代码)单链表尾插法(C++源代码)单链表尾插法(C++源代码)单链表尾插法(C++源代码)单链表尾插法(C++源代码)单链表尾插法(C++源代码)
单链表的头插与尾插完整c语言代码的实现
qq_43750336的博客
09-19 834
**单链表的头插法与尾插法** 初学数据结构，学了半天才敲出的完整c语言，特此写一篇博客来纪念一下。 下面是代码部分： #include <stdio.h> #include <stdlib.h> typedef int ElemType; typedef struct LNode { ElemType data; str...
翻转链表II[翻转链表3种方式+dummyHead/头插法/尾插法]
qq_43164662的博客
06-30 504
翻转链表有两个角度，三种方式。第一角度，从原链表上将链翻转，或叫指向前一个记录的节点，可递归，可循环。第二角度，完成不用在原链表上费力，采用dummyHead统一空链表/第一节点操作，将需要的节点以头插法(翻转)/尾插法(找符合要求的节点)将节点链接到其后。...
尾插法、头插法创建链表、链表反转、链表分段反转、查找链表倒数第k个元素，查找链表中间元素
鬼魅叔叔的小窝
10-20 1107
#include #include #include #include using namespace std; typedef struct node{ struct node *next; char value; }mynode; /********************************************/ //尾插法创建列表 /********
C语言单链表---尾插法
XYHEZ的博客
10-30 469
/插入节点---尾插法。
链表的尾插法（郝斌老师数据结构链表代码分析）
w_cjmla的博客
02-01 688
前言 今天学习到数据结构里的尾插法(郝斌老师的数据结构)，发现很多初学者对于视频所讲的尾插法的代码有些疑惑(尽管我也是个小白)，下面我们来对其分析一下 下附代码 二、代码示例 这里我把老师在课堂上讲的代码搬过来 没看过视频的可以先看这个较为完整的代码 看过视频的同学可以直接跳过看下一个代码： #include <stdio.h> #include <malloc.h> #include <stdlib.h> typedef struct Node { int
链表——尾插法创建链表（代码）
weixin_64805909的博客
11-21 585
{};{{=NULL){{}}}{{}= NULL){}}{{}int main(){：}
完整代码实例-Java实现 (头插法) 反转单链表
菜菜的大数据开发の路
04-15 351
代码示例: package DataStrcture.ArrayDemo.singlelistdemo; public class SingleListReverse { public static class Node{ Node next; int num; ///构造器 public Node(int num){ this.num = num; } /.
C语言实现的头插法和尾插法建立单链表的代码
最新发布
09-30
在C语言中，我们可以使用结构体表示链表节点，并通过指针进行头插法（即在列表头部插入节点）和尾插法（在列表尾部插入节点）。以下是这两种方法的基本示例： ### 头插法 ```c #include typedef struct Node { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值