精华内容
下载资源
问答
  • 插法插法是用结构体数组来实现的。 具体的思路是:在建立邻接表时,记录的不是点而是边,对于每一个点所对应的邻接表都是以栈的形式存储的,也就是说先添加的边在遍历时后取出,除此以外,所有的边用一个结构体...
  • 单链表头插法和尾插法的实现

    千次阅读 2018-08-07 21:14:41
    #ifndef _LINKLIST_H #define _LINKLIST_H #define FAILURE 10000 #define SUCCESS 10001 #define TRUE 10002 #define FALSE 10003 typedef int ElemType;... int LinkInsert(Node *... 尾插法:      
    #ifndef _LINKLIST_H
    #define _LINKLIST_H
    
    #define FAILURE    10000
    #define SUCCESS    10001
    #define TRUE       10002
    #define FALSE      10003
    typedef int ElemType; 
    
    struct node
    {
        ElemType data;   //数据域
        struct node *next;   //指针域
    };
    
    typedef struct node Node;
    #endif
    #include <stdio.h>
    #include <stdlib.h>
    int LinkInit(Node **l)      //初始化
    {
        *l=(Node *)malloc(sizeof(Node)*1);
        if(NULL == *l)
        {
            return FAILURE;
        }
        (*l)->next=NULL;
        return SUCCESS;
    }
    /*
       int LinkInsert(Node *l,ElemType e)     //头插法 
       {
       Node *p=l;
    
       if(NULL == l)
       {
       return FAILURE;
       }
       Node *q = (Node *)malloc(sizeof(Node)*1);  //要插入的
       q->data=e;
       Node *t = p->next;
       p->next = q;
       q->next = t;
    
       }
       */
    
    
    
    
    int LinkInsert(Node *l,ElemType e)     //头插法
    {
        Node *p=l;
        int k=1;
        if(NULL == l)
        {
            return FAILURE;
        }
        Node *q=(Node *)malloc(sizeof(Node)*1);  //要插入的
        while(k < 1 || p == NULL)
        {
            p = p->next;
            k++;
        }
        if(k > 1 || p == NULL)
        {
            return FAILURE;
        }
        if(NULL == q)
        {
            return FAILURE;
        }
        q->data = e;
        Node *t = p->next;
        p->next = q;
        q->next = t;
    
    }
    int LinkTraverse(Node *l,void (*p)(ElemType))
    {
        if(NULL == l)
        {
            return FAILURE;
        }
        Node *q = l;
        while(q->next)
        {
            q = q->next;
            p(q->data);
        }
        return SUCCESS;
    }
    
    void print(ElemType e)
    {
        printf("%d ", e);
    }
    
    int main()
    {
        int ret, i;
        srand(time(NULL));
        Node *first = NULL;   //头指针
    
        srand(time(NULL));
    
        ret = LinkInit(&first);
        if (ret == FAILURE)
        {
            printf("Init Failure!\n");
        }
        else
        {
            printf("Init Success!\n");
        }
    
        for (i = 0; i < 10; i++)
        {
            ret = LinkInsert(first, rand() % 20);
            if (ret == FAILURE)
            {
                printf("Insert Failure!\n");
            }
            else
            {
                printf("Insert Success!\n");
            }
        }
    
        ret = LinkTraverse(first, print);
        if (ret == FAILURE)
        {
            printf("\nTraverse Falure!\n");
        }
        else
        {
            printf("\nTraverse Success!\n");
        }
        return 0;
    }
    

    头插法: 

     尾插法:

     

     

     

    展开全文
  • 单链表头插法和尾插法的实现 单链表的功能特点主要用于频繁增删数据,而不适宜查找。因而,下面代码主要实现单链表的创建(头插法和尾插法),增加,删除,清空以及遍历功能。 #include <iostream> #include &...

    单链表头插法和尾插法的实现(带有头结点)

    单链表的功能特点主要用于频繁增删数据,而不适宜查找。因而,下面代码主要实现单链表的创建(头插法和尾插法),增加,删除,清空以及遍历功能。

    #include <iostream>
    #include <string>
    using namespace std;
    
    typedef struct{
    	int num;
    	string name;
    }ElemType;
    
    typedef struct Node{
    	ElemType data;
    	Node* next;
    }Node,*LList;
    
    struct LinkList{
    	LList LL;
    	int length;
    };
    
    void InitLinkList(LinkList &L){		//初始化
    	L.LL = new Node();
    	L.LL->next = NULL;
    	L.length = 0;
    }
    
    int CreateLinkList_head(LinkList &L,int n){		//头插法
    	if(n > 0){
    		cout << "请输入学生的学号和姓名:" << endl;
    		for(int i = 0;i < n;i++){
    			Node* p = new Node();
    			cin >> p->data.num >> p->data.name;
    			p->next = L.LL->next;
    			L.LL->next = p;
    			L.length++;
    		}
    		return 1;
    	}
    	return 0;
    }
    
    int CreateLinkList_tail(LinkList &L,int n){		//尾插法
    	if(n > 0){
    		cout << "请输入学生的学号和姓名:" << endl;
    		Node* temp = L.LL;
    		for(int i = 0;i < n;i++){
    			Node* p = new Node();
    			cin >> p->data.num >> p->data.name;
    			p->next = NULL;
    			temp->next = p;
    			temp = p;
    			L.length++;
    		}
    		return 1;
    	}
    	return 0;
    }
    
    int LinkList_Length(LinkList L){		//链表长度
    	return L.length;
    }
    
    void Insert_LinkList(LinkList &L,int i){		//在i位置插入数据项
    	if(i > 0 && i <= L.length+1){
    		Node* p = L.LL->next;
    		if(i == 1){		//分2种情况:在首元节点插入和其他节点插入
    			Node* q = new Node();
    			cout << "请输入学生的学号和姓名:" << endl;
    			cin >> q->data.num >> q->data.name;
    			q->next = L.LL->next;
    			L.LL->next = q;
    			L.length++;
    			cout << "信息插入成功!" << endl;
    		}
    		else{
    			int j = 1;
    			while(j < i-1){
    				p = p->next;
    				j++;
    			}
    			Node* q = new Node();
    			cout << "请输入学生的学号和姓名:" << endl;
    			cin >> q->data.num >> q->data.name;
    			q->next = p->next;
    			p->next = q;
    			L.length++;
    			cout << "信息插入成功!" << endl;
    		}
    	}
    	else
    		cout << "信息插入失败!" << endl;
    }
    
    void Delete_LinkList(LinkList &L,int i){		//删除i位置的数据项
    	if(i > 0 && i <= L.length){
    		if(i == 1){		//分2种情况:在首元节点删除和其他节点删除
    			Node *p = L.LL->next;
    			L.LL->next = p->next;
    			delete p;
    			L.length--;
    			cout << "信息删除成功!" << endl;
    		}
    		else{
    			Node* p = L.LL->next;
    			int j = 1;
    			while(j < i-1){
    				p = p->next;
    				j++;
    			}
    			Node* q = p->next;
    			p->next = q->next;
    			delete q;
    			L.length--;
    			cout << "信息删除成功!" << endl;
    		}
    	}
    	else
    		cout << "信息删除失败!" << endl;
    }
    
    void Print_LinkList(LinkList L){		//遍历链表
    	Node* p = L.LL->next;
    	int i = 1;
    	while(p){
    		cout << "第" << i << "名学生信息如下:" << endl;
    		cout << "学号为:" << p->data.num << endl;
    		cout << "姓名为:" << p->data.name << endl;
    		p = p->next;
    		i++;
    	}
    }
    
    void Clear_LinkList(LinkList &L){		//清空链表
    	L.LL->next = NULL;
    	L.length = 0;
    	cout << "链表已清空!" << endl;
    }
    
    int main(){
    	LinkList L;
    	InitLinkList(L);
    	if(CreateLinkList_head(L,2)){
    		cout << "链表(头插法)创建成功!" << endl;
    	}
    	Print_LinkList(L);
    	cout << "链表长度为:" << LinkList_Length(L) << endl;
    	Clear_LinkList(L);
    	cout << "链表长度为:" << LinkList_Length(L) << endl;
    	cout << "-----------------------------------------------------------------" << endl;
    	if(CreateLinkList_tail(L,2)){
    		cout << "链表(尾插法)创建成功!" << endl;
    	}
    	Print_LinkList(L);
    	cout << "链表长度为:" << LinkList_Length(L) << endl;
    	cout << "-----------------------------------------------------------------" << endl;
    	Insert_LinkList(L,3);
    	Print_LinkList(L);
    	cout << "链表长度为:" << LinkList_Length(L) << endl;
    	cout << "-----------------------------------------------------------------" << endl;
    	Delete_LinkList(L,3);
    	Print_LinkList(L);
    	cout << "链表长度为:" << LinkList_Length(L) << endl;
    	system("pause");
    	return 0;
    }
    

    输入输出如下图所示。在这里插入图片描述

    展开全文
  • 单链表头插法和尾插法C/C++代码实现

    千次阅读 2020-05-31 17:22:30
    1,头插法/前插法: 通过将新结点逐个插入链表的头部(头结点之后)来创建链表,每次申请一个新结点,读入相应的数据元素值,然后将新结点插入到头结点之后。 需要注意的是:头插法是逆序的,先插入的反而在后面。 ...

    1,头插法/前插法:

    在这里插入图片描述
    通过将新结点逐个插入链表的头部(头结点之后)来创建链表,每次申请一个新结点,读入相应的数据元素值,然后将新结点插入到头结点之后。

    需要注意的是:头插法是逆序的,先插入的反而在后面。

    代码如下:

    #include<stdio.h>
    #include<stdlib.h>
    
    //书的数据结构
    struct Book
    {
    	char title[128];
    	char author[40];
    	struct Book *next; //指针域
    };
    
    //头插法添加一本书
    void addBook(struct Book **Library)//两个**是定义指向指针的指针,详情见笔记
    {
    	struct Book *book, *temp;  //定义一个新结点的指针
    	book = (struct Book *)malloc(sizeof(struct Book));
    	if (book == NULL)
    	{
    		printf("内存分配失败!\n");
    		exit(1);
    	}
    
    	printf("请输入书名:");
    	scanf("%s", book->title);
    	printf("请输入作者:");
    	scanf("%s", book->author);
    
    	if (*Library != NULL)				//这个条件必须有,要不然下面让一个空指针去找next就会空指针异常!!!!	
    	{
    		temp = *Library;
    		*Library = book;
    		book->next = temp;				
    	}
    	else								//表为空表
    	{
    		*Library = book;				
    		book->next = NULL;
    	}
    
    }
    
    //打印图书信息
    void printLibrary(struct Book *Library)
    {
    	struct Book *book;
    	book = Library;
    	while (book != NULL)
    	{
    		printf("----------------\n");
    		printf("书名:%s\n", book->title);
    		printf("作者:%s\n", book->author);
    		book = book->next;
    	}
    }
    
    //释放
    void releaseLibrary(struct Book **Library)
    {
    	struct Book *temp;
    	while (*Library != NULL)
    	{
    		temp = *Library;
    		*Library = (*Library)->next;	//括号()不能少!!
    		free(temp);
    	}
    }
    
    //无头结点的单链表
    int main()
    {
    	struct Book *Library = NULL; //头指针指向NULL
    	char ch;
    	while (1)
    	{
    		do
    		{
    			printf("请问是否输入一本图书信息(Y/N):");
    			ch = getchar();		//捕获回车键!!
    		} while (ch != 'Y'&& ch != 'N');
    		if (ch == 'Y')
    		{
    			printf("请输入书籍信息:\n");
    			addBook(&Library);	//取头指针的地址
    		}
    		else
    		{
    			break;
    		}
    	}
    	printf("你输入的书籍信息为:\n");
    	printLibrary(Library);
    
    	releaseLibrary(&Library);
    	return 0;
    }
    

    运行结果:

    在这里插入图片描述
    头插法是逆序的,先插入的后输出。

    2,尾插法/后插法:

    在这里插入图片描述
    通过将新结点逐个插入到链表的尾部来创建链表。 同前插法一样, 每次申请一个新结点, 读入相应的数据元素值。 不同的是, 为了使新结点能够插入到表尾, 需要增加一个尾指针 r指向链表的尾结点。

    代码如下:

    #include<stdio.h>
    #include<stdlib.h>
    
    //书的数据结构
    struct Book
    {
    	char title[128];
    	char author[40];
    	struct Book *next; //指针域
    };
    
    //尾插法添加一本书
    void addBook(struct Book **Library)//两个**是定义指向指针的指针,详情见笔记
    {
    	struct Book *book, *temp;		 //定义一个新结点的指针
    	static struct Book *tail;		//定义一个静态指针变量,固定住tail指针的值
    	book = (struct Book *)malloc(sizeof(struct Book));
    	if (book == NULL)
    	{
    		printf("内存分配失败!\n");
    		exit(1);
    	}
    
    	printf("请输入书名:");
    	scanf("%s", book->title);
    	printf("请输入作者:");
    	scanf("%s", book->author);
    
    	if (*Library != NULL)				//这个条件必须有,要不然下面让一个空指针去找next就会空指针异常!!!!	
    	{
    		tail->next = book;
    		book->next = NULL;
    	}
    	else
    	{
    		*Library = book;
    		book->next = NULL;
    	}
    	tail = book;	//尾插法的精髓,把tail指向尾部
    }
    
    void printLibrary(struct Book *Library)
    {
    	struct Book *book;
    	book = Library;
    	while (book != NULL)
    	{
    		printf("----------------\n");
    		printf("书名:%s\n", book->title);
    		printf("作者:%s\n", book->author);
    		book = book->next;
    	}
    }
    
    //释放
    void releaseLibrary(struct Book **Library)
    {
    	struct Book *temp;
    	while (*Library != NULL)
    	{
    		temp = *Library;
    		*Library = (*Library)->next;
    		free(temp);
    	}
    }
    
    //无头结点的单链表
    int main()
    {
    
    	struct Book *Library = NULL; //头指针指向NULL
    	char ch;
    	while (1)
    	{
    		do
    		{
    			printf("请问是否输入一本图书信息(Y/N):");
    			ch = getchar();		//捕获回车键!!!
    		} while (ch != 'Y'&& ch != 'N');
    		if (ch == 'Y')
    		{
    			printf("请输入书籍信息:\n");
    			addBook(&Library);//取头指针的地址
    		}
    		else
    		{
    			break;
    		}
    	}
    	printf("你输入的书籍信息为:\n");
    	printLibrary(Library);
    
    	releaseLibrary(&Library);
    	return 0;
    }
    

    运行结果:

    在这里插入图片描述

    展开全文
  • 数据结构之单链表头插法尾插法

    万次阅读 2017-09-21 17:17:27
    数据结构之单链表头插法尾插法 单链表是线性表中的一种,单链表的头插法也称前插法。链表也是线性表的一种,与顺序表不同的是,它在内存中不是连续存放的。在C语言中,链表是通过指针相关实现的。而单链表是...
  • //单链表头插法 List* Insert_Head(List *Ptrl) { //头指针指向头结点 List *p=Ptrl; List *s; int i; p=(List*)malloc(sizeof(List)); p->next=NULL; printf("请输入数据,以1000结束\n"); scanf(...
  • //创建单链表头节点,head->data = 0;head->next = NULl void List::create_List(){ head = new Node(0); } //头插法 void List::insert_head(const int &d){ for(int i = 0; i ; i++){ Node *p = new Node(i); p...
  • 在头插法尾插法中,头插法讲究的是将新结点连接在头结点之后,第一个数据点之前。逆序输出。尾插法讲究的是链接到尾结点之后,所得链表称为顺序链表。因此,紧扣住定义,将代码多次演练即可掌握,实在是不可多得的...
  • } } 用用头插法和尾插法完成链表的初始化 头插法实现相对比较简单 尾插法实现因为head不能变,所以需要一个辅助节点tem; 画图会比较容易理解。 import leetcode.dataType.ListNode; public class LeetCode_206 { ...
  • 最近复习数据结构与算法,先从单链表开始。 首先明确链表参数为 ** head(即二级指针)的原因:只要是要修改head指针必须传递head的地址(用**head),否则传递...老生常谈,头插法上一张动图: 1.创建头结点 Node *
  • java单链表 头插法尾插法

    千次阅读 2019-11-17 23:22:01
    1.链表是一种物理存储结构上非连续存储结构,数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。...头插法在public void addFirst(int data){ ListNode node = new ListNode(data); if(this...
  • 单链表之头插法和尾插法详解(C语言版)

    千次阅读 多人点赞 2021-04-20 23:50:50
    用图来详细讲解单链表的头插法和尾插法,以及它们之间的对比
  • 最近有点忙,今天才开始看数据结构单链表的部分,由于考研,看了《王道复习指导书》上只讲了带头结点的单链表... } 效果如下: 头插法(看图皆可以看出头插法他有链表的逆反的作用) 尾插法 单链表借助新的链表的逆置
  • 单链表的头插法尾插法详解

    千次阅读 多人点赞 2020-10-19 01:28:11
    关于数据结构的入门,就是从顺序表单链表开始。 我们不讲顺序表,直接从单链表开始我们的数据结构算法的学习之路。 单链表就是一种特殊的结构体组合而成的数据结构,关于单链表的创建方法有很多种,但都大同小异...
  • 创建链表(头插法) void CreateLlist(LNode**head) { *head = (LNode*)malloc(sizeof(LNode)); (*head)->next = NULL; int n; printf("请输入元素个数"); scanf_s("%d", &n); int x; LNode* p; for (int i...
  • /*头插法建表*/ void CreateListF(LinkList *L,ElemType a[],int n) { LinkList s; int i; *L = (LinkList)malloc(sizeof(LNode)); (*L)->next = NULL; for (int i = 0; i ;i++) { s = (LinkList)malloc...
  • 数据结构 单链表的头插法和尾插法

    千次阅读 多人点赞 2018-08-07 17:06:36
    插法核心代码: q-&gt;data = e; q-&gt;next = p-&gt;next; p-&gt;next = q; 尾插法核心代码: q-&gt;data = e; q-&gt;next = NULL; p-&gt;next = q; 主函数代码: #...
  • 在上次实验课之后,有同学问我头插法和尾插法到底是干什么的有什么用处,因为到饭点了,赶着吃饭 难以描述的原因,说晚点解释,一拖拖了几天。人的本质就是鸽子精,而我是老鸽子精 头插法插法就是从头插入(没问题...
  • /*头插法插法原理: 定义一个head头结点,之后添加元素在头节点已有元素之间。*/ public ListNode createListHead() { ListNode head = new ListNode(); head.next = null; for (int i = 1; i <= 5; i++)...
  • 数据结构-线性表之单链表(头插法和尾插法)【下】在这里https://blog.csdn.net/viafcccy/article/details/84483828 因为头插法算法较为简单这里就用头插法作为案例   相较于顺序表的优点: 1、不用定义...
  • 有关单链表的创建,就地逆置,头插法尾插法,输出等
  • 创建单链表分为头插法和尾插法: 二者的事件复杂度相同,但是由于头插法插入数据和链表生成的顺序相反,故选取二者时要根据实际需求使用。
  • 尾插: void input(Linklist &L,int n) //头 { Linklist p,head,tail; int i; tail = L; for(i = 1;i <= n;i ++) { p=(Linklist)malloc(sizeof(LNode)); p->next=NULL; scanf("%d",...
  • 用Python实现数据结构的头插法和尾插法 1.链表结构 # -*- coding:utf-8 -*- import random as rd class Node(): def __init__(self, value, next=None): self.value = value self.next = next 2.头插法 #头...
  • 单链表的头插法和尾插法(C语言实现) #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 typedef int Elemtype; typedef int Status; typedef struct LNode{ Elemtype data; ...

空空如也

空空如也

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

单链表头插法和尾插法