C语言学习笔记(十三) －链表 Chain

最新推荐文章于 2024-04-18 18:05:11 发布
最新推荐文章于 2024-04-18 18:05:11 发布
阅读量1.6k 收藏 2
点赞数
文章标签： 动态链表 chain 动态 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangzi11322/article/details/44338271
版权

动态申请链表

/*
 动态申请链表

 数组:静态存储，有序的数据集合，数据顺序能够映射物理地址，查找快，插入删除效率低
 链表:动态存储，插入删除效率高
 */

#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
    int i;         //保存节点的值,数值域
    struct node *p;//记录下一个节点的地址 ,指针域

} Node;

Node * createlink();
void printLink(Node *head);
void freeLink(Node **phead);
/*
 *Node* 链表首地址
 *int pos 插入新节点的位置
 *int num 新节点的值域
 *返回值: Node* 将新链表的首地址返回
 */
Node *insert(Node* ,int pos,int num);
/*
 *参数:
 *   Node** 指向链表首地址的指针变量的地址
 *   int num 要删除的值,若num和链表中的某个节点的值域相等，则删除该节点
 */
void removeNode(Node **,int num);
Node * insertAsc(Node *head,int num);
Node *createlinkSort();
int main(void)
{
    Node *head=createlink();
    //Node *head=createlinkSort();
    //按顺序打印所有链表内容
    printLink(head);

    printf("插入后的结果为:\n");
    head=insertAsc(head,5);

    //head=insert(head,8,100);
    //printf("remove：\n");
    //removeNode(&head,4);

    printLink(head);
    //freeLink(&head);
    printf("head= %p\n",head);
    //printf("node->i:%d",head->i);
    return 0;
}



//作业
Node * insertAsc(Node *head,int num)
{
    Node *new=(Node *)malloc(sizeof(Node));
    new->i=num;
    new->p=NULL;

    if (head==NULL||head->i> new->i) {   //头结点插入
        new->p=head;
        head=new;
        return head;
    }
    Node *pf,*pb;//pf是要插入的前节点，pb是要插入位置的后节点
    pf=pb=head;
    while (pb!=NULL && pb->i<new->i) {
        pf=pb;
        pb=pb->p;
    }
    if (pb==NULL) {  //尾节点插入
        pf->p=new;
    }else{
        new->p=pb;
        pf->p=new;
    }
    return head;
}
//删除节点
void removeNode(Node **phead,int num)
{
    Node *p1=*phead;
    Node *pf=*phead;
    while (pf!=NULL &&pf->i!=num) {
        p1=pf;
        pf=pf->p;
    }
    if (pf==NULL) {
        printf("链表中没有%d\n",num);
        return ;
    }
    if (pf==*phead) {
        //头节点删除
        *phead=pf->p;
    }else{
        //中间节点和尾节点的删除
        p1->p=pf->p;
    }
    free(pf);

}


//插入节点
Node *insert (Node *head,int pos,int num)
{

    if (pos==0) {   //头结点插入
        Node *newnode=(Node *)malloc(sizeof(Node));
        if (newnode==NULL){
            return head;
        }
        newnode->i=num;
        newnode->p=head;
        head=newnode;
        return head;
    }

    int i=1;
    Node *pf=head;
    while (i<pos && pf!=NULL) {
        pf=pf->p;
        i++;
    }
    if (pf==NULL) {
        printf("链表不能在%d位置中插入节点\n",pos);
    }else{
        Node *newnode=(Node *)malloc(sizeof(Node));
        if (newnode==NULL){
            return head;
        }
        newnode->i=num;
        newnode->p=NULL;

        if (pf->p==NULL) {  //尾节点插入
            pf->p=newnode;
        }else{     //中间节点插入
            newnode->p=pf->p;
            pf->p=newnode;
        }
    }
    return head;
}

