精华内容
下载资源
问答
  • 很多刚接触数据结构的小白在学完单链表,只知道理论知识,却不知道如何实现,这是用c++语言实现的两种单链表初始化过程
  • C语言之单链表初始化

    千次阅读 多人点赞 2020-04-26 23:04:44
    单链表

    单链表前言

    在我之前的一片文章当中已经介绍过了单链表的作用以及他的优缺点。对于一个单链表的基础操作,也在上篇文章中给予了大概的轮廓。这篇文章主要是介绍单链表的初始化。
    目前这个系列的文章目录:

    1. 单链表及各项操作介绍
    2. 本文:单链表初始化
    3. 单链表打印(遍历),查询,定位,插入,删除,链表长度
    4. 单链表反转,排序

    通过结构体定义节点

    单链表的基本组成单位是节点,所以在编程当中我们先要定义这个节点。而这个节点主要内容包含了两个变量,一个是数据,另一个是指向下一个节点的指针。如果要想把两个变量放到一起,在C语言当中唯一的做法只有数据结构。或许有朋友会说用一个长度为2的数组也可以实现。这个说法不全,当数据类型是整型的时候,是可以的,不过倘若数据类型是字符,那么这个说法就实行不了了。
    节点的定义有以下两种方法:
    方法一:

    struct node {
    	int value;
    	struct node* next;
    };
    

    方法二:

    typedef struct node {
    	int value;
    	struct node* next;
    }node;
    

    如果在网上查资料的同学还会发现有一种写法,
    方法三:

    struct node{
    	int value;
    	struct node* next;
    }node;
    

    这三个方法很容易会让人混淆。我在自学阶段也研究了半天。方法三跟方法一的不同就是在“{}”后面多了一个“node”。而方法三看上去又跟方法二很像,所以很多时候就会觉得很迷惑。
    其实方法一和方法三是一致的。
    这么看,在方法一中,struct是说明现在要定义一个结构体。然后struct后面那一node就是来给这个结构体一个名字,名字就叫做node。然后这个结构体(node)的内容都在{}里面。当定义完之后node{}就已经成为了一中数据类型了,跟‘int’,'char’是在同一个范畴里的。然后在{}后面加上了一个名称(这里是node),其实和int a,是一个概念。所以在方法三中,它不仅仅是定义了一个结构体,而且同时创建了一个结构体变量。而方法一仅仅只是创建了一个结构体。代码大概框架如下:

    struct 	//声明一个结构体
    node	//给结构命名
    {		//给结构体node定义内容
    	int value;
    	struct node* next;
    }
    node;	//创建一个数据类型为node的变量。
    

    不过,方法一或者三中都有一个 缺点,就是每次创建一新的节点/结构体时,都要这样定义:

    struct node a//a为任意你想取的名称
    

    对于有成千上万行的程序来说,每次都要多打一次struct实在是太费劲了,所以就有了方法二这个代码。

    typedef是一个给数据类型重新命名的指令。
    例如typedef int a
    从此在代码时,int c等同于 a c。
    所以方法二中是这么理解的:
    
    typedef 					//重新命名
    struct node {				//重新命名的对象
    	int value;
    	struct node* next;
    }
    node;						//新名字
    

    所以给结构体重新命名后,以后创建一个新的节点只需这样:

    node p;
    //它等同于
    struct node p;
    

    节点内容

    节点的内容之前已经介绍个,在单链表里存放的信息主要有两项,一个数据,另一个就是指向下一个节点的指针(其实就是链)。在本文当中数据类型假设为int,当然有时候可能会需要char或者是其他类型的话,需要整体修改会很麻烦。在这里有另一种优化方式,就是我刚才说的typedef。

    typedef int datatype 
    typedef struct node {
    	datatype value;
    	struct node* next;
    }node;
    

    目前为止一个新的数据结构就已经被成功定义了。下一步就是如何把数据放入到链表当中

    生成链表头

    链表头是整个链表的第一个节点,它不存放任何数据信息,不过它可以告诉我们第一个数据是从哪一个开始。

    	//---------------------------------------------------------------
    	//创建头标
    	printf("正在创建头链表......\n\n");
    	node* head = _head();
    	printf("头链表创建成功。\n\n");
    

    而_head函数代码为:

    //创建头标													
    node* _head() {
    	node* head = (node*)malloc(sizeof(node));
    	if (head == NULL)
    		exit(-1);//head=_head();							
    	head->next = NULL;
    	return head;
    }
    

    在生成链表头当中主要是想要避免一个情况,就是head刚好被分配到了NULL这个地址,那么这个代码就运行不了了,因为我之前也说过,NULL这个地址是不能被访问的。

    数据放入链表当中

    在这个案例思虑的比较简单,就是假设我们已经知道数据量的大小以及我们人工输入数据。在一般的情况下数据量很大的话,可以直接应用文件fopen来读取数据。不过这里就先引用一个稍微简单的方法,由浅入深。以下是在主函数内的代码。

    	//---------------------------------------------------------------
    	//输入初始化数据个数
    	printf("多少个数字你想输入?(输入数字)\n");
    	scanf_s("%d", &num);
    	head->value = num;
    	//---------------------------------------------------------------
    	//插入数据
    	printf("\n开始输入你想输入的数字。\n");
    	_insert(head, num);
    	printf("\n完成输入,链表初始化完成。\n\n");
    

    在这里可以看到,我把数据量的大小直接寄存在了头文件的数据域里,其实一般情况下数据域是不存在任何信息的,不过为了之后的步骤,暂时先在这里记录链表的尺寸吧。
    对于函数:_insert(head,num);它的代码如下:

    //----------------------------------------------------------
    //插入新数据												
    void _insert(node* head, int num) {
    	int v, i = 0;
    	while (i < num) {
    		node* current = head;
    		node* new = (node*)malloc(sizeof(node));
    		printf("第 %d 位数据数值: ", i + 1);
    		scanf_s("%d", &v);
    		char c = getchar();
    		new->value = v;
    		new->next = NULL;
    		while (current->next != NULL) {
    			current = current->next;
    		}
    		current->next = new;
    		i++;
    	}
    }
    

    在这代码比较直接关注的部分是:

    		new->value = v;
    		new->next = NULL;
    		while (current->next != NULL) {
    			current = current->next;
    		}
    		current->next = new;`
    

    在这个代码当中,对于初学者理解可能有一些吃力,以下为它创立的顺序步骤图:
    在这里插入图片描述

    对于while循环里面,其实就是想找到这个链表目前为止的最后一个节点,找到之后就把最后一个节点里的指针指向新节点以求达到新节点被添加到链表里的效果。

    当以上步骤都完成之后,你那么一个单链表的初始化就已经被完成了。之后的文章会开始讲解不同的操作,例如打印,查询和定位功能。

    展开全文
  • 单链表初始化代码

    千次阅读 2020-03-24 18:52:12
    //初始化一个空的单链表 bool InitList(LinkList &L) { L=NULL; //空表,暂时还没有任何结点(防止脏数据遗留) return true; } ②有头节点 //初始化一个空的单链表(带头结点) bool InitList(LinkList &...

    ①无头结点

    //初始化一个空的单链表
    bool InitList(LinkList &L)
    {
        L=NULL; //空表,暂时还没有任何结点(防止脏数据遗留)
        return true;
    }
    
    

    ②有头节点

    //初始化一个空的单链表(带头结点)
    bool InitList(LinkList &L)
    {
        L=(LNode*)malloc(sizeof(LNode)); //分配一个头节点
        if(L==NULL)
            return false;
        L->next=NULL;
        return true;
    }
    
    

    基本代码如下:

    #include<stdio.h>
    #include<stdlib.h>
    
    typedef struct LNode //定义单链表结点类型
    {
        ElemType data;    //每个结点存放一个数据元素
        struct LNode *next; //指针指向下一个节点
    }LNode,*LinkList;
    
    //初始化一个空的单链表(带头结点)
    bool InitList(LinkList &L)
    {
        L=(LNode*)malloc(sizeof(LNode)); //分配一个头节点
        if(L==NULL)
            return false;
        L->next=NULL;
        return true;
    }
    
    void test()
    {
        LinkList L; //声明一个指向单链表的指针
        //初始化一个空表
        InitList(L);
    }
    
    
    展开全文
  • 【数据结构】单链表初始化

    万次阅读 2019-03-26 17:53:49
    #include <stdio.h> #include <stdlib.h> //链表中节点的结构 typedef struct Link { ...//初始化链表的函数 link * initLink(); //用于输出链表的函数 void display(link *p); int...

     

    #include <stdio.h>
    #include <stdlib.h>
    
    
    //链表中节点的结构
    typedef struct Link {
    	int  elem;
    	struct Link *next;
    }link;
    
    //初始化链表的函数
    link * initLink();
    //用于输出链表的函数
    void display(link *p);
    
    int main() {
    	//初始化链表(1,2,3,4)
    	printf("初始化链表为:\n");
    	link *p = initLink();
    	display(p);
    	return 0;
    }
    //无头节点的链表
    //link * initLink() {
    //	link * p = NULL;//创建头指针
    //	link * temp = (link*)malloc(sizeof(link));//创建首元节点
    //											  //首元节点先初始化
    //	temp->elem = 1;
    //	temp->next = NULL;
    //	p = temp;//头指针指向首元节点
    //	for (int i = 2; i<5; i++) {
    //		link *a = (link*)malloc(sizeof(link));
    //		a->elem = i;
    //		a->next = NULL;
    //		temp->next = a;
    //		temp = temp->next;
    //	}
    //	return p;
    //}
    //含头结点的链表
    link * initLink() {
    	link * p = (link*)malloc(sizeof(link));//创建一个头结点
    	link * temp = p;//声明一个指针指向头结点,
    					//生成链表
    	for (int i = 1; i<5; i++) {
    		link *a = (link*)malloc(sizeof(link));//申请一个新节点
    		a->elem = i;//第二个节点的数据域a->data=1;
    		a->next = NULL;//指针域为空
    		 //a所指向的节点连接在temp指向节点的后面(新节点插入链尾)
    		temp->next = a; 
    //指针temp每次都指向新链表的最后一个节点,其实就是 a节点,这里写temp = a也对(修改为指针)
    		temp = temp->next;
    		 
    	}
    	return p;
    }
    
    //void display(link *p) {
    //	link* temp = p;//将temp指针重新指向头结点
    //				   //只要temp指针指向的结点的next不是Null,就执行输出语句。
    //	while (temp) {
    //		printf("%d ", temp->elem);
    //		temp = temp->next;
    //	}
    //	printf("\n");
    //}
    void display(link *p) {
    	link* temp = p;//将temp指针重新指向头结点
    				   //只要temp指针指向的结点的next不是Null,就执行输出语句。
    	while (temp->next) {
    		temp = temp->next;
    		printf("%d", temp->elem);
    	}
    	printf("\n");
    }

     

    展开全文
  • 因为想使用纯C语言,不使用C++d的内容,所以在创建链表初始化的时候就遇到了问题。 以下是我写的第一版本的代码 #include // 链表定义 typedef struct LNode{ int data; struct LNode * next; }LNode,*LinkList; //...
  • #include #include <stdlib.h>#define OK 1 #define TRUE 1 #define ERROR -1 #define FALSE -1 #define OVERFLOW -2 #define ElemType int #define Status int //-------------------------------线性单链表 ty
    #include <stdio.h>
    #include <stdlib.h>
    
    #define OK 1
    #define TRUE 1
    #define ERROR -1
    #define FALSE -1
    #define OVERFLOW -2
    #define ElemType int
    #define Status int
    //-------------------------------线性单链表
    typedef struct LNode{ //封装一个线性单链表
        ElemType data; //数据域
        struct LNode *next; //指针域
    }LNode, *LinkList;//类型重定义struct LNode为Lnode,类型重定义 Lnode的*指针 为LinkList
    Status InitList_L(LinkList &L) {  //初始化线性链表
        L = (LinkList)malloc(sizeof(LNode)); //新开辟内存,返回指针L
        L->next = Null;//L->//对于指针p  p->a  被定义为 (*p).a   (不成文的标准)
        return TRUE;
    }
    Status GetElem_L(LinkList L,int i,ElemType &e){ //取出元素,i是序号,e为值
        //L为带头结点的单链表的头指针
        //当第i个元素存在时,将值返回给e,返回TRUE, 否则FALSE
        p = L->next; j = 1;//初始化,p指向第一个结点,j为计数器
        while (p && j<i) { //p指针非空,j计数器<i,所以循环的终点是i
            p = p->next; ++j;//指针后移一个,计数器+1一个
        }
        if (!p || j>i) return FALSE;//第i个元素不存在
        e = p->data;//取出第i个元素,值为e
        return TRUE;
    }//GetElem_L
    Status ListInsert_L(LinkList &L, int i, ElemType e) { //在带head的单链表L中第i个位置之前插入元素e    
        p = L; j = 0;//p为指针,被插入的previous Node
        while (p && j < i - 1) { p = p->next; ++j; }//寻找第i个结点,指针下移,j最后停在i
        if (!p || j>i) return FALSE;
        s = (LinkList)malloc(sizeof(LNode));//生成新节点,开辟内存空间 返回指针s,insert
        s->data = e;//s->data域的赋值 assignment
        s->next = p->next;//指针操作 ,=右往左,指针 指向 
        p->next = s;
    }
    Status ListDelete_L(LinkList &L, int i, ElemType &e) { //在带head的单链表L中第i个位置 删除元素e        
        p = L; j = 0;//p为指针,被插入的previous Node
        while (p && j < i - 1) { p = p->next; ++j; }//寻找第i个结点,下标最后是i-1,指针下移,j最后停在i
        if (p->next || j>i - 1) return FALSE;//删除位置不合理
    
        q = p->next; //q是被删除的节点 
        p->next = q->next;//P的next,指向q->next
    
        e = q->data; //取出 值为e
        free(q);//返回值,释放空间
    }
    LNode * LocateElem_L(LinkList L, ElemType e) { //在L中找到第一个值和e相同的结点,返回其地址,若不存在,返回空值NULL。
        if (!L) return NULL;
        p = L;
        while (p&&p->data != e) { p = p->next };//if(!p) p=null;
        return p;//时间复杂度O(n)
    }
    void CreateList_L(LinkList &L, int n) { //头插法 生成单链表 逆序初始化
        //逆位序输入n个元素的值,建立带表头结点的单链线性表L
        L = (LinkList)malloc(sizeof(LNode));
        L->next = NULL;//L->next表示头结点的指针,先建立一个带头结点的单链表
        for (i = n; i > 0; --i) {
            p = (LinkList)malloc(sizeof(LNode));
            scanf(&p->data);//输入元素值
            p->next = L->next;//挪动 头指针的后继
            L->next = p;//挪动 头指针的后继
        }
    }
    void MergeList_L(LinkList &La, LinkList &Lb,) { 
        //已知La和Lb升序排列
        //合并得到新的单链表Lc,Lc的元素也按值非递减排列
        pa = La->next;
        pb = Lb->next;
        q = La;//存放临时指针,q就是pa的前驱元素,q必须始终作为pa的前驱元素
        while (pa && pb) {
            if (pa->data <= pb->data) {//如果小于=,pc指针指向pa
                q = pa;//q下移
                pa = pa->next;//pa下移
            }
            else {//如果>,pc指针指向pb
                t = pb;// t 下移
                pb = pb->next;//pb下移
                t->next = pa;//t插入pa的前面
                q->next = t;
                q = t;//q必须始终作为pa的前驱元素,因此t赋值给q
            }//2个结合起来就是小者排前面,这个代码写的真差,不是人类看的,因为C在A和B只见跳来跳去,临时pc变量拆成2个就容易理解了
        }
        if (pb) q->next = pb;
    }//MergeList_L
    
    展开全文
  • //单链表 初始化 创建 头插法 尾插法 插入 删除 查找 合并 typedef struct LNode{ //封装一个线性单链表 Da ElemType data ; //数据域 struct LNode * next; //指针域 }LNode, * LinkList; //类型重定义...
  • // 单链表的类型定义 typedef struct node { int data; // 数据域 struct node *next; // 指针域 }Node, *LinkList; 因为单链表头结点和插入的结点要动态生成,所以要引入系统头文件<stdlib.h>...
  • java实现单链表初始化

    千次阅读 2020-04-17 22:34:18
    引子 做了牛客网上的《剑指offer》第三题 ,发现对单链表的构建不太了解。因为牛客网上并未要求实现main函数,...代码区的格式为: 定义了一个ListNode,即链表的结点类; 实现printListFromTailToHead函数,并且...
  • 循环单链表初始化、建立与遍历 文章目录前言代码实现其他 前言 循环链表是另一种形式的链式存储结构。它的特点是表中最后一个结点的指针域指向头结点,整个链表形成一个环。 代码实现 代码如下(示例): #...
  • 将L1的值作为实参传入初始化函数initlist时,即等于将头结点的地址传入初始化函数。在初始化函数中,使用指向结构体的指针L2接收头结点地址,然后使用malloc函数,为头结点分配空间。 请问,以上理解正确吗?
  • C语言对单链表初始化、判断是否为空、表长、输出表、单链表的头插法、单链表的尾插法、插入元素、生成新节点、删除元素、查找元素、修改元素、清空表、释放表空间。
  • 在操作单链表之前需要对其进行初始化之类的工作,下面通过具体的代码来说明其初始化方法: 1 #include<iostream> 2 using namespace std; 3 typedef struct Listnode 4 { 5 int data; 6 struct ...
  • 单链表的定义、初始化、增删改查伪代码 //单链表定义 typedef struct LNode{ int data; struct LNode *next; }LNode, *LinkList; //LNode强调节点;LinkList强调链表 struct LNode *p = (struct LNode*)malloc...
  • 单链表是最基础的数据结构,由于之前专业课听得一脸懵,所以现在重新学习数据结构。学好单链表也是为了之后的学习打基础。
  • 什么是单链表 单链表是一种链式存取的数据结构,用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的,每个结点的构成:元素(数据元素的映象) + 指针(指示后继元素存储位置),元素就是...
  • 单链表的实现头文件heads.h头文件means.h测试文件main.cpp IDE:Visual Studio 2019 声明:为了方便书写代码,用到了C++的引用调用特性和iostream作为输入输出,读者可以使用指针调用和scanf_s和print语句实现相同...
  • Python 单链表初始化、赋值、输出

    千次阅读 2019-08-16 17:43:51
    1.定义一个结点类 val next class ListNode: def __init__(self, x): ...2.定义单链表 :(单链表是由一个一个结点构成)在结点类的基础上 class LinkList: #新建一个头指针为空的链表 def __init__(s...
  • C语言实现单链表初始化、增删查改基本操作引言定义原理优点缺点比较时间上空间上实验过程及结果代码运行结果总结 引言 定义 ★★★单链表是线性表的链式存取的数据结构,用一组地址任意的存储单元存放线性表中的...
  • 单链表 之c代码

    千次阅读 2015-08-18 18:30:41
    我们知道数据结构就是数据及其相互关系,包括逻辑...因为单链表只有一个指向后一节点的单一指针域next 所以单链表只能从前往后遍历,而不能从后向前遍历,这就意味着一旦单链表的某一节点丢失 ,后面所有的数据信息都会
  • 单链表初始化,建立,插入,查找,删除。

    千次阅读 多人点赞 2018-04-20 21:05:04
    //单链表初始化,建立,插入,查找,删除。 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef int ElemType; //////////////////////////////////////////// //定义结点类型 ...
  • //////////////////////////////////////////// //单链表初始化,建立,插入,查找,删除。// //Author:Wang Yong // //Date: 2010.8.19 // /////////////////////////////////////
  • C++单链表初始化,插入,删除,反转操作

    万次阅读 多人点赞 2016-02-20 17:18:54
    链表的性质: 1.元素不能随机访问 2.链表只有一个表头 ...链表的初始化: #include using namespace std; class Node{ public: int data; Node *next; Node(int _data){ data = _data; next = NULL

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,065
精华内容 10,426
关键字:

单链表的初始化代码