精华内容
下载资源
问答
  • 链表创建

    2020-02-21 08:55:19
    1.经常要用链表,所以找了个模板。---- #include<stdio.h> #include<malloc.h> #include<stdlib.h> typedef int ElementType; // 定义数据类型,可根据需要进行其他类型定义 // 链表节点...
    1.经常要用链表,所以找了个模板。----
    
    #include<stdio.h>
    #include<malloc.h>
    #include<stdlib.h>
    
    typedef int ElementType;        //    定义数据类型,可根据需要进行其他类型定义
                                    //    链表节点的定义
    typedef struct ListNode {
        ElementType  Element;        //    数据域,存放数据
        struct ListNode* Next;        //    指向下一个链表节点
    }Node, *PNode;
    
    //    函数声明
    PNode CreateList(void);    //    声明创建链表函数
    void TraverseList(PNode List);    //    声明遍历链表函数
    void InsertList(PNode List, int pos, int val);        //    声明链表插入函数
    void DeleteTheList(PNode List);    //    声明删除整个链表函数
    void DeleteList(PNode List, int pos);    //    声明删除链表元素函数
    PNode FindList(PNode List);    //    声明链表查询函数
    
    //    主函数 
    int main() {
        PNode List = CreateList();    //    创建一个指针,使其指向新创建的链表的头指针    
        TraverseList(List);        //    遍历链表
        FindList(List);        //    链表查询    
        InsertList(List, 3, 100);    //    链表插入,在第三个位置插入数值100
        TraverseList(List);
        DeleteList(List, 3);    //    删除链表第三个节点
        TraverseList(List);
        DeleteTheList(List);    //    删除整个链表
        TraverseList(List);
        return 0;
    }
    
    //    创建链表函数定义
    PNode CreateList(void) {
        int len ;    //    用于定义链表长度
        int val ;    //    用于存放节点数值
        PNode PHead = (PNode)malloc(sizeof(Node));    //    创建分配一个头节点内存空间
        if (PHead == NULL)    //    判断是否分配成功
        {
            printf("空间分配失败 \n");
            exit(-1);
        }
    
        PNode PTail = PHead;    //    链表的末尾节点,初始指向头节点
        PTail->Next = NULL;    //    最后一个节点指针置为空
        printf("请输入节点个数:");
        scanf("%d", &len);        //    输入节点个数
        for (int i = 0; i < len; i++) {
    
            PNode PNew = (PNode)malloc(sizeof(Node));    //    分配一个新节点
            if (PNew == NULL) {
                printf("分配新节点失败\n");
                exit(-1);
            }
            printf("请输入第 %d 个节点的数据:", i + 1);
            scanf("%d", &val);    //    输入链表节点的数据
    
            PNew->Element = val;    //    把数据赋值给节点数据域
            PTail->Next = PNew;    //    末尾节点指针指向下一个新节点
            PNew->Next = NULL;        //    新节点指针指向为空
            PTail = PNew;    //    将新节点复制给末尾节点        
        }
        printf("创建链表成功\n");
        return PHead;    //    返回头节点
    }
    
    //    定义链表遍历函数
    void TraverseList(PNode List) {
        PNode P = List->Next;    //    首节点赋值给临时节点P
        printf("遍历链表的值为:");
        if (P == NULL)
            printf("链表为空");
        while (P != NULL)        //当临时节点P不为尾节点时,输出当前节点值 
        {
            printf("%d ", P->Element);
            P = P->Next;
        }
        printf("\n");
    }
    
    //    定义链表查询函数
    PNode FindList(PNode List) {
        PNode P = List->Next;    //    定义临时指针P指向首节点的地址
        int num = 0;    //    用于记录链表节点位置
        int val = 0;    //    用于存放要查询的值
        printf("请输入要查询的数:");
        scanf("%d", &val);    //    输入要查询的数值
        while (P != NULL&&P->Element != val) {
            P = P->Next;
            ++num;
        }
        if (P != NULL)
            printf("找到的节点为:%d", num + 1);
        else
            printf("找不到该节点");
        printf("\n");
        return P;
    }
    //     定义链表插入函数
    //    在链表位置第pos节点前插入包含数据val的节点
    void InsertList(PNode List, int pos, int val) {
        int position = 0;
        PNode P = List;    //    定义节点p指向头节点
                        //    寻找pos节点的前驱结点
        while (P != NULL&&position<pos - 1)
        {
            P = P->Next;
            ++position;
        }
        if(NULL == P) {
        printf("no node on pos\n");
        return;
        }
        PNode Tmp = (PNode)malloc(sizeof(Node));    //    分配一个临时节点用来存储要插入的数据
        if (Tmp == NULL)
        {
            printf("内存分配失败!");
            exit(-1);
        }
        //    插入节点
        Tmp->Element = val;
        Tmp->Next = P->Next;
        P->Next = Tmp;
    }
    
    //定义删除整个链表函数
    void DeleteTheList(PNode List) {
        PNode P, Tmp;
        P = List->Next;    //定义指针P指向链表要删除的链表List的第一个点节点
        List->Next = NULL;
        while (P != NULL) {
            Tmp = P->Next;        //临时Tmp指向要删除的节点的下个节点
            free(P);    //释放指针P指向的节点
            P = Tmp;    //重新赋值
        }
        printf("删除链表成功!\n");
    }
    //    定义删除链表元素函数
    //    删除链表中的第pos节点
    void DeleteList(PNode List, int pos) {
        int position = 0;
        PNode P = List;    //    定义一个指针p指向链表头节点
                        //    寻找pos节点位置的前驱节点
        while (P != NULL&&position < pos - 1) {
            P = P->Next;
            ++position;
        }
    
        //    删除节点
        if(NULL == P) {
            printf("No node on pos\n");
            return;
        }
        PNode Tmp = P->Next;    //    定义临时指针Tmp指向要删除的节点
        P->Next = Tmp->Next;    //    使要删除节点的前驱结点指向其后驱节点
        free(Tmp);    //    释放删除节点的内存空间,防止内存泄漏
        Tmp = NULL;    //    使q指向空指针,防止产生野指针
    }
    展开全文
  • 链表创建查询

    2014-01-08 22:51:00
    链表创建查询
  • 链表创建二叉树

    2013-06-02 20:52:06
    有关于数据结构中链表创建二叉树实现其功能
  • C++链表创建模板

    2019-09-22 10:37:36
    c++ 链表 创建模板

    链表的基本操作要不经大脑思考直接写出

    #include<bits/stdc++.h>
    using namespace std;
    
    typedef struct Node {
    	int data;
    	Node *next;
    }*LinkList;
    
    void creatList(LinkList l1, int length);
    
    int main() {
    	LinkList l1 = new Node;
    	LinkList n=l1;
    	l1->data = -1;
    	l1->next = NULL;//头节点
    	creatList(l1, 4);//创建链表
    	while (n->next) {
    		n = n->next;
    		cout<<n->data<<endl;
    	
    	}
    	delete l1;
    	return 0;
    }
    //创建链表
    void creatList(LinkList l1, int length) {
    	int i = 0;//记录链表长度
    	LinkList p1, p2;
    	p1 = p2 = l1;
    	while (i < length) {
    		p1 = new Node;//创建一个节点
    		p1->data = i+1;
    		p2->next = p1;//节点的移动
    		p2 = p1;
    		i++;
    	}
    	p2->next = NULL;
    }
    
    展开全文
  • 链表创建与排序

    2020-04-21 22:45:22
    编写一个能将链表创建与排序的小程序。 假设链表节点的结构体声明如下 struct node { int i; char c; node *next; }; 用户先依次输入每个节点的内容,要求输入的i要大于0 直到输入-1为止 按照i字段对链表所有元素...

    编写一个能将链表创建与排序的小程序。
    假设链表节点的结构体声明如下

    struct node
    {     
        int  i;      
        char c;     
        node *next;
    };

    用户先依次输入每个节点的内容,要求输入的i要大于0
    直到输入-1为止
    按照i字段对链表所有元素进行由小到大排序并输出
    效果如下:
    输入:

    12 a
    14 c
    10 b
    -1

    输出:

    [10,b];[12,a];[14,c]
    //不使用链表
    #include <iostream>
    using namespace std;
    struct data
    {
        int i;
        char c;
        data *next;
    }da[100];
    int main()
    {
     int j,temp,flag=0;
     char c1;
     for(j=0;;j++)
     {
      cin>>da[j].i;
      if(da[j].i!=-1)
      {
       cin>>da[j].c;
      }
      else
      {
       break;
      }
     }
     for(int m=0;m<j-1;m++)
     {
      for(int n=0;n<j-m-1;n++)
      {
       if(da[n].i>da[n+1].i)
       {
        temp=da[n].i;
        da[n].i=da[n+1].i;
        da[n+1].i=temp;
        c1=da[n].c;
        da[n].c=da[n+1].c;
        da[n+1].c=c1;
       }
      }
     }
     for(int k=0;k<j;k++)
     {
      if(flag==0)
      {
       cout<<"["<<da[0].i<<","<<da[0].c<<"]";
       flag=1;
      }
      else
      {
       cout<<";["<<da[k].i<<","<<da[k].c<<"]";
      }
     }
    }

    #include <iostream>
    using namespace std;
    struct data
    {
        int i;
        char c;
        data *next;
    };
    void px(data a[],int len);//利用排序函数
    int main()
    {
        data s[50];
        for(int m=0;m<100;m++)
        {
            cin>>s[m].i;
            if(s[m].i==-1)
            {
                break;
            }
            cin>>s[m].c;
        }
        int n=0;
        for(int k=0;s[k].i!=-1;k++)
        {
            n=n+1;
        }
        px(s,n);
        for(int j=0;j<n;j++)
        {
            cout<<'['<<s[j].i<<','<<s[j].c<<']';
            if(j==n-1)
            {
                break;
            }
          cout<<";";
        }
        return 0;
    }
    void px(data s[],int len)//排序
    {
        for(int c=0;c<len-1;c++)
        {
            int min=c;
            for(int j=c+1;j<len;j++)
            {
                if(s[j].i<s[min].i)
                {
              	min=j;
       	    }
                data temp=s[c];
                s[c]=s[min];
                s[min]=temp;   
      	}
        }
    }
    展开全文
  • c语言链表创建

    2018-10-23 11:31:28
    详细用c语言创建链表,通俗易懂链表是一种常见的基础数据结构,结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配,也就是说,链表是一个功能极为强大的数组,他可以在节点中定义多种数据类型,还可以...
  • 使用链表创建多项式存储 键盘输入指定多项式的项数,然后分别输入各项的系数和指数,链表自动按照指数从小到大排列 // 使用链表创建多项式 #include <stdio.h> #include <stdlib.h> struct pnote //...

    使用链表创建多项式存储

    键盘输入指定多项式的项数,然后分别输入各项的系数和指数,链表自动按照指数从小到大排列

    // 使用链表创建多项式
    #include <stdio.h>
    #include <stdlib.h>
    
    struct pnote    //多项式各项结点结构体
    {
        float ceof;
        int expn;
        struct pnote *next;
    };
    
    struct polyn_head   //多项式头结点结构体
    {
        struct pnote *next;
        int num;  //储存多项式项数
    };
    
    void creat_polyn(struct polyn_head*, int);
    void output(struct polyn_head *head);
    
    int main()
    {
        struct polyn_head polyn1;
        struct polyn_head *head;
        int n;
        head = &polyn1;
        printf("请输入多项式的项数:");
        scanf("%d", &n);
        creat_polyn(head, n);
        output(head);
    }
    
    //定义使用链表创建多项式的函数
    void creat_polyn(struct polyn_head *head, int n)
    {
        head->num = n;
        struct pnote *s, *p, *q;
        s = (struct pnote *)malloc(sizeof(struct pnote));   //添加第一项
        printf("请分别输入该项系数和指数,用空格隔开:");
        scanf("%f %d", &s->ceof, &s->expn);
        s->next = NULL;
        head->next = s;
    
        s = (struct pnote *)malloc(sizeof(struct pnote));   //添加第2项
        printf("请分别输入该项系数和指数,用空格隔开:");
        scanf("%f %d", &s->ceof, &s->expn);
        p = head->next;
        if(s->expn < p->expn)
        {
            s->next = head->next;
            head->next = s;
        }
        else if(s->expn > p->expn)
        {
            p->next = s;
            s->next = NULL;
        }
        for(int i = 1; i < n - 1; i++)
        {
            s = (struct pnote *)malloc(sizeof(struct pnote));   //添加第一项
            printf("请分别输入该项系数和指数,用空格隔开:");
            scanf("%f %d", &s->ceof, &s->expn);
            p = head->next;
            q = p->next;
            if(s->expn < p->expn)
            {
                s->next = head->next;
                head->next = s;
            }
            else if(s->expn > p->expn)
            {
                //为了能够实现这一步,必须已经拥有p、q两个结点。
                while(q && s->expn > q->expn)
                {
                    p = q;
                    q = q->next;
                }
                s->next = q;
                p->next = s;
            }
        }
    }
    
    void output(struct polyn_head *head)
    {
        struct pnote *p;
        p = head->next;
        while(p->next)
        {
            printf("%.2fx^%d + ", p->ceof, p->expn);
            p = p->next;
        }
        printf("%.2fx^%d  ", p->ceof, p->expn);
    }
    
    
    展开全文
  • 链表创建、反转

    2015-10-05 11:17:15
    链表创建、反转
  • C++数据结构---链表(链表创建

    千次阅读 2017-08-14 00:02:15
    本文附上链表创建的整个代码,包括自己写的链表节点创建的头文件(节点创建可以看C++数据结构—链表(链表节点创建))链表创建代码如下:#pragma once #ifndef LIST_HH #define LIST_HH #include #include"ListNode...
  • C++简洁的链表创建

    2019-02-26 20:45:00
    https://mintlucas.github.io/2019/02/26/C-简洁的链表创建/ 注意形参传递,在createList中为pHead开辟空间的时候,main中的head依旧指向NULL,所以要用引用绑定main里的head 不使用返回值传递而使用参数传递时,.....
  • c++编写的图的邻接链表创建形式,希望对你有帮助
  • 此类链表创建最为简单,但是不利于下面的处理void create(int n, type *stu) { int i; printf("输入数据\n"); for (i = 0; i ; i++) { stu = (type*)malloc(sizeof(type)); scanf("%d", &stu->data); s
  • 1、链表创建、翻转及遍历 单链表反转详解参考:单链表反转_python版 class CreateNode(object): '''创建链表节点''' def __init__(self,data,next = None): self.data = data self.next = next def create_...
  • c语言简单数据结构基础,链表应用,简单链表创建,插入,输出
  • 链表 创建插入删除

    2014-03-19 11:08:52
    链表的节点定义,链表创建、插入、删除。
  • 例一:链表创建 单向链表: 只能往后指,不能往前看 通过考察链表 = 考察敲代码能力 递归: 严格定义函数的作用: 给一个数组,把数组每个元素生成一个节点, 把节点首尾相接 链表必须以null结尾 把第一个...
  • 数据结构——二叉链表创建二叉树(C语言版)

    千次阅读 多人点赞 2020-12-08 15:36:21
    数据结构——二叉链表创建二叉树一、思想(先序思想创建):二、创建二叉树(1)传一级参数方法 一、思想(先序思想创建): 第一步先创建根节点,然后创建根节点左子树,开始递归创建左子树,直到递归创建到的节点下...
  • 链表创建之有头节点空

    千次阅读 2017-04-02 18:39:26
    这种链表创建要注意链表是怎么创建的,画个流程图更加清晰; 链表的创建在于上一个节点的next是下一个新节点TYPE* create(int n) { TYPE *head, *endp, *p1; //head为头节点,endp为尾节点,p1为操作节点(当前节点...
  • C语言来实现链表创建

    2020-10-11 15:50:50
    前言 链表是数据结构中很重要的内容,要想学会数据结构,首先要了解链表 链表的基本知识 1,链表的构成 ...创建链表前需要先创建结构体作为节点和头指针: typedef struct Node //typedef方法函数可以对于st
  • C++ 学生信息录入系统(链表创建插入) #include "stdio.h" #include "malloc.h" //定义链表结构 typedef struct student { int num; char name[300]; struct student *next; }St; //预声明 St* InsertSt();...
  • C语言链表创建

    万次阅读 2018-07-24 20:27:38
    //创建一个节点 printf ( "node_ptr->data=%d\n" ,node_ptr->data); //打印节点里的数据 printf ( "node_ptr->next=%d\n" ,node_ptr->next); node_ptr= node_ptr->next; node_ptr=create_list_node(data2)...
  • C链表创建,增加,删除功能详解,新手必看,也可买c语音书进行学习
  • 双向链表创建,插入,删除,销毁等,写的一个代码(包括详细的注释,初学者都看得懂),已经成功测试。及拿即用。
  • C语言 单向链表创建

    2017-07-29 15:10:29
    单向链表创建: 1、首先是创建一个头结点,他的数据域可以不设置,也可以设置成记录链表的长度; 2、创建一个尾节点; 3、创建一个要插入的节点; 尾节点的作用是作为新节点的插入点 #include #include #define...
  • 链表创建(create_list)与遍历(travese_list) 《数据结构》研究的主要是对数据的存储问题,而链表作为线性存储的一个重要方式,如何通过c语言来实现对链表的操作(下面的代码主要是创建链表以及如何遍历输出)是...
  • 链表创建节点

    2015-10-29 08:28:51
    // ListNode *t=new ListNode(val%10);  // p->next=t;  // p=t; ListNode t(val%10); ...创建链表的时候,声明节点,只能在堆空间中申请,也就是上面注释的可以,下面的不可以,不知道为什么
  • 24_链表创建和链表遍历算法的演示 #include #include #include   typedefstruct Node {  int data;//数据域  struct Node * pNext;//指针域 }NODE,*PNODE;//NODE等价于structNode,PNODE等价于struct Node * //...
  • 1.什么是链表链表是一种常见的数据结构,链表是由多个结点(自引用结构体)串成的表。 什么是自引用结构体? 自引用结构体是一种特殊的结构体类型,它有一个指针类型的...2.创建链表步骤分解 1.结构体声明 struct no

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,045
精华内容 8,418
关键字:

链表创建