//释放链表
void freeLink(Node **phead)
{
    Node *pf=NULL; //删除节点的前面一个节点
    Node *pb=NULL; //要删除的节点
    printf("free: ");
    while (*phead!= NULL) {
        //找到尾节点
        if ((*phead)->p== NULL) { //若链表中仅有一个节点
            printf("%d",(*phead)->i);
            free(*phead);
            *phead=NULL;
        }else{
            //链表中至少有两个以上的节点
            pf=*phead; //链表第一个节点
            pb=pf->p; //链表第二个节点
            while (pb->p !=NULL) {
                pf=pb;
                pb=pb->p;
            }
            printf("%d\n",pb->i);
            free(pb);
            pf->p=NULL;
        }
    }
    printf("\n");
}



//打印节点
void printLink(Node *head)
{
    printf("LinkNode: ");
    while (NULL!=head) {
        printf("%d ",head->i);
        head=head->p;
    }
    printf("\n");
}

//创建无序链表
Node *createlink()
{
    Node * head=NULL; //指向链表第一个节点的指针变量
    Node * end=NULL;  //指向链表最后一个节点的指针变量
    Node * newnode=NULL;//指向新申请的节点的指针变量
    while (1) { 
        newnode=(Node *)malloc(sizeof(Node));//动态申请链表,申请空间
        int num=scanf("%d",&(newnode->i));
        newnode->p=NULL;

        if (0==newnode->i) {
            break;
        }
        if (head==NULL) { //如果head＝＝NULL说明链表为空，新节点是第一个节点也是最后一个节点
            head=end=newnode;
        }else{
            end->p=newnode;//将新节点链接在链表尾部
            end =newnode;   //end指向新链表尾部
        }
        newnode=NULL;
    }
    if (newnode!=NULL) {  //回收最后一个0节点，该节点没有连入链表里
        free(newnode);
    }

    //指向创建完成的链表的首地址
    return head;
}

//创建有序链表
Node *createlinkSort()
{
    Node * head=NULL; //指向链表第一个节点的指针变量
    Node * end=NULL;  //指向链表最后一个节点的指针变量
    Node * newnode=NULL;//指向新申请的节点的指针变量
    while (1) {
        scanf("%d",&num);
        if (num==0) {
            break;
        }
        head=inse(head,i)
    }
    if (newnode!=NULL) {  //回收最后一个0节点，该节点没有连入链表里
        free(newnode);
    }

    //指向创建完成的链表的首地址
    return head;
}

创建顺序表并插入元素

 //创建顺序表并插入元素

#include <stdio.h>
#include <stdlib.h>
#define Listsize 100


struct sqlist {
    int data[Listsize];
    int len;
};

//插入元素
void InsertList(struct sqlist *l,int t,int i)
{
    int j;
    if (i<0||i>l->len) {
        printf("position error!");
        exit(1);
    }
    if (l->len>=Listsize) {
        printf("overflow");
        exit(1);
    }
    for (j=l->len-1; j>=i; i--) {
        l->data[j+1]=l->data[j];
    }
    l->data[i]=t;
    l->len++;
}


int main(void)
{
    struct sqlist *sq;
    int i,n,t;
    sq=(struct sqlist *)malloc(sizeof(struct sqlist));//分配空间
    sq->len=0;
    printf("请输入表的长度: \n");
    scanf("%d",&n);
    printf("请输入表的元素:\n");
    for (i=0; i<n; i++) {
        scanf("%d",&t);
        InsertList(sq,t,i);  //插入元素
    }

    printf("插入完成后的表为:\n");
    for (i=0; i<sq->len; i++) {
        printf("%d ",sq->data[i]);
    }
    printf("\n");
    return 0;
}

创建链表并向链表中插入新节点

/*
 创建链表并向链表中插入新节点
 */

#include <stdio.h>
#include <stdlib.h>
struct student {
    int num;
    struct student *next;
};
struct student *create(int n);
struct student *insertnode(struct student *head,char x,int i);
struct student *delnode(struct student *head,int i);

