数据结构（3）

最新推荐文章于 2023-11-02 18:34:59 发布
最新推荐文章于 2023-11-02 18:34:59 发布
阅读量126 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43663780/article/details/104595676
版权

文章目录

单链表

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

插入

在这里插入图片描述

删除

在这里插入图片描述

插入

在这里插入图片描述


```handlebars
#!usr/bin/env python
# -*- coding:utf-8 _*-
"""
@author: HP
@file: single_list.py
@time: 2020/02/19
@desc:
"""
class SingleNode(object):
    def __init__(self,item):
        self.item=item
        self.next=None


class SingleLinkList(object):
    # is_empty()
    # 链表是否为空
    # length()
    # 链表长度
    # travel()
    # 遍历整个链表
    # add(item)
    # 链表头部添加元素
    # append(item)
    # 链表尾部添加元素
    # insert(pos, item)
    # 指定位置添加元素
    # remove(item)
    # 删除节点
    # search(item)
    # 查找节点是否存在
    def  __init__(self):
        self.head=None
    def is_empty(self):
    # 链表是否为空
        return self.head==None
    def  length(self):
        cur=self.head
        count=0
    # 链表长度
        while cur!=None:
            count+=1
            cur=cur.next
        return count
    def travel(self):
        # 遍历整个链表
        cur = self.head
        while cur != None:
            print(cur.item)
            cur = cur.next
            print("")
    def add(self,item):
        # 链表头部添加元素
        node=SingleNode(item)
        node.next=self.head
        self.head=node
    def append(self,item):
        # 链表头部添加元素
        node = SingleNode(item)
        cur = self.head
        if self. is_empty():
            self.head == node
        elif cur.next==None:
            cur.next=node
            node.next=None
        else:
            while cur.next != None:
                cur=cur.next
   

```handlebars
 def insert(self,pos, item):
        # 指定位置添加元素
        if pos<=0:
            self.add(item)
        elif pos>(self.length()-1):
            self.append(item)
        else:
            pre=self.head
            count=0
            node = SingleNode(item)
            while count<(pos-1):
                count+=1
                pre=pre.next
                node.next=pre.next
                pre.next=node

def remove(self,item):
    # 删除节点
    cur=self.head
    pre=None
    while cur!=None:
        if cur.item==item:
            if not pre:
                self.head=cur.next
            else:
                pre.next=cur.next
            break
        else:
            pre=cur
            cur=cur.next
def search(self,item):
    # 查找节点是否存在
    cur=self.head
    while cur!=None:
        if cur.item==item:
            return True
        else:
            cur=cur.next
    return False

单向循环列表

在这里插入图片描述
在这里插入图片描述
``

