精华内容
下载资源
问答
  • 步骤 1、尾部插入法创建链表 2、自定义上一个节点、当前节点、下一个节点,遍历反转链表,主要是把当前节点下一个节点设置为当前节点上一个节点; public class ReverseLinkd { private static Node head; ...
    步骤
    • 1、尾部插入法创建链表
    • 2、自定义上一个节点、当前节点、下一个节点,遍历反转链表,主要是把当前节点的下一个节点设置为当前节点的上一个节点;
    public class ReverseLinkd {
    
        private static Node head;
        private static Node tail;
    
        public static void main(String[] args) {
            String[] dataArray = {"1", "2", "3", "4", "5", "6", "7"};
            for(int i = 0; i< dataArray.length; i++) {
                createLinked(dataArray[i]);
            }
            System.out.println("---------------原链表---------------");
            printAll(head);
    
            System.out.println("---------------反转后链表---------------");
            printAll(reverse(head));
    
        }
        //链表反转方法
        public static Node reverse(Node node) {
            if(node == null) {
                System.out.println("空链表");
                return null;
            } else if(node.next == null) {
                System.out.println("链表只有一个节点");
                return node;
            } else {
                Node pre = null;
                Node next = null;
                Node cur = node;
                while(cur != null) {
                    //记录下一个要操作的节点
                    next = cur.next;
                    //当前节点的下一个节点为当前节点的上一个节点,实现反转
                    cur.next = pre;
                    //上一个节点和当前节点全部后移
                    pre = cur;
                    cur = next;
                }
                return pre;
            }
        }
    
        //创建一个单链表,尾部插入法
        public static void createLinked(String nodeData) {
            Node node = new Node(nodeData);
            if(head == null) {
                head = node;
                tail = head;
            } else {
                tail.next = node;
                tail = node;
            }
        }
    
        //打印链表
        public static void printAll(Node node) {
            if(node == null) {
                System.out.println("空链表");
            } else {
                while(node != null) {
                    System.out.print(node.getData() + "-->");
                    node = node.next;
                }
            }
            System.out.println();
        }
    
    
        //定义单链表
        static class Node{
            public String data;
            public Node next;
    
            public Node(String data) {
                this.data = data;
            }
    
            public String getData() {
                return data;
            }
    
            public void setData(String data) {
                this.data = data;
            }
    
            public Node getNext() {
                return next;
            }
    
            public void setNext(Node next) {
                this.next = next;
            }
        }
    }
    
    展开全文
  • 创建单链表有两种方式:头插法与尾插法 尾插法是在链表结尾增加新节点 头插法是插入头节点后面,剩余节点前面 2 尾插法 步骤 需要新建一个尾节点tail,(初始head=tail) 创建新节点new,连接到尾节点,...

    1 简述

    创建单链表有两种方式:头插法与尾插法

    尾插法是在链表的结尾增加新的节点

    头插法是插入头节点后面,剩余节点前面

    2 尾插法

    步骤

    1. 需要新建一个尾节点tail,(初始head=tail)
    2. 创建新的节点new,连接到尾节点,tail.next = new
    3. 尾节点后移,tail = new

    Q:为什么要加新的节点?

    A:因为head的节点不能动,增加新的节点让其移动,让其指向最后一个节点,便于连接tail.next=new

    返回创建好的列表一般返回head,如果让head后移,那最后返回head的结果只有最后一个节点

    3 头插法

    步骤

    1. new.next = head.next
    2. head.next=new

    这种做法实际上实现了逆序

    假如节点为: 1 2 3

    创建过程:

    • head -> 1
    • head ->2 ->1
    • head ->3 ->2 ->1

    返回头节点的结果是3 ->2 ->1,原来是 1 2 3,实现了逆序

    参考https://blog.csdn.net/joob000/article/details/81196165

    展开全文
  • 单链表的创建以及操作 ...创建链表的步骤: 1.先创建出结构体变量 struct Node { int data; //数据域 struct Node* next; //指针域 }; 2.创建表头 struct Node* creatList() { //定义一个指针变量通过动态内存申请

    单链表的创建以及操作

    1.单链表的概念 :
    单链表的存储结构为线性非连续型,相比于数组极大的减少了空间的利用率,通过指针指向下一个结点让链表最大的利用了空间

    以下是链表的实现原理:

    在这里插入图片描述
    链表的每个结点都包含一个数据域和一个指针域
    创建链表的步骤:
    1.先创建出结构体变量

    struct Node
    {
      int data;   //数据域
      struct Node* next; //指针域
    }

    2.创建表头

    struct Node* creatList()
    { 
       //定义一个指针变量通过动态内存申请将指针变量变为结点 
      struct Node* headNode=(struct Node*)malloc(sizeof(struct Node));
      headNode=NULL;   //建立一个空表
      return headNode; 
    }
    

    3.创建结点

    struct Node* creatNode(int data)
    {  
      //为新结点动态内存申请空间
      struct Node* newNode=(struct Node*)malloc(sizeof(struct Node));
      newNode->data=data;   //将形参传递的数据传入新结点内
      newNode->next=NULL;   //将新结点的指针域为空
      return newNode;
    }
    

    4.打印链表
    打印以headNode为头结点的链表

    void printList(struct Node* headNode)
    { 
      //因为第一个结点内不存放数据,所以从第二个结点开始打印
      //定义一个新的指针变量指向第二个结点
      struct Node* pMove=headNode->next;
      while(pMove!=NULL)
      {
        printf("data=%d\n",pMove->data);
        pMove=pMove->next;
      }   
      printf("\n");
    }
    

    链表功能的实现

    链表的创建操作已经完成了,现在我们来完善链表的功能
    链表的功能包括了增,删, 查 ,改

    1.插入结点(表头法)
    在这里插入图片描述

    void InsertNode(struct Node* headNode)
    { 
       //调用创建结点函数来创建新结点
      struct Node* newNode=creatNode(data);
      newNode->next=headNode->next;
      headNode->next=newNode;
    }
    

    通过图片不难看出头插法是如何实现的

    2.插入结点(尾插法)
    在这里插入图片描述

    void InsertNode(struct Node* headNode)
    { 
      struct Node* newNode=creatNode(data);
      //定义一个临时变量指向表头
      struct Node* temp=headNode;
      if(headNode==NULL)   //如果头结点为空
      {  
        //如果headNode为空则将newNode设为第一个新结点
       headNode=newNode;
       newNode->=NULL;
      }
      else
      {  
         //最终让temp指向尾结点
        while(temp->next != NULL)
        {  
          temp=temp->next;
        }
        //将尾结点temp的next设为newNode,即将newNdoe设为尾结点
        temp->next=newNode;
      }
    }
    

    3.查找结点

    void SeekNode(struct Node* headNode,int data)
    { 
      //创建一个指针变量指向第二个结点
      struct Node* pMove=headNode->next;
      if(pMove==NULL)
      {
        printf("数据为空,无法查找!\n");
      }
      while(pMove != NULL)
      {
         if(pMove->data == data)
         {
           printf("数据存在!\n");
           printf("data=%d\n",pMove->data);
         }
         pMove=pMove->data;
      }
         printf("\n");
    }
    

    4.指定位置删除结点

    void DeletedNode(struct Node* headNode,int posData)
    {
    	struct Node* posNode = headNode->next;
    	struct Node* posFrotNode = headNode;
    	if (posNode == NULL)
    	{
    		printf("数据为空,无法删除!\n");
    	}
    	while (posNode->data != posData)
    	{
    		posFrotNode = posNode;   //将指定位置的前面到达指定位置
    		posNode = posFrotNode->next;
    		if (posNode == NULL)
    		{
    			printf("未找到指定位置,无法删除!\n");
    		}
    	}
    	posFrotNode->next = posNode->next;
    	free(posNode);
    }
    
    展开全文
  • 单链表逆序

    2016-03-04 17:59:53
    单链表逆序 步骤: 1. 初始化单链表 2. 动态创建单链表(插入操作) 3. 逆序算法处理 4. 打印输出 5. 释放动态创建单链表
  • 创建及输出动态单链表1.尾插法无头单链表❤2.尾插法有头单链表3.头插法无头单链表4.头插法有头单链表 一、链表是什么? 官方解释: 链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。...


    一、链表是什么?

    官方解释:

    链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分:一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。

    二、使用步骤

    1.定义结构体类型

    代码如下:

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

    2.创建及输出动态单链表

    创建链表之前需要了解动态单链表的几种形式,有头或无头,尾插法还是头插法,通过多次创建链表,个人更喜欢使用尾插法来创建一个无头单链表。

    有头和无头的区别就在于第一个节点是否有数据域。

    头插法和尾插法也就顾名思义,头插法每次都是在头节点后插入一个节点,而尾插法则是在链表末尾插入一个节点。所以在顺序输出的情况下,头插法创建的单链表是逆序输出的,而尾插法就是顺序输出。

    1.尾插法无头单链表❤

    int main()
    {
    	struct node* p1, * p2, * head;
    	head = NULL;
    	p1 = p2 = (struct node*)malloc(LEN);
    	if(p1==NULL) exit(1);
    	scanf_s("%d", &p1->num);
    	int count = 0;
    	do
    	{
    		if (count == 0) head = p1;
    		else p2->next = p1;
    		p2 = p1;
    		p1 = (struct node*)malloc(LEN);
    		if(p1==NULL) exit(1);
    		count++;
    		scanf_s("%d", &p1->num);
    	} while (p1->num != 0);
    	p2->next = NULL;
    	free(p1);
    	struct node* p;
    	p = head;
    	while (p != NULL)
    	{
    		printf("%d ", p->num);
    		p = p->next;
    	}
    	return 0;
    }
    

    2.尾插法有头单链表

    int main()
    {
    	struct node* head, * p1, * p2;
    	p1 = p2 = (struct node*)malloc(LEN);
    	if(p1==NULL) exit(1);
    	head = (struct node*)malloc(LEN);
    	if(head==NULL) exit(1);
    	scanf_s("%d", &p1->num);
    	int count = 0;
    	do
    	{
    		if (count == 0) head->next = p1;
    		else p2->next = p1;
    		p2 = p1;
    		count++;
    		p1 = (struct node*)malloc(LEN);
    		if(p1==NULL) exit(1);
    		scanf_s("%d", &p1->num);
    	} while (p1->num != 0);
    	p2->next = NULL;
    	free(p1);
    	struct node* p;
    	p = head->next;
    	while (p != NULL)
    	{
    		printf("%d ", p->num);
    		p = p->next;
    	}
    	return 0;
    }
    

    3.头插法无头单链表

    int main()
    {
    	struct node* head, * p1;
    	head = NULL;
    	p1 = (struct node*)malloc(LEN);
    	if(p1==NULL) exit(1);
    	scanf_s("%d", &p1->num);
    	while (p1->num != 0)
    	{
    		p1->next = head;
    		head = p1;
    		p1 = (struct node*)malloc(LEN);
    		if(p1==NULL) exit(1);
    		scanf_s("%d", &p1->num);
    	}
    	free(p1);
    	struct node* p;
    	p = head;
    	while (p != NULL)
    	{
    		printf("%d ", p->num);
    		p = p->next;
    	}
    	return 0;
    }
    

    4.头插法有头单链表

    int main()
    {
    	struct node* head, * p1;
    	head = (struct node*)malloc(LEN);
    	if(head==NULL) exit(1);
    	head->next = NULL;
    	int date;
    	scanf_s("%d", &date);
    	while (date != 0)
    	{
    		p1 = (struct node*)malloc(LEN);
    		if(p1==NULL) exit(1);
    		p1->num = date;
    		p1->next = head->next;
    		head->next = p1;
    		scanf_s("%d", &date);
    	}
    	struct node* p;
    	p = head->next;
    	while (p != NULL)
    	{
    		printf("%d ", p->num);
    		p = p->next;
    	}
    	return 0;
    }
    

    以上链表输入时都已0为结束标志,当检测到输入的值为0时,链表创建完毕。


    以上链表的创建都是根据自己的思想创建的,所以可能会出现错误,希望大佬们可以指点一二😊

    展开全文
  • Java-单链表的逆置

    2019-07-26 19:05:12
    单链表逆置步骤: 1.判断首结点是否为空,为空不需要逆置 2.如果只有一个结点,也不需要逆置 3.需要逆置就先创建一个新链表,然后把原链表依次头插到新链表即可 时间复杂度:O(n) 单链表逆置程序: ...
  • 1、定义单链表类型并动态创建单链表; 2、实现单链表的取元素操作、插入操作和删除操作; 3、实现输出单链表中各元素值的操作; 4、将单链表中的最小元素移到最前面。 实验步骤 1、定义单链表节点类; ...
  • 单链表的操作(C++)

    2020-05-12 21:18:45
    单链表(C++)(实验2): #include <iostream> using namespace std;...//创建单链表(头插法) void CreateList_H(LNode *L, int n){ //n为需要插入元素个数 //步骤1:初始化头结点 L->data = 0;
  • 一、实验目的 巩固线性表数据结构存储方法和相关操作,学会针对具体应用,使用线性表相关知识来解决具体问题。...三、实验步骤 1、依据实验内容分别说明实验程序中用到数据类型定义 SeqList(T...
  • 9-2 单链表的实现

    2020-10-21 21:05:59
    9.2.1 单链表的节点构成 (1)链表是由节点组成的,节点中包含:有效数据和指针。 (2)定义的struct ...(2)使用堆内存来创建一个链表节点的步骤:1、申请堆内存,大小为一个节点的大小(检查申请结果是否正确);
  • 创建表其实就是元素插入,就是多了几个步骤) typedef struct Node{ ElemType data;//数据域 struct Node *next;//指针域 }Node; typedef struct Node *LinkList; /*n个元素,在主函数也
  • 上一篇主要介绍了单链表的基本知识,接着上一篇,本篇将用一些基本的练习题巩固链表知识,创建链表的方法千千万,牢记原理和步骤图为上策 题目一 #include<iostream> using namespace std; struct node { ...
  • C语言的单链表分割

    2019-10-21 23:12:38
    已知链表头指针head与数值x,将所有小于x节点放在大于或等于x 节点前,且保持这些节点原来...创建一个less_ptr,负责对less端链表进行维护 创建一个more_ptr,负责对more端链表进行维护 最终进行less...
  • 步骤: 1)创建ListNode类 class ListNode: def __init__(self, x): self.val = x ...2)创建单链表类 可参考[python单链表](https://blog.csdn.net/qq_36512295/article/details/98514687) class Si...
  • 二、单链表的头插与尾插 只要懂了单链表的头插与尾插,双链表的就非常好理解了。对于这,我觉得用图形解释没一步是最好的方法。附上我自己对头插与尾插的理解。1.头插法在我学的过程中最难以理解的是s->...
  • 线性表之单链表

    2021-01-07 16:11:35
    文章目录头文件一、单链表的创建头插法尾插法二、使用步骤1.引入库2.读入数据总结 头文件 提示:这里可以添加本文要记录的大概内容: 例如:随着人工智能的不断发展,机器学习这门技术也越来越重要,很多人都开启了...
  • 创建一个临时头节点,头节点每次指向headA 或者 headB较小节点 当headA->data 比headB->data小时候,headA当前节点加入临时头节点,同时headA指针向后移动;否则headB加入临时头节点,同时headB指针向...
  • 单链表实验报告

    2012-03-11 21:06:37
    数据结构实验报告:单链表的建立 1.实验目的 (1)了解数据的逻辑结构和数据的存储结构之间的区别与联系; (2)掌握线性表的链式表示和实现方法,特别是插入、删除操作。 (3)掌握运用C语言上机调试线性表的...
  • 1.创建指针p,t均指向head-&gt;next,p表示正在节点,t表示待处理节点 2.将head-&gt;next置为空,即NULL 3.若p指针不为空,执行步骤4,否则跳到步骤8. 4.令t指向下一个节点,即t=t-&gt;next 5...
  • 要求很简单,输入一个链表,反转链表后,输出新链表表头 ...大致步骤如下 首先第一步,创建一个结点类 class Node{ public int id; public Node next; public Node(int id){ this.id=id; ...
  • 思路:因时间复杂度要求为O(N*logN),简单排序(时间复杂度为O(N*N))均不可用,故可以考虑归并排序思想,归并排序对数组操作空间复杂度为O(n),但对链表为O(1),因为每次只在merge函数中创建了一个辅助链表头...
  • 单链表(JAVA实现)

    2020-04-28 00:07:03
    概念:链表是有序的列表,在内存中存储如下: 小结: (1)链表是以节点的方式来存储,是链式存储 ...单链表的创建:(不考虑节点顺序) 示意图: 步骤: 1、先创建一个Head节点,作用就是表示单链表的头 2、...
  • 单链表 文章目录单链表一、什么是单链表?二、实现原理二、使用步骤...1.在创建需要单链表存储对象时,定义一个该对象属性next,用于表示下一个节点。(这样话,doubleEdgedSword.next就可以表示下一个节点) 2
  • 链表介绍 (1)链表是以节点的方式来存储,是链式存储 (2)每个节点包含data域,next域:指向下一个节点 (3)链表的各个节点不一定是连续存储 ...(1)先创建一个head头节点,表示单链表的头 (2)后面每添加...
  • 单链表一、线性表的链式表示1.1、线性表的链式表示的存储结构特点1.2、线性表的链式表示的节点组成1.3、线性表的链式表示的示例二、单链表2.1、定义2.2、单链表的结构示例物理存储示例逻辑示例2.3、创建链表2.3.1、...
  • 建立单链表步骤 定义结点数据存储结构 typedef struct node{ int Element;//结点元素值 struct node *next; //后继结点 }Node; 定义创建新结点函数,该函数为新结点开辟空间并且赋予元素值,最后函数返回...
  • 堆排序、单链表排序

    2020-05-15 16:47:37
    为什么要用堆排序呢?那么复杂,别排序不行么?可能真不行呢 看看这个图就会发现,堆排序时间...创建一个堆 H[0……n-1]; 把堆首(最大值)和堆尾互换; 把堆尺寸缩小 1,并调用 shift_down(0),目的是把新
  • 一、实验内容 1. 通过C语言结构体定义链表结点 2. 定义并实现创建空链表操作 3. 定义并实现向链表指定...1. 在VC++中创建名为LinkList空项目,并将commons.h文件添加到头文件目录中 2. 在工程头文件目录
  • 2,涉及到了单链表的增删改查 3.可以照搬的c++/c的信息管理系统项目中 4.简单易学,完成课设 实现步骤 一, 创建结构体 #include <iostream> using namespace std; //结点类 class node{ public: int data;...
  • 链表相关操作算法

    2012-10-11 21:57:34
    1、创建单链表的步骤  构造一个头结点  构造一个尾节点并初始化使其和头结点相同  尾节点的指针域置空  利用循环创建新节点赋值并挂在尾节点上  新节点指针域置空

空空如也

空空如也

1 2 3 4
收藏数 75
精华内容 30
热门标签
关键字:

创建单链表的步骤