DAY 9 学习日记&CSP-J初赛知识4：图型数据结构&选择排序

最新推荐文章于 2024-03-28 17:11:10 发布

taoyiwei17_HNCS

最新推荐文章于 2024-03-28 17:11:10 发布

阅读量158

点赞数 2

分类专栏：学习日记文章标签：学习数据结构

本文链接：https://blog.csdn.net/taoyiwei17_QFOI/article/details/132545724

版权

学习日记专栏收录该内容

10 篇文章 0 订阅

订阅专栏

CSP-J初赛知识4

图型数据结构

图的定义

由点和线组成的网格称之为图，其中点称之为顶点或者结点，线称之为边。

图的性质

1. 有向边和无向边

有向边

顾名思义，即有指向方向的边。

无向边

顾名思义，即没有指向方向的边。

2. 关于顶点(在有向图中)

顶点的入度

顶点被箭头指向的数目。

小技巧

有向边的数量=入度和。

顶点的出度

顶点指出的箭头的数目。

小技巧

有向边的数量=出度和。

3. 关于顶点（在无向图中）：顶点的度数

顶点连接的边的数目。

4. 边的权值

若边上有数值，该数值称为“边权”，边权的实际意义可以是长度、费用等。

5. 点的权值

若点上有数值，该数值称为“点权”，点权也可以有若干种实际意义。

6. 路径

从图上一点x到达图上另一点y的通路称为一条路径。

7. 环

若一条路径的起点和终点相同，则称之为环。

8. 连通

若图中两个点有路径，则称该两个点是连通的。

9. 连通图

若一张图中的任意两点都连通，称这张图为连通图。

10. 重边

两个点之间不止一条边时，称这两个点之间的边为重边。

11. 自环

一条边的出点和入点相同，称之为自环。

图的分类

1. 简单图

没有自环、没有重边的图。

2. 有向图和无向图

全部由有向边构成的图称之为有向图，全部由无向边构成的图称之为无向图。

3. 有权图和无权图

边是否有权值区分有权图和无权图。

4. 有环图和无环图

图中是否有环区分有环图和无环图。

5. 稠密图和稀疏图

有很少条边或弧（边的条数|E|远小于|V|²）的图称为稀疏图（sparse graph），边的条数|E|接近|V|²，称为稠密图（densegraph）。简单来说边越多，图就越稠密（其中|V|是结点数的意思，有时也用n来表示）。

图的分类有多种角度，这里不一一介绍了。

图的存储

方法1：邻接矩阵

使用一个二维数组g[i][j]表示点i到点j的边权，该二维数组g[][]称为“邻接矩阵”。

方法2：邻接链表

使用一个链表表示一个点指向的其余顶点，则n个点构成的n条链表表示一张图，这些链表称为“邻接链表”。

优缺点

无论用哪种方式存储图，都可以由存储信息“还原”图的形态和数量关系。邻接矩阵访问效率高，但是存储效率低（空间浪费大，尤其是在存储稀疏图时）；邻接链表访问效率低，但是存储效率高（空间浪费少）。

有关图中边数量的公式

有向图

有向图的边数量最大为|V|*(|V|-1)（其中|V|是结点数的意思，有时也用n来表示）。

无向图

无向图的边数量最大为|V|*(|V|-1) /2（其中|V|是结点数的意思，有时也用n来表示）。

选择排序（Select sorting）

原理

从左到右确定第i个位置的元素。
选择 [i,n] 区间内最值所在的位置pos，交换a[i]和a[pos]。
重复上述两部，直到所有位置确定。

举例：

代码实现

1. C++ 版

void selectSort()
{
    for(int i=1;i<=n;i++)
    {
        int pos=i;
        for(int j=i+1;j<=n;j++)
        {
            if(a[j]<a[pos])
            {
                pos=j;
            }
        }
        swap(a[i],a[pos]);
    }
    return ;
}

2. JAVA 版

import java.util.Arrays;
public class example2 
{
    public static void main(String[] args) 
    {
        int[] selectNums = {25, 63, 78, 45, 132, 7};
        selectSort(selectNums);
        System.out.println(Arrays.toString(selectNums));
 
    }
    public static void swap(int[]nums,int i,int j)
    {
        int temp=nums[i];
        nums[i]=nums[j];
        nums[j]=temp;
    }
    public  static void selectSort(int[] nums)
    {
        for(int i=0;i<nums.length-1;i++)
        {
            int temp=i;
            for(int j=i+1;j<nums.length;j++)
            {
                if(nums[j]<nums[temp])
                    swap(nums,j,temp);
            }
        }
    }
}

3. Python 3.8 版

def selection_sort(data_sort_selection_list):
    minimum_to_maximum = []while len(data_sort_selection_list) > 0:
    time = data_sort_selection_list[0],
    for times in range(len(data_sort_selection_list)):
        if data_sort_selection_list[times] < minimum:
        minimum = data_sort_selection_list[times]
        time = times
        minimum_to_maximum.append(minimum)
        del data_sort_selection_list[time]
return minimum_to_maximumprint(selection_sort([4,6,2,3,3]))

4. Go 版

func SelectionSort(nums []int) []int 
{
    length := len(nums)
    var minIndex, tmp int
    for i := 0; i < length-1; i++ 
    {
        minIndex = i
        for j := i + 1; j < length; j++ 
        {
            if nums[j] < nums[minIndex] 
            { 
                minIndex = j 
            }
        }
        tmp = nums[i]
        nums[i] = nums[minIndex]
        nums[minIndex] = tmp
    }
    return nums
}

5. Javascript 版

function selectionSort(arr) {
            function swap(a, b) {
                let temp = arr[b];
                arr[b] = arr[a];
                arr[a] = temp;
            }
            for (let i = 0; i < arr.length; i++) {
                let minIndex = i;
                for (let j = i + 1; j < arr.length; j++) {
                    if (arr[minIndex] > arr[j]) {
                        minIndex = j;
                    }
                }
                swap(i, minIndex);
            }
        }