`handlebars
class Node(object):
    """节点"""
    def __init__(self, elem):
        self.elem = elem
        self.next = None


class SingleCycleLinkList(object):
    """单向循环链表"""
    def __init__(self, node=None):
        self.__head = node
        if node:
            node.next = node

    def is_empty(self):
        """链表是否为空"""
        return self.__head == None

    def length(self):
        """链表长度"""
        if self.is_empty():
            return 0
        # cur游标，用来移动遍历节点
        cur = self.__head
        # count记录数量
        count = 1
        while cur.next != self.__head:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        """遍历整个链表"""
        if self.is_empty():
            return
        cur = self.__head
        while cur.next != self.__head:
            print(cur.elem, end=" ")
            cur = cur.next
        # 退出循环，cur指向尾节点，但尾节点的元素未打印
        print(cur.elem)

    def add(self, item):
        """链表头部添加元素，头插法"""
        node = Node(item)
        if self.is_empty():
            self.__head = node
            node.next = node
        else:
            cur = self.__head
            while cur.next != self.__head:
                cur = cur.next
            # 退出循环，cur指向尾节点
            node.next = self.__head
            self.__head = node
            # cur.next = node
            cur.next = self.__head

    def append(self, item):
        """链表尾部添加元素, 尾插法"""
        node = Node(item)
        if self.is_empty():
            self.__head = node
            node.next = node
        else:
            cur = self.__head
            while cur.next != self.__head:
                cur = cur.next
            # node.next = cur.next
            node.next = self.__head
            cur.next = node

    def insert(self, pos, item):
        """指定位置添加元素
        :param  pos 从0开始
        """
        if pos <= 0:
            self.add(item)
        elif pos > (self.length()-1):
            self.append(item)
        else:
            pre = self.__head
            count = 0
            while count < (pos-1):
                count += 1
                pre = pre.next
            # 当循环退出后，pre指向pos-1位置
            node = Node(item)
            node.next = pre.next
            pre.next = node

    def remove(self, item):
        """删除节点"""
        if self.is_empty():
            return

        cur = self.__head
        pre = None

        while cur.next != self.__head:
            if cur.elem == item:
                # 先判断此结点是否是头节点
                if cur == self.__head:
                    # 头节点的情况
                    # 找尾节点
                    rear = self.__head
                    while rear.next != self.__head:
                        rear = rear.next
                    self.__head = cur.next
                    rear.next = self.__head
                else:
                    # 中间节点
                    pre.next = cur.next
                return
            else:
                pre = cur
                cur = cur.next
        # 退出循环，cur指向尾节点
        if cur.elem == item:
            if cur == self.__head:
                # 链表只有一个节点
                self.__head = None
            else:
                # pre.next = cur.next
                pre.next = self.__head

    def search(self, item):
        """查找节点是否存在"""
        if self.is_empty():
            return False
        cur = self.__head
        while cur.next != self.__head:
            if cur.elem == item:
                return True
            else:
                cur = cur.next
        # 退出循环，cur指向尾节点
        if cur.elem == item:
            return True
        return False

双向链表

在这里插入图片描述

删除

在这里插入图片描述

插入

在这里插入图片描述
在这里插入图片描述

class Node(object):
    """结点"""
    def __init__(self, item):
        self.elem = item
        self.next = None
        self.prev = None


class DoubleLinkList(object):
    """双链表"""
    def __init__(self, node=None):
        self.__head = node

    def is_empty(self):
        """链表是否为空"""
        return self.__head == None

    def length(self):
        """链表长度"""
        # cur游标，用来移动遍历节点
        cur = self.__head
        # count记录数量
        count = 0
        while cur != None:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        """遍历整个链表"""
        cur = self.__head
        while cur != None:
            print(cur.elem, end=" ")
            cur = cur.next
        print("")

    def add(self, item):
        """链表头部添加元素，头插法"""
        node = Node(item)
        node.next = self.__head
        self.__head = node
        node.next.prev = node

    def append(self, item):
        """链表尾部添加元素, 尾插法"""
        node = Node(item)
        if self.is_empty():
            self.__head = node
        else:
            cur = self.__head
            while cur.next != None:
                cur = cur.next
            cur.next = node
            node.prev = cur

    def insert(self, pos, item):
        """指定位置添加元素
        :param  pos 从0开始
        """
        if pos <= 0:
            self.add(item)
        elif pos > (self.length()-1):
            self.append(item)
        else:
            cur = self.__head
            count = 0
            while count < pos:
                count += 1
                cur = cur.next
            # 当循环退出后，cur指向pos位置
            node = Node(item)
            node.next = cur
            node.prev = cur.prev
            cur.prev.next = node
            cur.prev = node

    def remove(self, item):
        """删除节点"""
        cur = self.__head
        while cur != None:
            if cur.elem == item:
                # 先判断此结点是否是头节点
                # 头节点
                if cur == self.__head:
                    self.__head = cur.next
                    if cur.next:
                        # 判断链表是否只有一个结点
                        cur.next.prev = None
                else:
                    cur.prev.next = cur.next
                    if cur.next:
                        cur.next.prev = cur.prev
                break
            else:
                cur = cur.next

    def search(self, item):
        """查找节点是否存在"""
        cur = self.__head
        while cur != None:
            if cur.elem == item:
                return True
            else:
                cur = cur.next
        return False
林淮荣
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构题目3.pdf
04-16
数据结构的考试练习题
数据结构数据结构数据结构
10-15
数据结构
数据结构
一口大芒果的博客
06-18 548
5639: 数据结构实验：顺序表操作 描述 对以顺序存储结构存储的线性表，验证其建表、初始化、插入、删除、索引、查找、就地逆置、销毁等操作。 顺序表定义如下： typedef int Elemtype; typedef struct { Elemtype *data; int length; }SeqList; 部分代码已经给出，请补充完整，提交时请勿包含已经给出的代码。 //打印 void Pr...
数据结构 | 排序
suiuko CSDN
11-24 211
数据结构：查找部分一：插入类：1.直接插入排序2.折半插入3.希尔排序二：交换类1：冒泡排序2:快速排序三：选择排序1.简单选择排序2.对排序四：二路归并排序五：基数排序六 排序总结1.关于时间复杂度 /* 插入类：直接插入，折半插入，希尔 选择类：简单选择，堆排序 交换类：冒泡，快排， 二路归并 基数 */ 一：插入类： 1.直接插入排序 找到哨兵 然后进行依次插入 性质：是一个稳定排序，时间复杂度为O^2，空间o（1） void InsertSort(ElemType A[],int n){ i
数据结构之顺序表
qq_53010164的博客
03-23 1633
定义：顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 静态顺序表： #define N 1000 typedef int SLDataType;//重新定义容易更改类型 //静态顺序表 typedef struct SeqList { SLDataType a[N]; int size;//表示数组存储了多少个数据 }SL; 动态顺序表： typedef int SLDataType; //动态顺序表 typ
数据结构——链表讲解（2）
dongxue727504的博客
03-05 621
7000字博客剩余内容讲解，及其链表完整代码
数据结构与算法二
GodLike
05-23 1169
1.课程安排表： 1. 线性表 2. 字符串 3. 栈和队列 4.树 5.查找 6.排序 7.暴力枚举法 8.广度优先搜索 9.深度优先搜索 10.分治 11.贪心 12.动态规划 13.图 14.数学方法与常见模型 15.大整数运算 16. 基础功能 2.   编程技巧： 1.把较大的数组放在main 函数（全局变量）外，作为全局变量，这样可以防止栈溢出，
数据结构视频
03-18
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检索算法和索引技术...
数据结构习题
11-21
数据结构习题
【数据结构】基础：堆
qq_66725576的博客
11-24 531
摘要：本文主要介绍数据结构堆，分别介绍其概念、实现和应用。
【数据结构】单向链表的增删查改以及指定pos位置的插入删除
m0_64476561的博客
11-02 355
在上面众多单向链表的实现中，很多并不实用，当需要大量的头插头删时，使用单向链表会更高效。
2021/3/28 树和二叉树 已知后序遍历和中序遍历，求前序遍历
NZR的blog
03-28 345
【练习时间】2021/3/28 【题目名称】已知二叉树的后序遍历和中序遍历，求前序遍历 详细的算法请参照我的另一篇博客 2021/3/6 算法训练 绘制地图（已知数组先序和中序求后序序列） 在这里我们只需要改变cur_pos的初始值和每次运行的操作即可 我们知道后序遍历序列是左子树->右子树->根；所以我们需要先建立右子树而后建立左子树即可。cur_pos初始化为n-1，每次找到后自动减一，如果没找到加一，先建立右子树； 【源代码】 /* 8 4 7 5 2 8 6 3 1 4 2 7 5 1
数据结构——串（基础知识）
weixin_66405733的博客
09-16 2306
例如：s=“happen”，t=“happy”，因为前四个字母均相等，而两串第五个字母（k值），字母e的ASCLL码是101，而字母y的ASCLL码是121，显然e
C++哈希查找算法简单实现
MusicMan
11-29 3236
首先哈希算法主要是用来查找元素，效率非常快 原理： 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则...
N皇后问题
清风拂面
11-17 315
n皇后问题 研究的是如何将 n个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。 给你一个整数 n ，返回所有不同的n皇后问题 的解决方案。 每一种解法包含一个不同的n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。 示例 1： 输入：n = 4 输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]] 解释：如上图所示，4 皇后问题存在两个不同的解法。 示例 2： ...
CURL常用命令
孤剑之家
01-07 1557
原文地址： http://www.thegeekstuff.com/2012/04/curl-examples/下载单个文件，默认将输出打印到标准输出中(STDOUT)中curl http://www.centos.org通过-o/-O选项保存下载的文件到指定的文件中：-o：将文件保存为命令行中指定的文件名的文件中-O：使用URL中默认的文件名保存文件到本地1 # 将文件下载到本地并命名为myge
curPos和tgtPos
weixin_33895695的博客
08-31 927
curpos tgtpos 乍一看以为是当前位置和目标位置，但在项目里面这两个位置有点坑 当客户端玩家移动或者AI里面的位置，会把获得的位置付给tgtpos 而以前的tgtpos会付给curpos 所以这个tgtpos是当前玩家或者怪物站立的位置，而curpos是上一个位置 我想要这个curpos有什么用呢这个也算是很久的一个问题了。  ...
数据结构数据结构设计
最新发布
12-01
数据结构是计算机科学中的一个重要分支，它研究的是数据的组织、存储、管理和操作等问题。数据结构设计是指在解决实际问题时，根据问题的特点和要求，选择合适的数据结构，并设计相应的算法来解决问题的过程。在实际...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值