精华内容
下载资源
问答
  • LinkList.cpp

    2020-04-17 14:57:33
    实现一个链表类(自己定义数据结构,不要使用语言自带的数据结构),链表内部每个 节点存放一个 int 变量和一个 double 变量。 利用迭代器模式,实现一个外部迭代器,可以从头到尾和从尾到头两种方式遍历这个链 表,...
  • LinkList

    2019-01-08 23:06:33
    LinkList.c  /*************************************** * author: * mail: * desc:链表的线性实现函数 * * **************************************/ #include <stdio.h> #include <...

    LinkList.c 

    /***************************************
     * author:
     * mail:
     * desc:链表的线性实现函数
     *
     * **************************************/
    
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include "LinkList.h"
    
    /*
    return:
        无
    parm:
     	L:链表的头指针
     	n: 链表的长度
    
    */
    
    void initList(LinkList L, int n)
    {
    	int i = 0;
    	LinkList p;
    	for(i = 0; i < n; i++)
    	{
    		p = (LinkList)malloc(sizeof(Lnode));
    		scanf("%d", &p->data);
    		p -> next = L -> next;
    		L -> next = p;
    	}
    }
    
    /*
    return:
    	无
    parm:
    	L:链表的头指针
    
    */
    
    void CrearList(LinkList L)
    {
    	LinkList p, t;
    	p = L -> next;
    	while(p != NULL)
    	{
    		t = p -> next;
    		free(p);
    		p = NULL;
    		p = t;
    	}
    	L -> next = NULL;
    }
    
    /*
    return:
    	无
    parm:
    	L:要销毁的链表
    
    */
    void DestroyList(LinkList L)
    {
    	if(L == NULL)return;
    	LinkList p;
    	while(L != NULL)
    	{	
    		p = L -> next;
    		free(L);
    		L = NULL;
    		L = p;
    	}
    }
    
    /*
    return:
    	TRUE:链表为空
    	FALSE:链表非空
    parm:
    	L:表示要判断的链表
    
    */
    
    int isEmptyList(LinkList L)
    {
    	if(NULL == L -> next)
    	{
    		return TRUE;	
    	}
    	else
    	{
    		return FALSE;	
    	}
    	
    }
    
    /*
    return:
    	链表的长度
    parm:
    	L:要获得长度的链表头指针
    
    */
    
    int getListSize(LinkList L)
    {
    	LinkList p = L -> next;
    	int x = 0;
    	while(p != NULL)
    	{
    		x++;
    		p = p -> next;
    	}
    	return x;
    }
    
    /*
    return:
    	OK:目标元素存在链表中
    	FALSE:目标元素不存在链表中
    parm:
    	L:链表的头指针
    	x:判断此元素是否存在于链表中
    	
    */
    
    int GetElem(LinkList L, int x)
    {
    	if(L == NULL)return FALSE;
    	LinkList p = L -> next;
    	while(p != NULL)
    	{
    	  if(p->data == x)return OK;	
    	  p = p -> next;
    	}
    	return p->data;
    }    
    
    /*
    return:
    	无
    parm:
    	L:链表的头指针
    	e:表示要插入的值
    	i:表示元素需要插入的位置
    
    */
    
    void insertList(LinkList L, elemType e, int i)
    {
    	LinkList p = L -> next;
    	LinkList q, s;
    	int j = 0;
    	while(p != NULL && j < i)
    	{
    		j++;
    		q = p;
    		p = p -> next;	
    	}
    	if(NULL == p)
    	{
    		s = (LinkList)malloc(sizeof(Lnode));
    		s -> data = e;
    		s -> next = NULL;
    		q -> next = s;
    	}
    	else 
    	{
    		s = (LinkList)malloc(sizeof(Lnode));
    		s -> data = e;
    		q -> next = s;
    		s -> next = p;
    	}
    }
    
    /*
    return:
    	OVERFLOW:链表中没有目标元素,删除失败
    	OK:表示删除成功
    parm
    	L:链表的头指针
    	i:需要删除的元素
    
    	
    */
    
    int deleteElem(LinkList L,  int i)
    {
    	LinkList p = L -> next;
    	LinkList q = L;
    	while(p != NULL)
    	{
    		if(p -> data == i)
    		{
    			q -> next = p -> next;
    			free(p);
    			p -> next = NULL;
    			return OK;
    		}
    		q = p;
    		p = p-> next;
    	}
    	return OVERFLOW;
    }
    
    /*
    return:
    	无
    parm:
    	L:需要销毁的链表头指针
    
    */
    
    void displayList(LinkList L)
    {
    	LinkList p = L -> next;
    	while(NULL != p)
    	{
    		printf("%d", p->data);
    		p = p -> next;
    		if(p)printf(" ");
    		else printf("\n");
    	}
    }
    
    

    LinkList.h

    #ifndef LINKLIST_H
    #define LINKLIST_H
    
    #include<stdio.h>
    #include<stdlib.h>
    
    //定义宏常量
    
    #define TRUE 1
    #define FALSE 0
    #define OVERFLOW -1
    #define OK 1
    
    //设置一个数据类型
    typedef int elemType;
    
    //lian表结构体
    typedef struct node{
    	elemType  data;
    	struct node *next;			
    }Lnode, *LinkList;
    
    
    //如下为所有链表的函数声明
    
    void initList(LinkList L, int n);
    
    void CrearList(LinkList L);
    
    void DestroyList(LinkList L);
    
    int isEmptyList(LinkList L);
    
    int getListSize(LinkList L);
    
    int GetElem(LinkList L, int i);
    
    void insertList(LinkList L, elemType e, int i);
    
    int deleteElem(LinkList L, int i);
    
    void displayList(LinkList L);
    
    
    #endif
    

    main.c

    #include "LinkList.h"
    #include <stdio.h>
    #include <stdlib.h>
    
    //如下为验证过程
    
    int main()
    {
    	LinkList L;
    	int n;
    	int len;
    	int x, value;
    	int i;
    	elemType *e;
    	printf("请输入链表的长度\n");
    	scanf("%d", &n);
    	L = (LinkList)malloc(sizeof(Lnode));
    	L -> next = NULL;
    	printf("请输入链表中的元素\n");
    	initList(L, n);
    	x = getListSize(L);
    	printf("输出为逆序建立链表的元素序列\n");
    	displayList(L);
    	printf("成功建立链表的长度为:%d\n", x);
    	printf("请输入需要查找的元素\n");
    	scanf("%d", &x);
    	value = GetElem(L, x);
    	if(value!=-1)printf("该元素存在于链表中\n");
    	else printf("查找的目标元素不存在链表中\n");
    	printf("请输入需要插入的元素以及插入元素的位置\n");
    	scanf("%d%d",&value, &i);
    	insertList(L, value, i);
    	printf("输出链表中的元素序列\n");
    	displayList(L);
    	printf("输入需要删除的元素\n");
    	scanf("%d", &i);
    	value = deleteElem(L, i);
    	if(value!=-1)
    	{
    		printf("删除成功\n");    
    		printf("输出链表中的元素序列\n");
            	displayList(L);
    	}
    	else printf("没有在链表中找到目标删除元素,删除失败!\n");
    	printf("正在清空链表\n");
    	CrearList(L);
    	x = isEmptyList(L);
    	if(x)printf("链表的长度为%d  已成功清空链表\n", 0);
    	else printf("链表的长度不为%d  清空链表失败\n");
    	printf("正在销毁链表\n");
    	DestroyList(L);
    	printf("销毁成功!\n");
    }
    
    

    makefile

    main:main.o LinkList.o
    	gcc -g main.o LinkList.o -o main
    main.o:main.c LinkList.h
    	gcc -g -c main.c -o main.o
    LinkList.o:LinkList.c LinkList.h
    	gcc -g -c LinkList.c -o LinkList.o
    
    clean:
    	rm -fr *.o
    	rm -fr main
    
    

     

    展开全文
  • linklist.zip

    2020-08-29 14:15:37
    本代码用于开发数据存储中遇到的链表存储数据的情况,里面有main.c,linklist.c,linklist.h,Makefile4个文件,可以在linux下直接运行测试,也可以直接移植到项目中,代码中包含单向链表的增、删、改、查功能,非常...
  • linkList

    2018-12-06 19:29:52
    linkList

    linkList

    展开全文
  • 主要介绍了C#数据结构之单链表(LinkList)实现方法,结合实例形式较为详细的分析了单链表的原理、定义与C#具体实现技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • ELinkList.cpp

    2021-02-03 19:42:52
    严蔚敏数据结构ELinkList
  • 手写linklist demo

    2018-08-21 15:46:09
    手写linklist demo
  • linklist.cpp

    2013-11-04 08:20:47
    it is out homework of C++ program
  • linklist_linklist_源码

    2021-10-04 09:53:40
    这是一个实现了linklist数据结构和几个常用函数的程序,可作为数据结构参考学习
  • 动画动态演示LINKLIST

    2018-01-04 13:17:29
    动态演示LINKLIST ARRAYLIST QUEUE STACK 顶顶顶顶顶顶顶
  • 2-1 linklist.cpp

    2019-01-24 09:13:03
    严蔚敏数据结构与算法 课本算法实现
  • Data structure: Link List Example
  • linklist example Realize the management of book system
  • LinkList L与LinkList *L Lnode与*LinkList的区别

    千次阅读 多人点赞 2020-10-13 13:39:00
    }Lnode,*LinkList; 对于结构体前面加typedef是给结构体起了个别名, struct node=Lnode struct node*=LinkList; Lnode L定义了一个结构体变量 LinkLnode L=Lnode *L=struct node *L定义的是一个指向node结构体的...
    typedef struct node
    {
    	int data;
    	struct node* next;
    }Lnode,*LinkList;
    
    
    

    对于结构体前面加typedef是给结构体起了个别名,

    1. struct node=Lnode
    2. struct node*=LinkList;
    3. Lnode L定义了一个结构体变量
    4. LinkLnode L=Lnode *L=struct node *L定义的是一个指向node结构体的指针L,必须初始化,可以用->指向结构体成员变量 L->data;或者 ( *L).data(此时的 *L就是一个结构体)
    5. 初始化
      L=(LinkList)malloc(sizeof(Lnode));
      或者
      L=(struct node*)malloc(sizeof(struct node));
      这几个等价替换,用谁都可以
    6. LinkLList *L定义的 是指向结构体指针的指针 ,它也可以指向成员变量 (此时的**L是一个结构体) (**L).data; (*L)->data;
    7. 那什么时候用LinkLIst *L,还是用LinkList L?
      LinkList L只改变结构体的内容,不改变L的地址
      而LinkList *L会改变L的地址
      具体例子看
    展开全文
  • LinkList集合详解

    2021-04-28 10:41:47
    LinkList集合详解 1、LinkedList简介 LinkedList类是一个继承于AbstractSequentialList的双向循环链表,它是非同步的,也是非线程安全的。 LinkedList实现了List接口,能对它进行队列操作。 LinkedList实现了...

    LinkList集合详解

    1、LinkedList简介

    • LinkedList类是一个继承于AbstractSequentialList的双向循环链表,它是非同步的,也是非线程安全的。
    • LinkedList实现了List接口,能对它进行队列操作。
    • LinkedList实现了Deque接口,能当作双端队列操作
    • LinkedList实现了CloneClass接口,能进行克隆操作。
    • LinkedList实现了SerialiableClass接口,能进行序列化操作。

    2、List数据结构

    • LinkedList包含两种构造函数,一种是无参构造,另一种是有参构造,他的Node对象是一个静态内部类,包含了pre、next、element
    	//指向第一个节点的指针
        transient Node<E> first;
    	//指向指针的最后一个节点
        transient Node<E> last;
    	//数据的个数
    	transient int size = 0;
    	//构造函数
        public LinkedList() {
        }
        public LinkedList(Collection<? extends E> c) {
            this();
            addAll(c);
        }
    //节点
        private static class Node<E> {
            E item;
            Node<E> next;
            Node<E> prev;
    
            Node(Node<E> prev, E element, Node<E> next) {
                this.item = element;
                this.next = next;
                this.prev = prev;
            }
        }

    3、添加元素

    • 添加元素last指针向后移动,size+1,操作次数+1
        public boolean add(E e) {
            linkLast(e);
            return true;
        }
    void linkLast(E e) {
            final Node<E> l = last;
            final Node<E> newNode = new Node<>(l, e, null);
            last = newNode;
            if (l == null)
                first = newNode;
            else
                l.next = newNode;
            size++;
            modCount++;
        }

    4、删除元素

    • 删除元素有多种方法,根据Object删除和根据index删除。
        //根据object删除,遍历找到删除node
    public boolean remove(Object o) {
            if (o == null) {
                for (Node<E> x = first; x != null; x = x.next) {
                    if (x.item == null) {
                        unlink(x);
                        return true;
                    }
                }
            } else {
                for (Node<E> x = first; x != null; x = x.next) {
                    if (o.equals(x.item)) {
                        unlink(x);
                        return true;
                    }
                }
            }
            return false;
        }
        E unlink(Node<E> x) {
            // assert x != null;
            final E element = x.item;
            final Node<E> next = x.next;
            final Node<E> prev = x.prev;
    
            if (prev == null) {
                first = next;
            } else {
                prev.next = next;
                x.prev = null;
            }
    
            if (next == null) {
                last = prev;
            } else {
                next.prev = prev;
                x.next = null;
            }
    
            x.item = null;
            size--;
            modCount++;
            return element;
        }
    
    //根据index删除
        public E remove(int index) {
            checkElementIndex(index);
            return unlink(node(index));
        }

    5、和ArrayList比较

    • 顺序插入的话ArrayList比较快,因为ArrayList基于数组实现的,只要望指定位置加一个数据即可,但是LinkedList顺序插入时,需要创建一个对象。
    • LinkList比ArrayList更加耗内存,因为LinkedList里面不仅维护了待插入的元素,还维护了Entry的前置Entry和后继Entry。
    • LinkedList和ArrayList插入和删除
    • LiskedList做插入和删除操作时,慢在寻址,快在只需要改变前后entry的应用地址
    • ArrayList做插入和删除操作时,快在寻址,慢数组的批量copy。
    • 针对各自的遍历最高的方式,ArrayList遍历效率要比LinkedList效率普片要高一点。
    • ArrayList实现了RandomAccess接口,LinkedList没有实现,所以ArrayList用for遍历更快,LinkedList用foreach遍历更快。

    展开全文
  • LinkList ✳L 我们已经知道了LinkList L定义的是指向结构体的指针,所以LinkList ✳L就是定义了指向结构体的指针的指针,也就是二级指针。在这里可以通过指向运算符->访问结构体,即(L)->data ,**L才是指结构体...
  • 对于p = *L,对于这个理解,可以先从类型上来看,LinkList 是Node * 类型,那么LinkList *L就是Node **, *L类型就是Node *。所以类型上是对的。 p是指向链表的指针,而 *L是指向p的指针,L是p指针的地址, *L是p所...
  • //header其实是传入指针head的别名 void CreateList(LinkList &header){ //参数也可写成(LNode *&header) header=(LNode*)malloc(sizeof(LNode));//(LinkList)malloc(sizeof(LNode)); header->data=11; header->...
  • java中ArrayList和LinkList的区别

    千次阅读 2019-07-09 15:39:27
    java中ArrayList和LinkList的区别 1.首先我们说下ArrayList和LinkList各是基于什么原理实现的? 答:ArrayList底层是数组结构,LinkList底层是链表结构。我们来说一下数组与链表的区别: 1.数组的定义:是相同数据...
  • C语言中LinkList L和LinkList *L 的区别

    千次阅读 2020-09-20 08:34:56
    LinkList L 和 LinkList *L二者的区别 如果调用函数里要修改指针本身,就要向函数传递指针本身的地址,即二级指针 LinkList *L,如果只是简单的访问读取指针指向的内容,就用一级指针就可以了,即LinkList L 举例: ...
  • void InitList(LinkList *L){ //实参就是void InitList(L) *L=(LinkList)malloc(sizeof(Node)); (*L)->next=NULL; }//L是指向头结点的指针,用来接收头指针;*L头结点; void ...
  • 引用传递和值传递以及链表中的LinkList L、LinkList *L、LinkList &L1 函数参数传递的两种方式为值传递和引用传递 1.传值方式传参 c语言是按值传递的,在函数中被传递的参数的本身(实参)是不能被修改的!参数...
  • 考研复习到单链表的时候,发现书中对于初始化单链表的代码些许不懂,查阅资料后想保存下来,因为写一篇以后不懂得时候可以看: ...习惯上Linklist强调是一个单链表,而Node * 强调这是一个节点。 继续说L
  • 链表中LinkList L与LinkList *L的区别

    千次阅读 2018-12-14 22:17:16
    对于LinkList L: L是指向定义的node结构体的指针,可以用-&gt;运算符来访问结构体成员,即L-&gt;elem,而(*L)就是个Node型的结构体了,可以用点运算符访问该结构体成员,即(*L).elem; 对于L...
  • linklist详解

    2020-03-28 12:42:53
    这个博客记录的很详细 原文链接
  • 链表中的LinkList L、LinkList *L

    千次阅读 2019-06-09 11:30:18
    对于LinkList L: L是指向定义的node结构体的指针,可以用->运算符来访问结构体成员,即L->elem,而(*L)就是个Node型的结构体了,可以用点运算符访问该结构体成员,即(*L).elem; 对于LinkList *L:L是指向定义的Node...
  • 《数据结构与算法》——线性表之链表(LinkList)总结 在数据结构的基本顺序结构中线性表有两类存储逻辑,一种是顺序表,一种是链表。链表中又包括单链表、双链表、单循环链表、双循环链表、静态链表。本文对最基本...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 62,451
精华内容 24,980
关键字:

linklist