int main(void)
{
    int n,i;
    int x;
    struct student *q;  //声明节点类型的指针变量
    printf("输入要创建的节点个数:\n");
    scanf("%d",&n);
    q=create(n);       //创建链表
    printf("输入要插入的节点值:\n");
    scanf("%d",&x);
    printf("输入要插入的位置:\n");
    scanf("%d",&i);
    insertnode(q,x,i);   //插入节点
//    printf("输入要删除的位置:\n");
//    scanf("%d",&i);
//    delnode(q,i);   //删除节点


    printf("输出结果为:\n");
    while (q) {     //输出插入节点后链表
        printf("%d ",q->num);
        q=q->next;
    }
    printf("\n");
    return 0;
}


//创建链表
struct student *create(int n)
{
    int i;
    struct student *head,*p1,*p2;
    int a;
    char b;
    head =  NULL;
    printf("随机输入一段数字: \n");
    for (i=n; i>0; --i) {
        p1=(struct student *)malloc(sizeof(struct student));
        scanf("%d",&a);
        p1->num=a;
        if (head==NULL) {
            head=p1;
            p2=p1;
        }else{
            p2->next=p1;
            p2=p1;
        }
        p2->next=NULL;
    }
    return head;
}


//在链表中新插入节点
struct student *insertnode(struct student *head,char x,int i)
{
    int j=0;
    struct student *p,*s;
    p=head;
    while (p&&j<i-1) {  //找到要插入的位置
        p=p->next;
        ++j;
    }
    if (!p||j>i-1) {
        exit(1);
    }
    s=(struct student *)malloc(sizeof(struct student));//申请节点空间

    s->num=x; //为数据域赋值
    s->next=p->next;
    p->next=s;

}

//删除链表中的节点
struct student *delnode(struct student *head,int i)
{
    int j=0;
    struct student *p,*r;
    p=head;
    while (p&&j<i-1) {  //找到要删除的位置
        p=p->next;
        ++j;
    }
    if (!p||j>i-1) {
        exit(1);
    }
    r=p->next;
    p->next=r->next;   //删除节点
    free(r);
}

从链表中删除节点

/*
 从链表中删除节点
 */

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

typedef struct student
{
    int num;
    struct student *next;
}LNode, *LinkList;

struct student *create(int n);
struct student *delnode(struct student *head,int i);

int main(void)
{
    int n,i;
    int x;
    struct student *q;  //声明节点类型的指针变量
    printf("输入要创建的节点个数:\n");
    scanf("%d",&n);
    q=create(n);       //创建链表
    printf("输入要删除的位置:\n");
    scanf("%d",&i);

    delnode(q,i);   //插入节点
    printf("输出结果为:\n");
    while (q) {     //输出插入节点后链表
        printf("%d ",q->num);
        q=q->next;
    }
    printf("\n");
    return 0;
}


//创建链表
struct student *create(int n)
{
    int i;
    struct student *head,*p1,*p2;
    int a;
    char b;
    head =  NULL;
    printf("随机输入一段数字: \n");
    for (i=n; i>0; --i) {
        p1=(struct student *)malloc(sizeof(struct student));
        scanf("%d",&a);
        p1->num=a;
        if (head==NULL) {
            head=p1;
            p2=p1;
        }else{
            p2->next=p1;
            p2=p1;
        }
        p2->next=NULL;
    }
    return head;
}


