精华内容
下载资源
问答
  • 查找:对于长度为n线性表最坏查找次数 顺序查找 -------------------------------------------------------n 查找最大项和最小项-----------------------------------------n-1 二分查找法--------------------...

    查找:对于长度为n的线性表最坏查找次数
    顺序查找 ----------------------------------n
    查找最大项和最小项--------------------n-1
    二分查找法----------------------------------log2^n
    冒泡排序法----------------------------------n(n-1)/2
    快速排序法---------------------------------n(n-1)/2
    简单插入排序-------------------------------n(n-1)/2
    希尔排序法-----------------------------------n^1.5
    简单选择排序-------------------------------n(n-1)/2
    堆排序------------------------------------------nlog2^n

    展开全文
  • https://wenku.baidu.com/view/5288baf8534de518964bcf84b9d528ea81c72f3c.html
    展开全文
  • 线性表排序算法

    千次阅读 2019-04-21 22:22:00
    指经过特定规则进行排序后,两个都满足排序规则,无法判断,哪一个排在前面,哪一个排在后面,这类的元素,如果按照原来的顺序,进行排列,则稳定,否则不稳定。 举例, (4,1),(3,1),(3,7),(5,6),...

    1、排序算法的稳定性

    指经过特定规则进行排序后,两个都满足排序规则,无法判断,哪一个排在前面,哪一个排在后面,这类的元素,如果按照原来的顺序,进行排列,则为稳定,否则为不稳定。

    举例, (4,1),(3,1),(3,7),(5,6),我们将这个四个元祖,以第一个元素的大小,从小到大进行排序。那么对于(3,1)和(3,7)而言有两种排列方式

    (3,1),(3,7),(4,1),(5,6)这种排序中的(3,1),(3,7)是以原来的顺序进行排列的,称之为稳定。

    (3,7),(3,1),(4,1),(5,6)这种改变了原来的排序方式,称之为不稳定。

     

     

    2、排序算法们

    2.1 冒泡排序

    冒泡排序的基本思想:

                                   每一个元素都和下一个元素进行比较大小,哪一个元素大就将大的元素向后移动,然后这个大的元素,在和下一个元素进行比较,一次向下进行,直到队列的尾部,这样就找了最大数。

                                   然后开始第二次进行进行上面的步骤,找到第二大的数。依次向下进行。

     

    def bubblesort(sequence):
        length = len(sequence) #获取序列的长度
        for i in range(length-1):  #一共要循环这个序列多少次
            #考虑特殊情况 ,就是这个序列本身就是一个有序的,那么对于这个序列来讲,我就没有
            #进行过位置互换,所以,当进入循环进行判断后,这个count一遍是一直没有执行的,#
            #如果第一次全部比较过后,都没有发生过替换,直接退出即可
            count = 0
            for j in range(length-1-i):  #每一次循环,循环序列中元素的个数
                if  sequence[j]>sequence[j+1]:  #当前元素和后一个元素进行大小判断
                    sequence[j], sequence[j+1] = sequence[j+1], sequence[j]  #进行位置互换
                    count += 1
            if count == 0:
                return sequence
        return sequence
    
    if __name__ == '__main__':
        a = [10,30,15,12,6,9,45,2,6,50]
        print(a)
        print(bubblesort(a))
    

      

    2.2 选择排序

     

    def selectsort(sequence):
        '''选择排序'''
    
        n = len(sequence)  #获取列表的长度
    
        for i in range(n-1):  #判断这种逻辑需要多少次
            min=i
            for j in range(1+i , n-1): #每一次循环,都是取current为最小值,和后面进行判断,找到最小值后,将最小值与当前值位置互换。
                if sequence[min] >sequence[j]:
                    min = j
            sequence[i], sequence[min] = sequence[min], sequence[i]
        return sequence
    
    print(selectsort([1,10,50,22,12,44,66]))
    

      

    2.3插入排序

    #插入排序与选择排序类似,都输将一个序列分为两个部分,针对插入排序,将前面作为有序部分,将一个元素,作为有序部分的第一个元素,然后从
    #第二个元素开始和前面有序中的每一个元素进行循环对比,如果比有序部分的元素小,就交换位置。
    
    def insert_sort(sequence):
    
        n = len(sequence)
        for i in range(1, n):
    
            while i>0:
                if sequence[i] < sequence[i-1]:
                    sequence[i-1], sequence[i] = sequence[i], sequence[i-1]
                    i -=1
                else:
                    break
    
        return sequence
    
    
    print(insert_sort([1,10,50,22,12,44,66]))
    

      

    2.4希尔排序

     

    #首先说一下希尔排序的一个思想,希尔排序是一个间隙gap和插入排序的组成。
    #首先说他的gap ,他根据gap,将一个序列分成若干个部分
    #例如 一个队列[1,10,8,9,33,15,99],加入说gap是3 ,那么分成的[1,10,8],
    #[9,33,15], 和[9]这三部分进行对比 ,
    # [1,10,8]
    # [9,33,15]
    # [99]
    # 他们进行竖向对比,就是竖向对比的规则就是插入排序。
    # 当一次对比完成后,将gap缩小,直到是1,当gap是1的,就完全就是插入排序了。有点鸡肋这个希尔排序
    
    
    def shell_sort(sequence):
    
        n = len(sequence)
    
        gap = n//2   #获取间隙大小
    
        while gap >= 1:
            for i in range(gap, n):  #循环多少次 ,这个次数的判断,就看上面我们竖向对比的时候,有一个中间位置, [1]      [9]   [99]
                j =i                 #                                                                [10]    [33]
                while j>0:           #                                                                   [8]     [15]
                    if sequence[j] < sequence[j-gap]:#那么对我们来说就是从9和你开始做对比,9是第一次,99是最后一次,99对应的下标是n-1,9对应的下标是gap,所以二者相减就是次数
                        sequence[j-gap], sequence[j] = sequence[j], sequence[j-gap]
                    j -= gap
            gap = gap//2
    
        return sequence
    
    
    print(shell_sort([1,10,50,22,12,44,66]))
    

      

    2.5

    快速排序,使用递归实现快排

    #使用递归,重要的思想有三点,
    1、递归必须要有一个基线条件(就是终止递归的条件),一般像线性表这种数据结构,
    递归条件就表中的元素为1或者为空。
    
    2、就是排序算法本身,先取列表中一个元素为中间元素,循环整个列表,将大于当前元素,放入一个新的列表,然后在将小于这个元素放入一个列表。然后将列表中不断按照这种原则进行一个分拆,最后,在将这些列表相加在一起。
    
    3、关于为什么,递归能够获取之前函数的值,因为递归会产生调用栈,每一次递归都会在栈中保存,上一次函数调用的变量的值。
    
    def quick_sort(sequence):
    
        if len(sequence)==0:
            return sequence
    
        else:
            middle = sequence[0]
            min = [i for i in sequence[1::] if i < middle]
            max = [i for i in sequence[1::] if i > middle]
            return quick_sort(min) + [middle] + quick_sort(max)
    
    
    
    print(quick_sort([33,10,50,22,12,44,66,55,999,24]))
    

      

     2.6 merge_sort

    '''
    归并排序的思想是,将sequence,均分成两个部分,直接将每一个部分,都分成,只有一个元素位置
    例如 [10,8,22,15] ,先分成[10,8],[22,15]然后在将这个两个数组在划分,[10,8]划分成[10],[8]到达这种状态。
    分成每一个部分都只有一个元素后,就开始对比合并 ,首先我们看[10],[8],两个对比,[8],将先8放入到一个空数组中
    然后在和[10]merge ,筒体[22,15】重复上述操作,合并成了[15,22] ,这时候[8,10]和[15,22]在开始合并,
    先将每一个数组中的第一个元素进行对比,小的先放到一个数组中,然后在拿这个数和[10]比较,如果还是10小,就将10也
    放到这个列表中,然后在将[8,10]和[15,22]合并,最后就是一个有序的序列了
    
    
    '''
    
    def mergesort(sequence):
        '''归并排序'''
        if len(sequence)==1:
            return sequence
    
        n = len(sequence)
        middle = n // 2
        left_li = mergesort(sequence[:middle])
        right_li = mergesort(sequence[middle:])
    
        res = []
        left_cursor, right_cursor=0, 0
        while left_cursor<len(left_li) and right_cursor<len(right_li):
            if left_li[left_cursor]<right_li[right_cursor]:
                res.append(left_li[left_cursor])
                left_cursor += 1
    
            else:
                res.append(right_li[right_cursor])
                right_cursor += 1
    
        res += left_li[left_cursor:]
        res += right_li[right_cursor:]
    
        return res
    
    
    print(mergesort([1,10,50,22,12,44,66]))
    

      

     

    二、 树

     

     有序树

          1、  二叉树

                        1.1完全二叉树

                        1.2 

          2、霍夫曼树

          3、B树

     

    下面所有的代码都是基于二叉树实现,都是为了实现一个满二叉树

     

    2、1 二叉树添加节点及,广度serversal

    class Node(object):
        '''树节点'''
        def __init__(self, ele):
            self._ele = ele
            self.left_node = None
            self.right_node = None
    
    class Tree(object):
        def __init__(self):
            self.__root = None
    
        def add(self, item):
            '''添加节点,通过层级遍历,实现二叉树'''
    
            node = Node(item)
            if self.__root is None:
                self.__root = node
                return
            queue = [self.__root]  #先将跟节点放入队列中
            while queue:
                cur_node = queue.pop(0)
                if cur_node.left_node is None:
                    cur_node.left_node = node
                    return
                else:
                    queue.append(cur_node.left_node)
    
                if cur_node.right_node is None:
                    cur_node.right_node = node
                    return
                else:
                    queue.append(cur_node.right_node)
    
    
        def leveltraversal(self):
    
            queue = []
            queue = [self.__root]  # 先将跟节点放入队列中
            while queue:
                cur_node = queue.pop(0)
                print(cur_node._ele)
    
                if cur_node.left_node is None:
                    pass
                else:
                    queue.append(cur_node.left_node)
    
                if cur_node.right_node is None:
                    pass
                else:
                    queue.append(cur_node.right_node)
    
    
    
    if __name__ == '__main__':
    
        tree = Tree()
    
        for i in range(10):
            tree.add(i)
    
    
        tree.leveltraversal()
    

      

    二叉树纵向遍历,分为三中分别是前序、中序、后序。这三种遍历的区别在遍历顺序前序是根节点 - 左边的节点 - 右边的节点 , 中序是 左边的节点 - 根节点 - 右边的节点 , 后序是做节点 - 右节点 - 根节点。(这个根节点如果是子树,对应的就是父节点)

    这个要注意的是在纵向遍历时,如果向下遍历的节点,不是叶节点,也就是对应的仍然是一个子树,那么就要按照遍历规则,继续向下遍历。这些遍历利用了递归的思想。

    class Node(object):
        '''树节点'''
        def __init__(self, ele):
            self._ele = ele
            self.left_node = None
            self.right_node = None
    
    class Tree(object):
        def __init__(self):
            self.root = None
    
        def add(self, item):
            '''添加节点,通过层级遍历,实现二叉树'''
    
            node = Node(item)
            if self.root is None:
                self.root = node
                return
            queue = [self.root]  #先将跟节点放入队列中
            while queue:
                cur_node = queue.pop(0)
                if cur_node.left_node is None:
                    cur_node.left_node = node
                    return
                else:
                    queue.append(cur_node.left_node)
    
                if cur_node.right_node is None:
                    cur_node.right_node = node
                    return
                else:
                    queue.append(cur_node.right_node)
    
    
        def leveltraversal(self):
    
            queue = []
            queue = [self.root]  # 先将跟节点放入队列中
            while queue:
                cur_node = queue.pop(0)
                print(cur_node._ele)
    
                if cur_node.left_node is None:
                    pass
                else:
                    queue.append(cur_node.left_node)
    
                if cur_node.right_node is None:
                    pass
                else:
                    queue.append(cur_node.right_node)
    
        def prevtraversal(self, node):
            '''先序'''
            if node is None:
                 return
            print(node._ele, end='')
            print('')
            self.prevtraversal(node.left_node)
    
            self.prevtraversal(node.right_node)
    
    
    
    
        def infixtraversal(self, node):
            '''中序'''
    
            if node is None:
                return
    
            self.infixtraversal(node.left_node)
            print(node._ele, end='')
            print('')
            self.infixtraversal(node.right_node)
    
    
        def postordertraversal(self, node):
            '''后序'''
    
            if node is None:
                return
            self.postordertraversal(node.left_node)
            self.postordertraversal(node.right_node)
            print(node._ele, end='')
    

      

     

            

    转载于:https://www.cnblogs.com/python-ERIC/p/10747412.html

    展开全文
  • c语言线性表

    2021-05-23 09:09:01
    //输出顺序表h的长度 if(listempty(h)) printf("该单链表空。\n"); else printf("该单链表不空。\n"); //判断顺序表h是否空 getelem(h,3,e);printf("该单链表的第3个元素:"); printf("%c",e); printf("\n...

    next;

    }

    if(p==null)return 0;

    else

    {

    s=(linklist *)malloc(sizeof(linklist));

    s->data=e; s->next=p->next; p->next=s;

    return 1;

    }

    }

    int listdelete(linklist *&l,int i,elemtype &e) //删除数据元素

    {

    int j=0;

    linklist *p=l,*q;

    while(jnext;

    }

    if(p==null)

    return 0;

    else

    {

    q=p->next;

    if(q==null)return 0;

    e=q->data;

    p->next=q->next;

    free(q);

    return 1;

    }

    }

    int main()

    {

    elemtype e,a[5]={'a','b','c','d','e'};

    linklist *h;

    initlist(h); //初始化顺序表h

    createlistr(h,&a[0],5); //依次采用尾插入法插入a,b,c,d,e元素

    printf("单链表为:");

    displist(h); printf("\n"); //输出顺序表h

    printf("该单链表的长度为:");

    printf("%d",listlength(h)); printf("\n"); //输出顺序表h的长度

    if(listempty(h)) printf("该单链表为空。\n");

    else printf("该单链表不为空。\n"); //判断顺序表h是否为空

    getelem(h,3,e);printf("该单链表的第3个元素为:");

    printf("%c",e); printf("\n"); //输出顺序表h的第3个元素

    printf("该单链表中a的位置为:");

    printf("%d",locateelem(h,'a')); printf("\n"); //输出元素'a'的位置

    listinsert(h,4,'f'); //在第4个元素位置插入'f'素

    printf("在第4 个元素位置上插入'f'后单链表为:");

    displist(h); printf("\n"); //输出顺序表h

    listdelete(h,3,e); //删除l的第3个元素

    printf("删除第3个元素后单链表为:");

    displist(h); printf("\n"); //输出顺序表h

    destroylist(h); //释放顺序表h

    return 0;

    }

    展开全文
  • 线性表排序算法排序相关的几个基本概念直接插入排序(简单插入排序)基本思想代码示例性能分析空间复杂度时间复杂度冒泡排序基本思想 排序相关的几个基本概念 排序依据是指数据元素的关键字,若关键字是主关键字...
  • 线性表长度线性表实训)

    千次阅读 2020-04-28 20:40:03
    编写函数listLength函数来求线性表长度。 函数listLength的函数原型: int listLength(node * h); 其中: 参数h链表头指针;...温馨提示:这一关不难,遍历线性表,逐个结点计数即可。 ...
  • 对n个记录的线性表进行快速排序为减少算法的递归(栈)深度,每次分区后,先处理较短的部分。 举个栗子。 现在有这么个序列:123456789 假设每次划分出短序列的长度为1 即第一次划分 短序列:1 长序列:23456789 如果...
  • 最近闲来无事,就顺便把数据结构再复习一下,在此把我刚写的c语言实现的顺序结构线性表送给大家,不要吝啬评论哦。#include "stdio.h"#include "stdlib.h"#include "io.h"#include "math.h"#include "time.h"#define...
  • 线性表(linear list)是数据结构的一种,一个线性表n个具有相同特性的数据元素的有限序列 2、线性表中数据元素之间的关系是一一的关系,即除了第一个和最后一个数据元素之外,其它数据元素都是首尾相接的(注意...
  • 思路:分治思想,将线性表不断对半拆分,拆到只剩一个元素时就进行从小到大归并,递归实现 代码: #include<stdio.h> #include<stdlib.h> #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR ...
  • 线性表-排序 定义 结构体 直接插入排序 简单交换排序 简单选择排序 1.定义基于线性表排序 排序是计算机数据处理的基本操作和重要技术,能有效提高一个数据处理系统的运行效率. 排序设计要的几个要素 1.排序...
  • 线性表长度为10,在最坏情况下,冒泡排序需要比较次数()。 正确答案: D 你的答案: D (正确) 40 42 44 45 添加笔记 求解答(0) 收藏 纠错 冒泡的算法就是 for(int i=0; i<n; ++i) { for...
  • 线性表的插入排序

    千次阅读 2016-09-14 14:46:29
    插入排序算法
  • //线性表当前的长度 }SqList; //创建一个线性表 Status createList(SqList *L) { int i,n; printf("请输入元素的个数:\n"); scanf_s("%d", &n); printf("请输入元素:\n"); for (i = 0; i < n; i++) { ...
  • 线性表

    2018-06-28 21:50:49
    printf("线性表s长度为:%d\n", ListLength(&s)); //再定义一个线性表b SqList b; InitList(&b); ListInsert(&b, 1, 1); ListInsert(&b, 1, 5); ListInsert(&b, 1, 3); ListInsert(&b, 1, 4); ListInsert(&b...
  • 数据结构之线性表-01

    2021-01-19 14:38:19
    线性表 线性表是计算机程序设计活动中最经常用到的一种操作对象,...n时,ai的直接前驱元素ai-1,ai的直接后继数据ai+1.也就是说,除表中的第1个数据元素a1没有前驱元素及最后一个数据元素an没有后继元素外,其他的
  • 长度为n线性表,最坏情况下查找或比较次数: 类型 次数 顺序查找 n 查找最大项或最小项 n-1 二分法查找 log2n 冒泡排序 n(n-1)/2 快速排序 n(n-1)/2 简单插入排序 n(n-1)/2 堆排序 nlog2n ...
  • 【单选题】在长度为 n 的顺序表中进行顺序查找,查找失败时需与键值比较次数是 ( ) 。【单选题】一个具有n个顶点e条边的图中,所有顶点的度数之和等于 ( )。(5.0分)【填空题】假设在有序线性表a[20]上进行折半查找,则...
  • 顺序线性表

    千次阅读 2018-10-03 22:53:37
    1.在长度为n线性表的第i个位置插入一个新的数据item(尾部插入法) 该操作是指在线性表的第i-1个位置与线性表的第i个位置插入一个新的数据元素,使得线性表长度变为n+1,但是在进行插入时首先应该判断线性表...
  • /*线性表的查找 2.6*/ #include using namespace std; #define SIZE 6 int main() { int a[SIZE]={9,2,8,4,5,6}; int elem,i,j=0; cin>>elem; for(i=0;i { if (elem==a[i]) { cout break; } ...
  • 作者最近在复习考博,乘此机会分享一些计算机科学与技术、软件工程等相关专业课程考题,一方面分享给考研、考博、找工作的博友,另一方面也是自己...基础知识,希望您有所帮助,不喜勿喷~还有四天考试,加油!!!
  • 顺序查找的缺点是n较大时,平均查找长度较大,效率低 优点数据元素存储没有要求,顺序存储或链式存储均可;对表中记录的有序性也没有要求 */ #include <stdlib.h> #include<stdio.h> #define LIST_...
  • 对于顺序存储的长度为N线性表,访问结点和增加结点的时间复杂度分别对应O(1)和O(N)。 T 1-2 若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算,则利用顺序表存储最节省时间。 T 1-3 ...
  • 线性表的交换排序

    2016-09-14 16:49:01
    交换排序算法
  • #include <stdio.h> #include<stdlib.h> #define MAXSIZE 100 //顺序表可达到最大长度 #define OK 1 #define OVERFLOW -1 #define ERROR -2 typedef int Status;... //线性表数据类型整...
  • 线性表是很常见数据结构表的一种,一般又细分顺序存储...n为线性表长度 ,若n==0时,线性表为空表。优点:尾插效率高,支持随机访问。缺点:中间插入或者删除效率低。 比如常用的数组和ArrayList。 链表是由一...
  • 1、 对长度为n线性表排序,在最坏情况下,比较次数不是n(n-1)/2的排序方法是A) 快速排序 B) 冒泡排序 C) 直接插入排序 √D) 堆排序2、下列关于栈的叙述正确的是A) 栈按""先进先出""组织数据 √B) 栈按""先进后出"...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,721
精华内容 5,888
关键字:

对长度为n的线性表排序