精华内容
下载资源
问答
  • 主要介绍了Python实现数据结构线性链表单链表)算法,结合实例形式分析了Python单链表的定义、节点插入、删除、打印等相关操作技巧,需要的朋友可以参考下
  • 线性链表单链表

    千次阅读 2018-11-16 17:08:31
    线性链表存储结构的特点:用一组任意的存储单元存储线性表的数据元素(存储单元可以是连续的,也可以是不连续的) 数据元素a与其直接后继a+1之间的逻辑关系,对数据元素a来说,除了存储其本身信息外,还需要存储一...

    线性链表存储结构的特点:用一组任意的存储单元存储线性表的数据元素(存储单元可以是连续的,也可以是不连续的)

    数据元素a与其直接后继a+1之间的逻辑关系,对数据元素a来说,除了存储其本身信息外,还需要存储一个指示其直接后继的信息(即直接后继的存储位置)。这两部分信息组成数据元素a的存储映像,称为结点( node)

    它包括两个域:存储数据元素信息的域称为数据域;存储直接后继存储位置的域称为指针域。指针域中存储的信息称为指针

    n个结点(ai(1i≤n)的存储映像)链结成一个链表,即为线性表的式存储结构。又因为此链表的每一个结点中只包含一个指针域,故又称线性链表单链表

    链表是从头指针开始,头指针的信息就是第一个结点(即第一个数据元素的存储映像)存储地址。最后一个数据元素没有直接后继,故线性链表的最后一个结点的指针为“(NULL)

    指针是数据元素之间的逻辑关系的映像。

    逻辑上相邻的两个数据元素其存储的物理位置不要求相邻,这种存储结构为非顺序映像链式映像

    头结点:在单链表的第一个结点之前设一个结点。头结点的数据域可以不存储任何信息,也可以存储如线性表的长度等类的附加信息,头结点的指针域存储指向第一个结点的指针(即第一个元素结点的存储位置) 

    Status GetElem_L(LinkList L,int i,ElemType &e){
    	//L为带头结点的单链表的头指针
    	//当第i个元素存在时,其赋值给e并返回OK值,否则返回ERROR
    	p = L -> next;j=1;//初始化L,p指向第一个结点,j为计数器
    	while(P && j < i){//顺指针向后查找,知道p指向第i个元素或p为空
    		p = p -> next;
    		++j;
    	}
    	if(!p || j>i) return ERROR;//第i个元素不存在
    	e = p -> data;//取第i个元素
    	return OK;
    }GetElem_L

      时间复杂度:O(n)

    单链表的插入与删除:

    插入算法:

    Status ListInsert_L(LinkList &L, int i,ElemType e){
    //在带头结点的单链线性表L中第i个位置插入元素e
    	p = L; j = 0;
    	while(p && j<i-1){//寻找第i-1个结点
    		p=p->next;
    		++j;
    	}
    	if(!p || j>i-1) return ERROR;
    
    	s=(LinkList)malloc(sizeof(LNode));//生成新的结点
    
    	s->data=e;s->next=p->next;//插入到L中
    	p->next=s;
    	return OK;
    }//ListInsert_L

     s=(LinkList)malloc(sizeof(LNode));作用是游戏厅生成一个LNode型的结点,同时将该结点的起始位置赋值给指针变量s

     时间复杂度:O(n)

    删除算法:

    Status ListDelete_L(LinkList &L, int i,ElemType e){
    //在带头结点的单链线性表L中删除第i个位置的元素,并由e返回其值
    	p = L; j = 0;
    	while(p && j<i){//寻找第i个结点,并令p指向其前驱
    		p=p->next;
    		++j;
    	}
    	if(!p || j>i-1) return ERROR;
    
    	q=p->next; p->next=q->next;//删除并释放结点
    	e=q->data;
    	free(q);//粒子还给系统
    	return OK;
    }//ListDelete_L

      free(q);作用是由系统回收一个LNode型的结点,回收后的空间可以备做再次生成结点时用

      时间复杂度:O(n)

    展开全文
  • Python实现数据结构线性链表单链表)算法示例本文实例讲述了Python实现数据结构线性链表单链表)算法。分享给大家供大家参考,具体如下:初学python,拿数据结构中的线性链表存储结构练练手,理论比较简单,直接...

    Python实现数据结构线性链表(单链表)算法示例

    本文实例讲述了Python实现数据结构线性链表(单链表)算法。分享给大家供大家参考,具体如下:

    初学python,拿数据结构中的线性链表存储结构练练手,理论比较简单,直接上代码。

    #!/usr/bin/python

    # -*- coding:utf-8 -*-

    # Author: Hui

    # Date: 2017-10-13

    # 结点类,

    class Node:

    def __init__(self, data):

    self.data = data # 数据域

    self.next = None # 指针域

    def get_data(self):

    return self.data

    # 链表类

    class List:

    def __init__(self, head):

    self.head = head # 默认初始化头结点

    def is_empty(self): # 空链表判断

    return self.get_len() == 0

    def get_len(self): # 返回链表长度

    length = 0

    temp = self.head

    while temp is not None:

    length += 1

    temp = temp.next

    return length

    def append(self, node): # 追加结点(链表尾部追加)

    temp = self.head

    while temp.next is not None:

    temp = temp.next

    temp.next = node

    def delete(self, index): # 删除结点

    if index < 1 or index > self.get_len():

    print "给定位置不合理"

    return

    if index == 1:

    self.head = self.head.next

    return

    temp = self.head

    cur_pos = 0

    while temp is not None:

    cur_pos += 1

    if cur_pos == index-1:

    temp.next = temp.next.next

    temp = temp.next

    def insert(self, pos, node): # 插入结点

    if pos < 1 or pos > self.get_len():

    print "插入结点位置不合理..."

    return

    temp = self.head

    cur_pos = 0

    while temp is not Node:

    cur_pos += 1

    if cur_pos == pos-1:

    node.next = temp.next

    temp.next =node

    break

    temp = temp.next

    def reverse(self, head): # 反转链表

    if head is None and head.next is None:

    return head

    pre = head

    cur = head.next

    while cur is not None:

    temp = cur.next

    cur.next = pre

    pre = cur

    cur = temp

    head.next = None

    return pre

    def print_list(self, head): # 打印链表

    init_data = []

    while head is not None:

    init_data.append(head.get_data())

    head = head.next

    return init_data

    if __name__ == '__main__':

    head = Node("head")

    list = List(head)

    print '初始化头结点:\t', list.print_list(head)

    for i in range(1, 10):

    node = Node(i)

    list.append(node)

    print '链表添加元素:\t', list.print_list(head)

    print '链表是否空:\t', list.is_empty()

    print '链表长度:\t', list.get_len()

    list.delete(9)

    print '删除第9个元素:\t',list.print_list(head)

    node = Node("insert")

    list.insert(3, node)

    print '第3个位置插入‘insert'字符串 :\t', list.print_list(head)

    head = list.reverse(head)

    print '链表反转:', list.print_list(head)

    执行结果:

    1559535W3QF-14604.jpg

    更多关于Python相关内容感兴趣的读者可查看本站专题:《Python数据结构与算法教程》、《Python加密解密算法与技巧总结》、《Python编码操作技巧总结》、《Python函数使用技巧总结》、《Python字符串操作技巧汇总》及《Python入门与进阶经典教程》

    希望本文所述对大家Python程序设计有所帮助。

    以上就是本次给大家分享的关于java的全部知识点内容总结,大家还可以在下方相关文章里找到相关文章进一步学习,感谢大家的阅读和支持。

    展开全文
  • [文档整理系列]线性链表单链表 /* 问题描述:线性表____链表_____单链表 @date 2017-3-7 */ #include<iostream> using namespace std; template<typename T> struct node{ T data;...

    [文档整理系列] 线性链表之单链表

    /*
    问题描述:线性表____链表_____单链表 
    @date 2017-3-7 
    */ 
    
    #include<iostream>
    using namespace std;
    
    template<typename T>
    struct node{
    	T data;
    	node<T> *next;
    };
    
    template<typename T>
    class LinkedList{
        public:
        	LinkedList();    
    		LinkedList(T arr[],int n);  
    		~LinkedList();   
    		int getLength();  
    		void InsertAt(int n,T data);  
    		T DeleteAt(int i);     
    
    		T   GetData(int i);      
    		int getDataAt(T data);   
    		void Print(); 
    	private:
    	    int length;
    		node<T> *first;   
    };
    
    template <class T>  
    LinkedList<T>::LinkedList(){
        first = new node<T>;
    	first->next = NULL;    
    	length = 0;	
    } 
    
    template <class T>  
    LinkedList<T>::LinkedList(T arr[],int n){
        first = new node<T>();   //初始化指针变量  
        first->next = NULL;     
        
        for(int i = 0;i<n;i++){
        	node<T> s;
        	s.data = arr[i];
        	s.next = first->next;
        	first->next = &s;
    	}
    	
        length = n;
    	cout<<"初始化成功!"<<endl;  //test
    }
    
     
    template<typename T>
    LinkedList<T>::~LinkedList(){   
    
       node<T> *q;
       while (first)                         //释放单链表的每一个结点的存储空间
       {
         q=first;                            //暂存被释放结点
         first=first->next;                  //工作指针p指向被释放结点的下一个结点,使单链表不断开
         delete q;    
    }
       cout<<"析构(销毁)成功!"<<endl;	 //test
    }
    
    template<typename T>
    int LinkedList<T>::getLength(){
    	return length;
    }
    
    template< typename T> 
    void LinkedList<T>::InsertAt(int n,T data){
        
    	cout<<"成功插入第"<<n<<"个位置!"<<endl;
    }
      
    int main(){
        int arr[6]={7,19,4,5,6,9};
        LinkedList<int> t(arr,6);  
    //    t.InsertAt(7,689); 
    	return 0;
    }
    

      

    转载于:https://www.cnblogs.com/johnnyzen/p/9277436.html

    展开全文
  • 本文实例讲述了Python实现数据结构线性链表单链表)算法。分享给大家供大家参考,具体如下:初学python,拿数据结构中的线性链表存储结构练练手,理论比较简单,直接上代码。#!/usr/bin/python# -*- coding:utf-8 ...

    本文实例讲述了Python实现数据结构线性链表(单链表)算法。分享给大家供大家参考,具体如下:

    初学python,拿数据结构中的线性链表存储结构练练手,理论比较简单,直接上代码。

    #!/usr/bin/python

    # -*- coding:utf-8 -*-

    # Author: Hui

    # Date: 2017-10-13

    # 结点类,

    class Node:

    def __init__(self, data):

    self.data = data # 数据域

    self.next = None # 指针域

    def get_data(self):

    return self.data

    # 链表类

    class List:

    def __init__(self, head):

    self.head = head # 默认初始化头结点

    def is_empty(self): # 空链表判断

    return self.get_len() == 0

    def get_len(self): # 返回链表长度

    length = 0

    temp = self.head

    while temp is not None:

    length += 1

    temp = temp.next

    return length

    def append(self, node): # 追加结点(链表尾部追加)

    temp = self.head

    while temp.next is not None:

    temp = temp.next

    temp.next = node

    def delete(self, index): # 删除结点

    if index < 1 or index > self.get_len():

    print "给定位置不合理"

    return

    if index == 1:

    self.head = self.head.next

    return

    temp = self.head

    cur_pos = 0

    while temp is not None:

    cur_pos += 1

    if cur_pos == index-1:

    temp.next = temp.next.next

    temp = temp.next

    def insert(self, pos, node): # 插入结点

    if pos < 1 or pos > self.get_len():

    print "插入结点位置不合理..."

    return

    temp = self.head

    cur_pos = 0

    while temp is not Node:

    cur_pos += 1

    if cur_pos == pos-1:

    node.next = temp.next

    temp.next =node

    break

    temp = temp.next

    def reverse(self, head): # 反转链表

    if head is None and head.next is None:

    return head

    pre = head

    cur = head.next

    while cur is not None:

    temp = cur.next

    cur.next = pre

    pre = cur

    cur = temp

    head.next = None

    return pre

    def print_list(self, head): # 打印链表

    init_data = []

    while head is not None:

    init_data.append(head.get_data())

    head = head.next

    return init_data

    if __name__ == '__main__':

    head = Node("head")

    list = List(head)

    print '初始化头结点:\t', list.print_list(head)

    for i in range(1, 10):

    node = Node(i)

    list.append(node)

    print '链表添加元素:\t', list.print_list(head)

    print '链表是否空:\t', list.is_empty()

    print '链表长度:\t', list.get_len()

    list.delete(9)

    print '删除第9个元素:\t',list.print_list(head)

    node = Node("insert")

    list.insert(3, node)

    print '第3个位置插入‘insert'字符串 :\t', list.print_list(head)

    head = list.reverse(head)

    print '链表反转:', list.print_list(head)

    执行结果:

    希望本文所述对大家Python程序设计有所帮助。

    展开全文
  • 单链表:用任意的存储... /// 该类为链表接口定义类,顺序链表单链表都使用该接口 /// </summary> /// <typeparam name="T"></typeparam> interface IListDS<T> { /// <summary>
  • 一、介绍了线性表的一种链式存储结构——单链表的C语言实现原理; 二、介绍了单链表线性链表)的基本操作的算法实现,包括求长度、创建单链表、插入结点、删除结点以及各个算法的时间复杂度。
  • 线性链表——单链表 文章目录 线性链表——单链表 线性链表 一、头指针头结点的异同 二、链表存储结构代码描述 1.构造结构体 2.单链表的读取 3.单链表的插入删除 总结 线性链表 线性表的链式存储结构的特点是用...
  • python 实现线性链表单链表

    千次阅读 2017-10-13 17:11:46
    初学python,拿数据结构中的线性链表存储结构练练手,理论比较简单,直接上代码。 #!/usr/bin/python # -*- coding:utf-8 -*- # Author: Hui # Date: 2017-10-13 # 结点类, class Node: def __init__(self, ...
  • 线性链表单链表

    2014-04-21 15:39:10
    单链表的部分实现
  • 线性链表(单链表)的基本操作

    千次阅读 2020-01-10 18:55:19
    单链表的基本操作的实现1 . 初始化2 . 添加1 . 头添加2 . 尾添加3 . 查1 . 遍历整个链表2 . 查询指定结点4 . 插入5 . 删除1 . 尾删除2 . 头删除3 . 删除指定结点6 . 清空链表 一 . 链表的特点和定义 链表是一种...
  • 初学python,拿数据结构中的线性链表存储结构练练手,理论比较简单,直接上代码。!/usr/bin/python-- coding:utf-8 --Author: HuiDate: 2017-10-13结点类,class Node:def __init__(self, data): self.data = data ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,075
精华内容 7,230
关键字:

线性链表与单链表