struct student *delnode(struct student *head,int i)
{
    int j=0;
    struct student *p,*r;
    p=head;
    while (p&&j<i-1) {  //找到要删除的位置
        p=p->next;
        ++j;
    }
    if (!p||j>i-1) {
        exit(1);
    }
    r=p->next;
    p->next=r->next;  //删除节点
    free(r);
}
陆讯
关注
大神之路-起始篇 | 第12章.计算机科学导论之【抽象数据类型】学习笔记
WeiyiGeek 唯一极客IT知识分享
01-05 166
抽象数据类型(abstact data type, ADT) 比上一章讨论的数据结构(数组、记录、链表)处于更高抽象层的数据类型,实际上ADT也是使用数据结构来实现的。 本章将讨论各种不同的抽象数据类型，例如：栈、队列、广义线性列表、树、二叉数、二叉搜索树和图。 抽象数据类型（ADT）：是数据类的定义和应用于数据的操作定义的集合。例如，求某个列表中数字之和，则需要选择数字类型（整数或实数）以及定义运算（加法）。 换言之，ADT的用户只需要知道对数据类型可用的一组操作，而不需要知道它们是如何应用的 。
Lua源码学习笔记
dengping_ss的博客
07-02 581
介绍lua实现统一表达各种数据结构的方式，以及Table部分插入key时解决冲突和rehash的实现
链表学习笔记
庚午步雲
08-25 1933
链表虚席笔记：从尾到头遍历链表、链表中倒数第 k 个结点、合并两个排序的链表、两个链表的第一个公共结点、链表中环的入口结点、判断链表是否是回文结构、删除单向链表中指定的结点（o(1)时间）、删除链表中相邻的重复结点（保留一个）、删除链表中重复结点（保留一个）、删除链表中相邻重复结点、复杂链表的复制
c语言学习笔记（13）——链表
iteye_709的博客
08-07 136
链表算法：1.通俗定义：解题的方法和步骤2.狭义定义：对存储数据的操作 3.广义定义：广义的算法也叫泛型无论数据是如何存储的，对数据的操作都是一样的 我们至少可以通过两种结构来存储数据数组1.需要一整块连续的存储空间，内存中可能没有2.插入元素，删除元素效率极低。3.查找数据快链表1.查找效率低2.不需要一块连续的内存空间2.插入删除元素效率高 专业术语头指针存放头结点地址的指针变量头结点...
C语言链表学习笔记
wangjun_huster的博客
04-13 850
问题引入：预先无法知道数组的大小，不能分配一块连续的内存用动态存储的方法可以很好地解决这些问题。有一个学生就分配一个结点，无须预先确定学生的准确人数，某学生退学，可删去该结点，并释放该结点占用的存储空间。从而节约了宝贵的内存资源。另一方面，用数组的方法必须占用一块连续的内存区域。而使用动态分配时，每个结点之间可以是不连续的（结点内是连续的）。结点之间的联系可以用指针实现。 即在结点结构中定义一个成员
C语言——链表笔记
于书盼的博客
03-10 305
我们至少可以用两种方式存储数据 1、数组 优点：存储速度快 缺点：需要一个连续的很大的内存；插入和删除元素的效率很低。 数组每个单元只存储元素的实际值 2、链表 优点：插入删除元素的效率高；不需要一个连续大的内存 缺点：查找元素效率低 链表每个单元分两部分，左边存储实际元素值，右边存储下一个元素的指针 链表术语： 头结点：头结点的数据类型和首节点的类型一样；头结点是首节点前...
C语言学习笔记——链表
qq_39079631的博客
12-18 734
C语言学习笔记 链表 创建链表 链表是什么： 其实是多个结构体，里面存有数据和指针，其中上一个结构体的指针成员指向了下一个结构体，如此往复，就可以实现链表。 如果我们想在链表后面加入新的内容，只需要再创建（malloc）一个节点，并使之前尾部的节点中的指针指向他。 链表可以分为两种：有空头和无空头，有空头也就是第一个节点使不储存数据的，其他节点都接在他的后面，无空头的链表第一个节点存有数据...
高级java笔试题-Lookoop:学习笔记
06-03
数据结构与一些算法，来自算法导论，数据结构与算法分析-C语言描述，C Primer Plus, 数据结构-python描述，博客 ADT链表(c)-抽象链表实现 geometry（c++）-Andrew's Monotone Chain Algorithm Graph (python)-拓扑...
【C语言开源库】C语言必备实用第三方库Melon(包括数据结构算法)_c melon
最新发布
2401_84264583的博客
04-18 1163
这里设置的字符串必须是从内存池或堆中分配的内存，栈中内存会出现段错误，因为赋值时不会在宏内自动复制一份而是直接使用。：是入栈数据的释放函数，由于入栈数据可能为自定义数据结构，因此若需释放，可对此进行设置否则置。节点设置类型，依次分别为：无类型、对象、数组、字符串、数字、布尔真、布尔假、NULL。
C程序设计 第四版（谭浩强）-学习笔记-第十二天
遇酒的博客
01-01 2250
/* 创建时间：20180101 创建人：fangweijun(773714759@qq.com) 功能：通过指向结构体变量的指针变量输出结构体变量中成员的信息 位置：C程序设计(第四版)2010年6月第四版 303页例9.5 */ #include<stdio.h> #include<string.h> int main() { struct Student
C语言链表基础自学笔记
枫林晚
03-09 538
为了复试开始复习C语言的一些编程技巧，今天复习C链表。 1.链表的结构体 typedef struct node{ int data; struct node* next; }Node; 2.创建一个有n的节点的链表 Node *LinkCreate(int n) { Node *head,*end,*s; int i; head = end= (Node*)malloc(s...
c语言链表笔记
qq_44940648的博客
06-19 142
动态链表： 数据结构:关心的是数据在内存中的存储结构 数组：数组的空间是连续 链表：线性访问，但是允许空间不连续 可以将非连续的空间进行连接并进行访问 链表是一种数据结结构，数据结构的定以取决于使用的人 链表的组成： 链表有若干节点连接而成 节点： 存放数据的结构体 指针域：存储相邻节点的地址 数据域：用来存储数据 链表数据结构的创建： 1、定以存储的数据结构 — 节点数据结构 2、创建链表头 – 获取头节点的首地址 对比数组：访问数组是通过数组的首地址，同数组操作，链表的访问也需要首地址，但是不同的是
c 语言链表 笔记
风二中的博客
03-08 134
链表初始化时需要二级指针
c语言链表（笔记）
yy的博客
04-04 300
文章目录创建链表打印链表删除节点插入节点链表拼接 创建链表 情况一：创建的链表结点数通过输入n可知，n作为参数传入函数 struct Student *createList(int n){ struct Student *head,*end,*node; //定义头节点，尾节点，新节点 head=(struct Student *)malloc(sizeof(struct Student)); //给头节点申请内存 end=head;
C语言学习笔记：链表（一）
Qiao____的博客
05-11 228
有关链表 链表 链表是一种常见的基础数据结构。 链表的构成 1、链表头：指向第一个链表结点的指针； 2、链表结点：链表中的每一个元素， 包括： 1）当前结点的数据 2）下一个结点的地址 3、链表尾：不再指向其他结点的结点 ...
链表——学习笔记
m0_59738220的博客
04-13 843
链表学习笔记
链表—学习笔记
qq_40114716的博客
03-05 838
知识点： 链表： 通过指针串联在一起的线性结构，每个节点包含指针域和数据域。 链表的定义及调用方式： //定义 struct ListNode { int val; // 节点存储的元素 ListNode *next； // 指向下一个节点的指针 ListNode(int x) : val (x), next(NULL) {} // 节点的构造函数 }; //构造初始化节点 ListNode* head = new ListNode(5); 类型：单链表（每个节点指向.
链表（学习笔记）
weixin_44109902的博客
01-11 186
一、链表 我觉得还是先把链表捋一下 1、链表的创建 //定义一个链表（结构体） typedef struct node { int num; struct node *next; } ; 创建一个链表 int creat_node(){ struct node *head,*p,*q,*t; int i,n,a; scanf("%d",&n); head =...
C语言-链表-添加到链表尾部
11-27
以下是C语言中将新节点添加到链表尾部的示例代码： ```c #include #include // 定义链表结构体 struct Node { int data; struct Node* next; }; // 在链表尾部添加新节点 void append(struct Node** head_ref...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值