精华内容
下载资源
问答
  • typedef struct LNode{ int data; struct LNode* next; }LNode, *LinkList;...//指定结点后插操作:在p结点之后插入元素e bool InsertNextNode(LNode *p,int e) { if(p == NULL) return false; LNode *s =
    typedef struct LNode{
        int data;
        struct LNode* next;
    }LNode, *LinkList; //这里LNode 和 *LinkList 等价,只不过LNode更强调一个结点,LinkList更强调一个链表。
    
    //指定结点的后插操作:在p结点之后插入元素e
    bool InsertNextNode(LNode *p,int e)
    {
        if(p == NULL)
            return false;
        LNode *s = (LNode*)malloc(sizeof(LNode));
        if(s == NULL) //内存分配失败
            return false;
        s -> data = e; //用结点s保存数据元素e
        s -> next = p -> next;
        p -> next = s; //将结点s连到p之后
        return true;
    }
    
    //指定结点的前插操作:在p结点之前插入元素e
    bool InsertPriorNode(LNode *p,int e)
    {
        if(p==NULL)
            return false;
        LNode *s = (LNode*)malloc(sizeof(LNode));
        if(s==NULL) //申请空间失败
            return false;
        s -> next = p -> next; //新结点s连接到p之后
        s -> data = p -> data; //将p中元素复制到s中
        p -> next = s;
        p -> data = e; //将e赋值给p结点
        return true;
    }
    

    前插法示意

    在这里插入图片描述

    展开全文
  • 指定结点前插操作 typedef struct LNode{ int data; struct LNode *next; }LNode, *LinkList; //在p结点之前插入元素e bool InsertPriorNode(LNode *p, int e){ if(p==NULL) return false; LNode *s = ...

    指定结点的前插操作

    typedef struct LNode{
        int data;
        struct LNode *next;
    }LNode, *LinkList;
    
    //在p结点之前插入元素e
    bool InsertPriorNode(LNode *p, int e){
        if(p==NULL) 
            return false;
        LNode *s = (LNode *)malloc(sizeof(LNode));
        if(s==NULL)            //内存分配失败
            return false;
        s->next = p->next;      
        p->next = s;           //新结点s连到p之后
        s->data = p->data;     //将p中元素复制到s中
        p->data = e;           //p中元素覆盖为e
        return true;
    }
    
    //核心思想:由于没法直接找到p结点的前结点,可以先把s结点插入p结点之后,
    //再把p结点的数据复制到s结点,最后把p中数据赋值为新插入值e。

    指定结点的后插操作

    typedef struct LNode{
        int data;
        struct LNode *next;
    }LNode, *LinkList;
    
    bool InsertNextNode(LNode *p, int e){
        if(p==NULL) 
            return false;
        LNode *s = (LNode *)malloc(sizeof(LNode));
        if(s==NULL)            //内存分配失败
            return false;
        s->data = e;
        s->next = p->next;
        p->next = s;           //将结点s连到p之后
        return true;
    }

    展开全文
  • C语言实现链表之双向链表(五)头结点前插入结点  上一篇文章给出了清空链表的函数,本篇文章将给出插入结点---在头结点之前插入的函数。注意对前向指针的处理。 /*=========================================...

    C语言实现链表之双向链表(五)头结点前插入结点


        上一篇文章给出了清空链表的函数,本篇文章将给出插入结点---在头结点之前插入的函数。注意对前向指针的处理。

    /*============================================================================== 
    *   操作  :在头结点之前加入一个新结点
    *   操作前:pHeadNode为链表的头指针,ListData为待加入的结点数据元素
    *   操作后:数据元素为ListData的结点被加到pHeadNode前面,操作成功返回新的头结点
    *           操作失败返回NULL
    ==============================================================================*/
    MyListNode* InsertFirstNode(MyListNode* pHeadNode, MyListData ListData)
    {
        MyListNode* pListNodeTmp = NULL;
    
        // 错误函数输入的处理
        if(pHeadNode == NULL)
        {
            fprintf(stderr, "There is no list.\n");
            return NULL;
        }
    
        // 为新增结点分配内存
        pListNodeTmp = MallocMemInitNode(pListNodeTmp);
        if(pListNodeTmp == NULL)
        {
            fprintf(stderr, "The new node's memory allocating defeat.\n");
            return NULL;
        }
    
        // 将原始头结点链接到此结点后面,并将数据进行设置
        pListNodeTmp->pNextNodeAddr  = pHeadNode;
        pHeadNode->pPrevNodeAddr     = pListNodeTmp;
        pListNodeTmp->sNodeData      = ListData;
        pHeadNode = pListNodeTmp;
    
        return pHeadNode;
    }

    (1)这个函数依然调用了MallocMemInitNode()函数,用来给结点分配内存,不过数据是由函数参数传入的;

    (2)该函数依旧进行了错误处理。
    展开全文
  • creat_node这个函数应有返回类型,来判断新建结点是否成功,不然主函数中不管成不成功都会访问该节点成员。 改了这个函数,在主函数中create_node后要判断是否成功,不成功就提示并退出函数,退出别忘了还要释放...

    还需改进:

    creat_node这个函数应有返回类型,来判断新建结点是否成功,不然主函数中不管成不成功都会访问该节点成员。

    改了这个函数,在主函数中create_node后要判断是否成功,不成功就提示并退出函数,退出前别忘了还要释放链表!

    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    
    struct node
    {
        int num;
    
        struct node * next;
    };
    
    typedef struct node Node;
    typedef struct node * Link;
    
    void create_link(Link *head)   //创建新链表
    {
        *head = NULL;
    }
    
    void insert_node_head(Link *head,Link new_node)    //前插
    {
        new_node->next = *head;
        *head = new_node;
    }
    
    void display(Link head)  //按序显示链表
    {
        Link p = head;
    
        if(p == NULL)
        {
            printf("Link is empty!\n");
            return;
        }
    
        while(p != NULL)
        {
            printf("num = %d\n",p->num);
            p = p->next;
        }
    }
    
    void insert_node_tail(Link *head,Link new_node)  //尾插
    {
        Link p;
    
        p = *head;
    
        if(p == NULL)
        {
            *head = new_node;
            new_node->next = NULL;
        }
        else
        {
            while(p->next != NULL)
            {
                p = p->next;
            }
            p->next =  new_node;
            new_node->next = NULL;
        }
    }
    
    void create_node(Link *new_node)  //创建新的节点     给new_node指针分配空间
    {
        int count;
        count = 10;        //count保证如果一直申请不了空间的话,他不会一直进入死循环
    
        do
        {
            *new_node = (Link)malloc(sizeof(Node));
            count--;
        }while(!is_malloc_ok(*new_node) && count);
    }
    
    int is_malloc_ok(Link new_node)   //判断给节点分配空间是否有效
    {
        if(NULL == new_node)
        {
            printf("error malloc!\n");
            return 0;
        }
        return 1;
    }
    
    void insert_node_mid_before(Link *head,Link new_node,int loc)  //在给点节点的前面插入
    {
        Link p, q;
    
        p = q = *head;
    
        if(p == NULL)
        {
            printf("Link is empty!\n");
            free(new_node);
            return;
        }
    
        while(p->num != loc && p->next != NULL)
        {
            q = p;
            p = p->next;
        }
    
        if(p->next == NULL)
        {
            if(p->num == loc)
            {
                new_node->next = p;
                q->next = new_node;
            }
            else
            {
                printf("The node cannot be found!\n");
                free(new_node);
                return;
            }
        }
        else
        {
            if(p == *head)
            {
                new_node->next = *head;
                *head = new_node;
            }
            else
            {
                new_node->next = p;
                q->next = new_node;
            }
        }
    }
    
    void insert_node_mid_after(Link head,Link new_node,int loc)  //在给定节点的后面插入
    {
        Link p;
    
        p = head;
    
        if(p == NULL)
        {
            printf("Link is empty!\n");
            free(new_node);
            return;
        }
    
        while(p->num != loc && p->next != NULL)
        {
            p = p->next;
        }
    
        if(p->next == NULL && p->num != loc)
        {
            printf("The node cannot be found!\n");
            free(new_node);
            return;
        }
        else
        {
            new_node->next = p->next;
            p->next = new_node;
        }
    
    
    }
    
    delete_node(Link *head,int number)  //删除节点(输入number查找到指定节点)
    {
        Link p, q;
    
        p = q = *head;
    
        if(p == NULL)
        {
            printf("Link is empty!\n");
        }
        else
        {
            while(p != NULL && p->num != number)   //这两个条件不能颠倒!&&是短路运算符,如果颠倒,当p=NULL时判断p的num就会段错误
            {
                q = p;
                p = p->next;
            }
            
            if(p == NULL)
            {
                printf("No such node!\n");
            }
            else
            {
                if(p == *head)
                {
                    *head = (*head)->next;
                    free(p);
                }
                else
                {
                    q->next = p->next;
                }
            }
        }
    }
    
    int length(Link head)   //返回链表的节点个数
    {
        Link p;
        int count = 0;
    
        p = head;
        while(p != NULL)
        {
            count++;
            p = p->next;
        }
    
        return count;
    
    }
    
    void release_link(Link * head)  //删除并释放链表
    {
        Link p;
        
        p = *head;
    
        if(p == NULL)
        {
            printf("Link is empty!\n");
        }
        else
        {
            while(*head != NULL)
            {
                *head = (*head)->next;
                free(p);
                p = *head;
            }
        }
    }
    
    void insert_node_sort(Link *head,Link new_node)  //插入后对链表里所有的数排序
    {
        Link p, q, k, temp;
        int i, j, count;
    
        new_node->next = *head;
        (*head) = new_node;   
        if(new_node->next == NULL)
        {
            return;
        }
    
        count = length(*head);
    
        for(i = 0; i < count - 1; i++)
        {
            k = *head;
            q = *head;
            p = (*head)->next;
            for(j = 0; j < count - 1 - i; j++)
            {
                if(q->num > p->num)
                {
                    q->next = p->next;
                    p->next = q;
                    if(q == *head)    //不能靠判断k是否指向head
                    {
                        *head = p;
                        k = *head;    //注意这边要让k重指向,画图看看
                    }
                    else
                    {
                        k->next = p;
                    }
                    temp = p;
                    p = q;
                    q = temp;
                }
                if(q == *head)  //不能靠判断k是否指向head
                {
                    q = p;
                    p = p->next;
                }
                else
                {
                    k = q;
                    q = p;
                    p = p->next;
                }
            }
        }
    }
    
    void insert_node_sort2(Link *head,Link new_node) //插入前链表中的数字是有序的,这次插入的数找正确的地方插入
    {
        Link p;
        p = *head;
    
        if(*head == NULL)
        {
            printf("Link is empty!\n");
        }
        else
        {
            if(new_node->num < p->num)
            {
                new_node->next = *head;
                *head = new_node;
            }
            else
            {
                while(p->next != NULL && p->next->num < new_node->num)
                {
                    p = p->next;
                }
                new_node->next = p->next;
                p->next = new_node;
            }
        }
    }
    
    int main()
    {
        Link head;
        Link new_node;
        int i;
        int location;
        int num;
    
        srand((unsigned)time(NULL));
    
        create_link(&head);
    
        for(i = 0; i < 10; i++)
        {
            create_node(&new_node);
            //new_node = (Link)malloc(sizeof(Node));
            
            new_node->num = rand() % 100;
            //insert_node_head(&head,new_node);
    
            insert_node_tail(&head,new_node);     //只要指针所指向的内容,一级指针。要改变指针所指向的方向,二级指针
        }
    
        display(head);
        printf("The length is %d\n\n",length(head));
    
    
        /
        create_node(&new_node);
    
        printf("Please input the new node number:\n");
        scanf("%d",&new_node->num);
    
        printf("Please input the node you want to insert after:\n");
       // printf("Please input the node you want to insert before:\n");
        scanf("%d",&location);
    
       // insert_node_mid_before(&head,new_node,location);
        insert_node_mid_after(head,new_node,location);
    
        display(head);
        printf("The length is %d\n\n",length(head));
    
    
        
        create_node(&new_node);
    
        printf("Please input the node you want to insert:\n");
        scanf("%d",&new_node->num);
    
        insert_node_sort(&head,new_node);
    
        display(head);
        printf("The length is %d\n\n",length(head));
        
        /
        create_node(&new_node);
    
        printf("Please input the node you want to insert:\n");
        scanf("%d",&new_node->num);
    
        insert_node_sort2(&head,new_node);
    
        display(head);
        printf("The length is %d\n\n",length(head));
    
        /
        printf("Please input a node number you want to delete:\n");
        scanf("%d",&num);
    
        delete_node(&head,num);
    
        display(head);
        printf("The length is %d\n\n",length(head));
    
        
        release_link(&head);
        display(head);
    
        return 0;
    }
    

    每次都需要考虑一下头结点这个特殊的位置,不然容易漏。

    先插入后排序的函数最好画图看一下各指针的指向(不要想当然),不然也容易错。

    展开全文
  • 他奶奶的,实验室吵死了,键盘声就不能小一点。 今天刷题做到了leetcode#82,做一会...新建结点tail并将dummy赋值给tail,此时tail的地址会与dummy的相同。 当改变tail的值时,例如tail=tail.next;的时候并不会改变du
  • } //前插 特定元素前插入数据 template<class T> void LinkList<T>::Binsert(T x) { Node* p = NULL; p = first;//遍历链表的指针 Node* q = NULL; T data; cout 请输入您想在前面插入的元素" ; cin >> data;...
  • 根据结点插入位置的不同,链表的创建方法可分为前插法和后插前插前插法是通过将新节点逐个插入链表的头部(头节点之后)来创建链表,每次申请一个新节点,读入相应的数据元素值,然后将新节点插入到头节点之后...
  • // 前插 在特定元素前插入元素, 考虑相同元素有多个 template < class T > void SeqList < T > :: Binsert ( T x ) { int insertdata ; // insertdata表示插入的元素 if ( last == maxSize -...
  • 根据结点插入位置的不同,链表的创建方法可分为前插法和后插前插前插法是通过将新节点逐个插入链表的头部(头节点之后)来创建链表,每次申请一个新节点,读入相应的数据元素值,然后将新节点插入到头节点之后...
  • 链表是一种物理存储单元上非连续、非顺序...链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分:一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。
  • 利用C语言实现链表的前插后插

    千次阅读 2019-03-26 16:55:30
    #define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #include <stdlib.h> typedef struct node{ int data; struct node next;...//前插法: LinkList Inserthead(){ LinkList L; L...
  • 前插法 从空表开始重复读入数据 1、生成新节点 2、将读入的数据存放到新的数据域中 3、将该新节点插入到链表的前端 void CreateList_F(LinkList& L, int n) { L = new LNode; L->next = NULL;//建立...
  • #include <iostream> using namespace std; // 单链表带头结点 typedef int ElemType;...// 指定结点后插操作, 上面的运行时间O(n) bool ListInsert(LNode *p, ElemType e) { if (p == NULL) { return fa
  • C语言实现链表之双向链表(七)尾结点后插入...注意双向链表中向指针的处理,与单向链表对比学习一下。 /*============================================================================== * 操作 :在尾结点
  • 单链表的前插法和后插

    千次阅读 2019-04-26 21:17:00
    printf("请选择前插法(1)或后插法(2):"); scanf("%d", &choice); switch(choice){ case 1:insertLink(head);break; case 2:outsertLink(head);break; default:printf("输入不合法\n"); exit(1); } } int ...
  • 带头节点链表的创建方法:前插法,后插法,顺序添加法。
  • C语言创建链表的方法:前插法,后插法,顺序添加法。
  • 带头结点的单链表

    2021-04-20 15:00:21
    带头结点的单链表定义操作初始化结点前插后插查找插入删除求表长 定义 线性表的链式存储方式称为单链表,它是指通过一组任意的存储单元来存储线性表中的数据元素。 为了实现数据元素之间的线性关系,所以每个结点中...
  • 选择用前插(头插)或后插(尾插)的方式得到如下邻接矩阵的邻接表并输出 输出方式例如 先上代码 class Node{ //无论是表结点还是头结点都是用同一个类即可 String data; //数据域 Node next; //相当于指针域,...
  • } 测试一: 一共要输入的数:5 1 2 3 4 5 0 输入要插入的数:7 要在哪个数和哪个数之间:1 2 1 7 2 3 4 5 测试二: 一共要输入的数:5 1 1 2 3 4 0 输入要插入的数:2 要在哪个数和哪个数之间:1 1 1 2 1 2 3 ...
  • 单链表带头结点与不带头结点插入的区别 ...在表L中的第i个位置插入指定元素e(带头结点) **采用后插操作 bool ListInsert2(LinkList &L, int I, int e);//按位序插入操作。在表L中的第i个位置插入指定元
  • 初学C#记录历程,记录心情。在学习的过程中严重参考了前辈们在网上的分享,当然也不忘有自己的细微思想在里面,写在这里主要是对自己由不懂到能独立写下来的纪念。...//在i前插 节点类和链表类参考...
  • 提示:数据结构-线性表-单链表-结构体定义/后插法建立/前插法/删除/查找/合并有序单链表-c语言 提示:以下是本篇文章正文内容,下面案例可供参考 一、单链表的结构体定义 //单链表的结构体的定义 1.数据 2.指向下一...
  • } 单链表的建立(前插法) 给等待插入的新节点分配一块内存空间,然后使用前插法 Status CreateList_Sq(Linklist &L,int n) //创建单链表的各节点以及对各节点数据域赋值(前插法) { Linklist p; for(int i=0;i { ...
  • [size=24px]对带头结点的单链表L,在指针p所指的结点上插入数据元素为e的新结点(设由指针s指示):前插O(n),后插O(1),分别写出插入算法,[color=#FF0000]思考:前插O(n),如何改进至O(1)?[/color][/size]重点是...
  • //改变被删结点的前驱结点 *e=q->data; //保存删除结点的数据域 free(q); //删除空间 return 1; } Status CreateList_F(LinkList &L,int n) //输入的数据域会逆置,所以建议逆序输入 { LinkList p; L=(LinkList)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,563
精华内容 625
关键字:

结点前插后插