精华内容
下载资源
问答
  • 链表头插法和尾插法
    2021-12-28 16:59:57

    链表

    1.头插法链表

    链表的头插法首先需要定义初始化一个头结点HEAD,每次新的节点插入到链表中都插入到头结点HEAD之后前次插入节点之前具体看以下框图

    请添加图片描述

    1.具体的操作如下:

    数据结构data_demo
    struct data_demo {
        struct data_demo *next;
    }
    1.首先创建一个头结点HEAD,并且HEAD的下一个节点指向空
    struct data_demo *HEAD;
    HEAD->next = NULL;
    2.创建一个新的node1插入到链表中
    struct data_demo *node1;
    node1->next = HEAD->next;   //将HEAD->next的指向赋值给node1->next
    HEAD->next = node1;			//HEAD->next指向node1节点
    3.创建一个新的node2插入到链表中
    struct data_demo *node2;
    node2->next = HEAD->next;	//将HEAD->next的指向赋值给node2->next
    HEAD->next = node2;			//HEAD->next指向node2节点
    为什么要先执行node2->next = HEAD->next再执行HEAD->next = node2呢,如果我们先执行HEAD->next = node2后,我们就找不到之前
    头结点指向的后驱节点吗,所以我们需要先把头结点指向的后驱节点先赋值给当前node2,然后再把HEAD节点的next指向node2
    
    

    2.头插法代码实现例子

    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct list_demo {
    	int data;
    	struct list_demo *next;
    }List;
    
    void InitHeadList(int i, List *HEAD)
    {
    	List *node = NULL;
    	for(i = 0;i < 3; i++)
    	{
    		node = (List*)malloc(sizeof(List));
    		node->data = i;
    		node->next = NULL;
    		node->next = HEAD->next;
    		HEAD->next = node;
    	}
    }
    void PrintList(List *HEAD)
    {
    	while(HEAD !=NULL)
    	{
    		printf("node data:%d\n", HEAD->data);
    		HEAD = HEAD->next;
    	}
    }
    int main(void)
    {
    	int i = 3;
    	//创建头结点
    	List HEAD;
    	HEAD.data = 200;
    	HEAD.next = NULL;
    	InitHeadList(i, &HEAD);
    	PrintList(&HEAD);
    
    	return 0;
    }
    
    执行的结果:
    node data:200
    node data:2
    node data:1
    node data:0
    

    2.链表的尾插法

    链表的尾插法的实现是把每次新创建的节点都插入到链表的尾节点后,因此我们需要创建一个尾部指针tail来记录当前的位置,每次有新的节点插入

    都需要把这个指针指向当前插入的节点

    请添加图片描述

    1.具体操作如下

    数据结构data_demo
    struct data_demo {
        struct data_demo *next;
    }
    1.创建头结点和尾部指针,并且把tail指向HAED
    struct data_demo *HEAD, *tail;
    HEAD->next = NULL;
    tail = HEAD;
    2.创建node1节点,使用尾插法插入到HEAD后
    struct data_demo *node1;
    tail->next = node1;
    tail = node1;
    tail ->next = NULL;
    3.创建node2节点,插入到链表中
    struct data_demo *node2;
    tail->next = node2;
    tail = node2;
    tail ->next = NULL;
    

    2.尾插法实现例子

    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct list_demo {
    	int data;
    	struct list_demo *next;
    }List;
    
    void InitHeadList(int num, List *HEAD)
    {
    	List *node = NULL;
    	int i = 0;
    
    	for(i = 0;i < num; i++)
    	{
    		node = (List*)malloc(sizeof(List));
    		node->data = i;
    		//node->next = NULL;
    		node->next = HEAD->next;
    		HEAD->next = node;
    	}
    
    }
    void InitTailList(int num, List *HEAD)
    {
    	List *node = NULL;
    	List *tail = HEAD;
    	int i = 0;
    
    	for(i = 0; i < num; i++)
    	{
    		node = (List*)malloc(sizeof(List));
    		node->data = i;
    		tail->next = node;
    		tail = node;
    	}
    	tail->next = NULL;
    
    }
    void PrintList(List *HEAD)
    {
    	while(HEAD !=NULL)
    	{
    		printf("node data:%d\n", HEAD->data);
    		HEAD = HEAD->next;
    	}
    }
    
    int main(void)
    {
    	int i = 3;
    
    	//创建头结点
    	List HEAD;
    	HEAD.data = 200;
    	HEAD.next = NULL;
    	//InitHeadList(i, &HEAD);
    	InitTailList(i, &HEAD);
    	PrintList(&HEAD);
    	
    	return 0;
    }
    执行结果:
    node data:200
    node data:0
    node data:1
    node data:2
    
    
    
    更多相关内容
  • 链表头插法和尾插法

    2021-12-21 00:12:10
    文章目录1.头插法2.尾插法 1.头插法 #include <stdio.h> #include <...//==============头插法建立链表========================== struct LNode *CreatLNode(){ int x; int LNode_len=0;

    文章目录

    1.头插法

    #include <stdio.h>
    #include <stdlib.h>
    typedef struct LNode{
    int data;
    struct LNode *next;
    }LNode;
    //==============头插法建立链表==========================
    struct LNode *CreatLNode(){
        int x;
        int LNode_len=0;                          //计算链表长度
        LNode *head;
        LNode *s;
        //head->next=NULL;                          //初始为空链表
        head=(struct LNode*)malloc(sizeof(struct LNode));//创建头结点
        printf("请输入数据(9999结束)\n");
        scanf("%d",&x);
        while(x!=9999){
            s=(struct LNode*)malloc(sizeof(struct LNode));
            s->data=x;
            s->next=head->next;
            head->next=s;
            LNode_len++;
            head->data=LNode_len;
            scanf("%d",&x);
        }
        return head;
    };
    //==============头插法建立链表==========================
    
    
    
    //输出
    LNode print(LNode *head){
    LNode *p=head->next;
    int i;
    for(i=0;i<head->data;i++){
         printf("%3d",p->data);
        p=p->next;
    
    }
    }
    int main()
    {
       LNode *p;
       p=CreatLNode();
       print(p);
        return 0;
    }
    
    

    在这里插入图片描述

    2.尾插法

    #include <stdio.h>
    #include <stdlib.h>
    typedef struct LNode{
    int data;
    struct LNode *next;
    }LNode;
    //==============尾插法建立链表==========================
    struct LNode *CreatLNode(){
        LNode *head;    
        LNode *p1,*p2;
        int LNode_len=0;
        int x;
        head=(struct LNode*)malloc(sizeof(struct LNode));//建立头结点
        p1=p2=head;    //让p1和p2都指向头结点
        printf("请输入数据(9999结束)\n");
        scanf("%d",&x);         //输入数据
        while(x!=9999){
            p1=(struct LNode*)malloc(sizeof(struct LNode));  //再让p1建立一个新结点把x值放进去(此时头结点没有放值)
            p1->data=x;
            p2->next=p1; //p2指向p1
            p2=p1;       //p2在等于p1又使p1和p2又指向了同一个。。。重复。。。
            LNode_len++;
            head->data=LNode_len;
            scanf("%d",&x);
        }
        p1->next=NULL;
        return head;
    };
    //==============尾插法建立链表==========================
    
    
    
    //输出
    LNode print(LNode *head){
    LNode *p=head->next;
    int i;
    for(i=0;i<head->data;i++){
         printf("%3d",p->data);
        p=p->next;
    
    }
    }
    int main()
    {
       LNode *p;
       p=CreatLNode();
       print(p);
        return 0;
    }
    
    

    在这里插入图片描述

    展开全文
  • java链表头插法和尾插法

    千次阅读 2021-12-04 09:21:35
    头插法看如下代码: public void startAdd(int n) { Listnode listnode=new Listnode(n); listnode.next=head; head=listnode; } 尾插法看如下代码: public void endAdd(int n) { Listnode listnode=...

    链表是由值和地址组成,地址指向下一个值的地址,如下图所示

    我们先定义一个节点类Listnode,里面包含值和地址属性,再通过构造器传值为这个值在内存中申请一块区域。代码如下:

    public class Listnode {
        //链表中一个节点的值属性
    	public int value;
    //链表中一个节点的指针域属性,指向下一个值的地址,因为下一块区域是Listnode类型的所以next也是Listnode类型
    	public Listnode next;
    //构造器,通过值传递给value赋值
    	public Listnode(int n) {
    		this.value=n;
    	}
    	
    }
    

    先创建一个链表类Linklist.

    头插法的思路是定义一个头指针Listnode head=null,把第一个节点的地址通过值传递给它,再创建节点时,让这个新节点的next指针指向旧节点,再让这个头指针指向新节点。如下图:

     

     

    头插法看如下代码:

    public void startAdd(int n) {
    //通过new实例给value创建一个新节点
    		Listnode listnode=new Listnode(n);
    //让新节点的下一个指向旧节点,因为旧节点通过值传递的方式传给head
    		listnode.next=head;
    //新节点通过值传递的方式传给head
    		head=listnode;
    	}

    尾插法的思路是先定义一个游标temp,游标从头结点head开始,如果它的next指针域不是null,就让游标指向下一个,直到游标指向next指针域为null,然后在这个节点后插入新的节点。

     

    尾插法代码如下:

    public void endAdd(int n) {
    //通过new实例给value创建一个新节点
    		Listnode listnode=new Listnode(n);
    //判断头结点是否为空,空就通过值传递把新节点传给头节点,直接return不再走下面的流程
    		if(head==null) {
    			head=listnode;
    			return;
    		}
    //定义游标
    		Listnode temp=head;
    //通过游标判断此节点的next指针域是否为空,不是就指向下一个节点
    		while(temp.next!=null) {
    			temp=temp.next;
    		}
    //此时指向最后一个节点,让它的next指针域指向新节点
    		temp.next=listnode;
    	}

    总体代码如下:

    public class Linklist {
    //定义头指针
    	Listnode head;
    //头插法
    	public void endAdd(int n) {
    		Listnode listnode=new Listnode(n);
    		if(head==null) {
    			head=listnode;
    			return;
    		}
    		Listnode temp=head;
    		while(temp.next!=null) {
    			temp=temp.next;
    		}
    		temp.next=listnode;
    	}
    //尾插法
    	public void startAdd(int n) {
    		Listnode listnode=new Listnode(n);
    		listnode.next=head;
    		head=listnode;
    	}
    //把添加的值打印的方法
    	public void printLink() {
    		Listnode temp=head;
    		while(temp!=null) {
    			System.out.print(temp.value+" ");
    			temp=temp.next;
    		}
    	}
    //获取添加多少数的方法
    	public void getLength() {
    		int count=0;
    		if(head==null) {
    			System.out.println(0);
    			return;
    		}
    		Listnode temp=head;
    		while(temp!=null) {
    			count++;
    			temp=temp.next;
    		}
    		System.out.println("你添加了"+count+"个数");
    	}
    }

    通过test类来测试一下:

    public class Test {
    	public static void main(String[] args) {
    		Linklist linklist=new Linklist();
    		linklist.endAdd(1);
    		linklist.endAdd(2);
    		linklist.endAdd(3);
    		linklist.endAdd(4);
    		linklist.startAdd(2);
    		linklist.startAdd(3);
    		linklist.startAdd(4);
    		linklist.printLink();
    		linklist.getLength();
    	}
    }
    

    结果如下:

     

    展开全文
  • 头插法三步走:​ ①:创建新节点 ②:给新节点赋地址 ③:给首元节点改地址

    头指针,是一个链表的核心,找到链表就靠它;辅助指针,是增删链表的工具。

    头插法:

    所需要的数据有:头指针(head),一个辅助指针(s)

    ①:创建新节点

    文字详解:使用辅助指针s开辟一块空间。

    伪码部分:LinklistCreate(Linklist *a)

    ②:给新节点赋地址

      

    文字详解:令新节点里面的next指针指向首元节点里的next指针。

    伪码部分:s->next=head->next;

    ③:给首元节点改地址

    文字详解:令首元节点里面的next指针指向新节点。

    伪码部分:head->next=s;

    尾插法:

    所需要的数据有:头指针(head),两个辅助指针(s:标记指针)(t:开辟指针)

    ①:创建新节点

    文字详解:

    伪码部分:LinklistCreate(Linklist *a)

    ②:给标记节点赋地址

    文字详解:

    伪码部分:s->next=t;

    ③:移动标记指针

    文字详解:

    伪码部分:s=t;

    展开全文
  • } } 用用头插法和尾插法完成链表的初始化 头插法实现相对比较简单 尾插法实现因为head不能变,所以需要一个辅助节点tem; 画图会比较容易理解。 public class LeetCode_206 { public static void main(String[] args...
  • 头插法 头插法是用结构体数组来实现的。 具体的思路是:在建立邻接表时,记录的不是点而是边,对于每一个点所对应的邻接表都是以栈的形式存储的,也就是说先添加的边在遍历时后取出,除此以外,所有的边用一个结构体...
  • 下面通过图像简要示意链表的头插法和尾插法 1、头插法 代码示意: #include<stdio.h> #include<stdlib.h> struct stu_node{ int num; struct stu_node *next; }; int main() { struct stu_...
  • java单向链表
  • 链表头插法尾插法(简易图解代码)

    万次阅读 多人点赞 2021-11-04 12:15:38
    头插法 定义:输入的数据次序生成的链表节点次序相反,例如:按1,2,3顺序进行头插之后,最终排序却变成了3,2,1。简而言之就是逆序插入。 定义图解: 代码图解: 代码:(使用头插法建立单链表) Linklist head_...
  • 图解java链表 头插法 尾插法
  • 头插法 class Node{ int value; Node next; @Override public String toString() { return "Node{" + "value=" + value + ", next=" + next + '}'; } } public class Test { public static vo
  • 头插法建立的表,得到的链表的顺序实际的插入顺序是相反的,比如插入的顺序是1,2,3,4,5,那么得到的顺序是5,4,3,2,1。整个插入过程入下图所示, 二、尾插法 尾插法得到的链表数值顺序是按照插入顺序的,比如...
  • 因而,下面代码主要实现单链表的创建(头插法和尾插法),增加,删除,清空以及遍历功能。 #include <iostream> #include <string> using namespace std; typedef struct{ int num; string name; }...
  • 链表尾插法和头插法创建 typedef struct my { int data; struct my *next, *prior; }my1; my1 *dlist1() //尾插法建立双向链表的函数// { my1 *head, *q, *p; int n, a,i; head = (my1*)malloc(sizeof(my1)); ...
  • C语言单链表的头插法尾插法

    千次阅读 2021-12-14 22:01:11
    C语言单链表头尾插入门
  • 在建立单链表的时候 头插法尾插法时最最常见的,话不多说直接进入正题 头插法 的两种方式 顾名思义 从链表的开头开始插入结点——先进后出。 在头节点之后插入节点 新插入的结点指向上一次插入的结点 方法一 ...
  • 头插法和尾插法

    千次阅读 2020-03-16 15:32:49
    链表的头插法和尾插法 表结构的声明 typedef int ElemType; typedef struct node //定义链表的结点的结构 { ElemType data;//定义链表的数据域 struct node *next;//定义链表中的指针域 }slink; 头插法 1,从一个...
  • 链表 ,头插法,尾插法

    2018-07-31 23:04:23
    数据的分类: 1、物理结构:数据所在内存的表现(顺序结构、链式结构) ... 线性:节点之间存在1:1的联系(每一个节点只有一个直接前驱一个直接 后驱) 通过物理区来表现线表: 1、顺序线性表 2、链式...
  • 头插法尾插法中,头插法讲究的是将新结点连接在头结点之后,第一个数据点之前。逆序输出。尾插法讲究的是链接到尾结点之后,所得链表称为顺序链表。因此,紧扣住定义,将代码多次演练即可掌握,实在是不可多得的...
  • ​ 首先讲述了我自己在动态实现数据结构的时候遇到的大坑结构体指针问题,随后就是头插法和尾插法的介绍。 结构体指针 引言 ​ 首先需要讲述的是一个让我改了一天半的bug。实际上半天的时候就已经发现了二级指针的...
  • 头插法:生成的链表和我输入的数据顺序是相反的,所以又称逆序建表法。 例如:e d c b a 建成的链表就是  head->a->b->c->d->e 算法步骤: ①创建一个只有头结点的空链表。 ②根据待创建链表的元素个数n,循环n次...
  • 准备重新复习一遍数据结构了,基础的东西不能丢呀。当作复习笔记一些思考来写。...数组和链表的区别(记得那会儿校招找工作的时候也考了) 数组静态分配内存,数组动态分配内存 数组在内存中连续,
  • 链表能够很大程度的节省我们系统的存储空间,因为链表的存储位置是任意的,想要找到下一块内容,是通过本块内容中记录下一块内容的地址空间,由此达到一个连续的链表,牺牲空间来换取逻辑相连,与数组相比各有利弊。
  • 一、单链表的头插法头插法原理图: 代码演示头插法: package com.fan.linkedlist; public class SingleLInkedListDemo3 { public static void main(String[] args) { SingleLInkedList3 singlelist3 = new ...
  • 头插法简介头插法建立单链表的算法虽然简单,但生成的链表中结点的次序输入数据的顺序不一致。若希望两者次序一致,可采用尾插法。该方法是将新结点插入到当前链表的表尾上,为此必须增加一个尾指针r,使其始终指向...
  • //头插法 foreach (pheader);//遍历 return 0; } int *jjd1(){ lin *pheader=( lin *)malloc(sizeof( lin)); CHECK(pheader); pheader->pri=NULL;pheader->pnext=NULL; int val=0; lin *pt= pheader; while(1){ ...
  • 1. 头插法2. 尾插法 ...List HeadCreatList() //头插法建立链表 { List L = (List)malloc(sizeof(PtrToNode)); //初始化空表,申请一个头结点 L->Next = NULL; //头指针为空 for (int i = 0; .
  • C++单链表的创建:头插法尾插法

    万次阅读 2018-10-29 15:53:46
    链表是指用若干个结点连接在一起用于存储数据的数据结构,这些节结在物理内存上是离散的,但是在逻辑存储上是连续的。每个节结由两部分组成,如图1,第一部分用于存储数据,第二部分是一个指针,指针类型与结点类型...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,526
精华内容 9,810
关键字:

链表头插法和尾插法