【PTA】数据结构与算法------基于顺序表的排序算法函数题

最新推荐文章于 2024-02-02 17:18:17 发布
最新推荐文章于 2024-02-02 17:18:17 发布
阅读量2.7k 收藏 15
点赞数 4
文章标签： 排序算法 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44854473/article/details/131096410
版权

排序题都比较简单，只要掌握算法原理就不难了！

1.直接选择排序：

直接选择排序（Selection Sort）是一种简单直观的排序算法，其基本思想是：每次从待排序的元素中选择最小（或最大）的元素，放到已排序序列的末尾（或开头）。具体实现过程如下：

1. 从待排序序列中选择最小的元素，将其与序列的第一个元素交换位置。

2. 排除第一个元素后，在剩余的元素中选择最小的元素，将其与序列的第二个元素交换位置。

3. 重复以上步骤，直到所有元素都被排序。

直接选择排序的时间复杂度为O(n^2)，不适合处理大规模数据。但是，由于其实现简单，代码易于理解，因此在一些小规模数据的排序中仍然有应用。

 排序过程-----------宏观过程

 例子：

 初始关键字：『 8，5，2，6，9，3，1，4，0，7 』

 第一趟排序后：0，『5，2，6，9，3，1，4，8，7』

 第二趟排序后：0，1，『2，6，9，3，5，4，8，7』

 第三趟排序后：0，1，2，『6，9，3，5，4，8，7』

 第四趟排序后：0，1，2，3，『9，6，5，4，8，7』

 第五趟排序后：0，1，2，3，4，『6，5，9，8，7』

 第六趟排序后：0，1，2，3，4，5，『6，9，8，7』

 第七趟排序后：0，1，2，3，4，5，6，『9，8，7』

 第八趟排序后：0，1，2，3，4，5，6，7，『8，9』

 第九趟排序后：0，1，2，3，4，5，6，7，8，『9』

 结果：          『 0，1，2，3，4，5，6，7，8，9 』
【PTA】中的题目：

基于顺序表的直接选择排序

本题要求实现基于顺序表的直接选择排序算法，要求打印出每一趟的排序结果。顺序表的结构体定义如下：

typedef int DataType;                                
#define LISTSIZE 100                                
typedef struct
{
    DataType list[LISTSIZE];
    int length;
}SqList;

函数接口定义：

void SelectSort(SqList *L)

L 是用户传入的参数，代表待排序的顺序表，也是排序后返回的顺序表。要求打印出每一趟的排序结果。

裁判测试程序样例：

#include <stdio.h>
typedef int DataType;                                // 定义具体数据类型

#define LISTSIZE 100                                // LISTSIZE 表示顺序表可能的最大数据元素数目

/****** 顺序表存储结构 ******/
typedef struct
{
    DataType list[LISTSIZE];
    int length;
}SqList;


/****** 初始化顺序表 ******/
int InitList(SqList *L)                // L为指向顺序表的指针
{
    L->length = 0;            
    return 1;
}

/****** 求顺序表表长 ******/
int ListLenth(SqList L)                // L为顺序表
{
    return L.length;        
}

/****** 判断顺序表是否为空 ******/
int ListEmpty(SqList L)                // L为顺序表
{
    if (L.length <= 0)        
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

/****** 向顺序表插入元素 ******/
int ListInsert(SqList *L, int pos, DataType item)
{                                    // L为指向顺序表的指针，pos为插入位置，item为待插入的数据元素
    int i;

    if (L -> length >= LISTSIZE)    // 判断顺序表是否已满
    {                                
        printf("顺序表已满，无法插入\n");
        return 0;
    }

    if (pos <= 0 || pos > L -> length + 1)
    {                                // 检查元素插入位置是否在顺序表里
        printf("插入位置不合法\n");
        return 0;
    }

    for (i = L -> length - 1; i >= pos - 1; i--)
    {                                // 移动数据元素
        L -> list[i + 1] = L -> list[i];
    }

    L -> list[pos - 1] = item;        // 插入元素
    L -> length++;                    // 表长加一

    return 1;
}


/****** 遍历顺序表 ******/
int TraverList(SqList L)            // L为顺序表
{                        
    int i;
    for(i = 0; i < L.length; i++)
    {
        printf("%d ", L.list[i]);
    }
    printf("\n");
    return 1;
}

void swap(SqList *L, int i, int j)
{
    DataType temp = L->list[i];
    L->list[i] = L->list[j];
    L->list[j] = temp;
}
void SelectSort(SqList *L);
int main()
{
    SqList L;
    DataType x;
    char ch;
    int pos = 1;
    InitList(&L);
    do
    {  
        scanf("%d",&x); // 某些编译器要求此处改为scanf_s
        ListInsert( &L , pos++ , x );        
    }while ((ch=getchar())!='\n');
    SelectSort(&L);
    printf("The sorted List is\n");
    TraverList(L);
    return 0;
}

/* 请在这里填写答案 */

输入样例：

23 45 12 20 31

输出样例：

12 45 23 20 31 
12 20 23 45 31 
12 20 23 45 31 
12 20 23 31 45 
The sorted List is
12 20 23 31 45

答案解析：

void SelectSort(SqList *L)
{
    int i, j, min;
    int p;
    for(i=0;i<L->length-1;i++)
    {
        min = i;
        for(j=i+1;j<L->length;j++)
        {
            if(L->list[j]<L->list[min])
            {
                min = j;
            }
        }
            if(min!=i)
            {
                p=L->list[i];
                L->list[i]=L->list[min];
                L->list[min] = p;
            }
        
        TraverList(*L);
    }
}

---------------------------------------------------------------------------------------------------------------------------------

直接插入排序：

直接插入排序（Insertion Sort）是一种简单直观的排序算法，其基本思想是：将待排序元素插入到已排序序列中的合适位置，使得插入后仍然保持有序。具体实现过程如下：

1. 将序列的第一个元素视为已排序序列，其他元素视为待排序序列。

2. 从待排序序列中取出第一个元素，与已排序序列中的元素从后往前比较，找到合适的位置插入。

3. 重复以上步骤，直到所有元素都被排序。

直接插入排序的时间复杂度为O(n^2)，同样不适合处理大规模数据。但是，与直接选择排序相比，直接插入排序的比较次数较少，交换次数也较少，因此在一些小规模数据的排序中比直接选择排序更加高效。
在这里插入图片描述

 【PTA】中题目：

 基于顺序表的直接插入排序

本题要求实现基于顺序表的直接插入排序算法，要求打印出每一趟的排序结果。顺序表的结构体定义如下

typedef int DataType;                                
#define LISTSIZE 100                                
typedef struct
{
    DataType list[LISTSIZE];
    int length;
}SqList;

函数接口定义：

void InsertSort(SqList *L)

L 是用户传入的参数，代表待排序的顺序表，也是排序后返回的顺序表。要求打印出每一趟的排序结果。

裁判测试程序样例：

#include <stdio.h>
typedef int DataType;                                // 定义具体数据类型

#define LISTSIZE 100                                // LISTSIZE 表示顺序表可能的最大数据元素数目

/****** 顺序表存储结构 ******/
typedef struct
{
    DataType list[LISTSIZE];
    int length;
}SqList;


/****** 初始化顺序表 ******/
int InitList(SqList *L)                // L为指向顺序表的指针
{
    L->length = 0;            
    return 1;
}

/****** 求顺序表表长 ******/
int ListLenth(SqList L)                // L为顺序表
{
    return L.length;        
}

/****** 判断顺序表是否为空 ******/
int ListEmpty(SqList L)                // L为顺序表
{
    if (L.length <= 0)        
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

/****** 向顺序表插入元素 ******/
int ListInsert(SqList *L, int pos, DataType item)
{                                    // L为指向顺序表的指针，pos为插入位置，item为待插入的数据元素
    int i;

    if (L -> length >= LISTSIZE)    // 判断顺序表是否已满
    {                                
        printf("顺序表已满，无法插入\n");
        return 0;
    }

    if (pos <= 0 || pos > L -> length + 1)
    {                                // 检查元素插入位置是否在顺序表里
        printf("插入位置不合法\n");
        return 0;
    }

    for (i = L -> length - 1; i >= pos - 1; i--)
    {                                // 移动数据元素
        L -> list[i + 1] = L -> list[i];
    }

    L -> list[pos - 1] = item;        // 插入元素
    L -> length++;                    // 表长加一

    return 1;
}


/****** 遍历顺序表 ******/
int TraverList(SqList L)            // L为顺序表
{                        
    int i;
    for(i = 0; i < L.length; i++)
    {
        printf("%d ", L.list[i]);
    }
    printf("\n");
    return 1;
}
void InsertSort(SqList *L);
int main()
{
    SqList L;
    DataType x;
    char ch;
    int pos = 1;
    InitList(&L);
    do
    {  
        scanf("%d",&x); // 某些编译器要求此处改为scanf_s
        ListInsert( &L , pos++ , x );        
    }while ((ch=getchar())!='\n');
    InsertSort(&L);
    printf("The sorted List is\n");
    TraverList(L);
    return 0;
}

/* 请在这里填写答案 */

输入样例：

23 45 12 20 31

输出样例：

23 45 12 20 31 
12 23 45 20 31 
12 20 23 45 31 
12 20 23 31 45 
The sorted List is
12 20 23 31 45

答案解析：

void InsertSort(SqList *L)
{
    int i, j;
    int p;
    for(i=1;i<L->length;i++)
    {
        p=L->list[i];
        for(j=i-1;j>=0&&p<L->list[j];j--)
        {
            L->list[j+1] = L->list[j];
        }
            L->list[j+1] = p;
        
        TraverList(*L);
    }
}

---------------------------------------------------------------------------------------------------------------------------------

冒泡算法属于最基本的排序算法，但是主要分为两种：重者沉和轻者浮。二者有相似也有不同之处，由于很容易理解就不做图文展示了。

【PTA】中的考题如下：

基于顺序表的冒泡排序（重者沉）

本题要求实现基于顺序表的“重者沉”的冒泡排序算法，就是第一趟排序把最大值排到表尾，第二趟排序把次大值排到表尾倒数第二位，以此类推。最后要求打印出每一趟的排序结果。顺序表的结构体定义如下

typedef int DataType;                                
#define LISTSIZE 100                                
typedef struct
{
    DataType list[LISTSIZE];
    int length;
}SqList;

函数接口定义：

void BubbleSort(SqList *L);

L 是用户传入的参数，代表待排序的顺序表，也是排序后返回的顺序表。要求打印出每一趟的排序结果。

裁判测试程序样例：

#include <stdio.h>
typedef int DataType;                                // 定义具体数据类型

#define LISTSIZE 100                                // LISTSIZE 表示顺序表可能的最大数据元素数目

/****** 顺序表存储结构 ******/
typedef struct
{
    DataType list[LISTSIZE];
    int length;
}SqList;


/****** 初始化顺序表 ******/
int InitList(SqList *L)                // L为指向顺序表的指针
{
    L->length = 0;            
    return 1;
}

/****** 求顺序表表长 ******/
int ListLenth(SqList L)                // L为顺序表
{
    return L.length;        
}

/****** 判断顺序表是否为空 ******/
int ListEmpty(SqList L)                // L为顺序表
{
    if (L.length <= 0)        
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

/****** 向顺序表插入元素 ******/
int ListInsert(SqList *L, int pos, DataType item)
{                                    // L为指向顺序表的指针，pos为插入位置，item为待插入的数据元素
    int i;

    if (L -> length >= LISTSIZE)    // 判断顺序表是否已满
    {                                
        printf("顺序表已满，无法插入\n");
        return 0;
    }

    if (pos <= 0 || pos > L -> length + 1)
    {                                // 检查元素插入位置是否在顺序表里
        printf("插入位置不合法\n");
        return 0;
    }

    for (i = L -> length - 1; i >= pos - 1; i--)
    {                                // 移动数据元素
        L -> list[i + 1] = L -> list[i];
    }

    L -> list[pos - 1] = item;        // 插入元素
    L -> length++;                    // 表长加一

    return 1;
}


/****** 遍历顺序表 ******/
int TraverList(SqList L)            // L为顺序表
{                        
    int i;
    for(i = 0; i < L.length; i++)
    {
        printf("%d ", L.list[i]);
    }
    printf("\n");
    return 1;
}

void swap(SqList *L, int i, int j)
{
    DataType temp = L->list[i];
    L->list[i] = L->list[j];
    L->list[j] = temp;
}
void BubbleSort(SqList *L);
int main()
{
    SqList L;
    DataType x;
    char ch;
    int pos = 1;
    InitList(&L);
    do
    {  
        scanf("%d",&x);  // 某些编译器要求此处改为scanf_s
        ListInsert( &L , pos++ , x );        
    }while ((ch=getchar())!='\n');
    BubbleSort(&L);
    printf("The sorted List is\n");
    TraverList(L);
    return 0;
}
/* 请在这里填写答案 */

输入样例：

23 45 12 20 31

输出样例：

23 12 20 31 45 
12 20 23 31 45 
The sorted List is
12 20 23 31 45

答案解析：

 

void BubbleSort(SqList* L)
{
    int i, j;
    int flag ;

    for (i = 0; i < L->length-1; i++)
    {
        flag = 1;
        for (j = 0; j < L->length - 1 - i; j++)
        {
            if (L->list[j + 1] < L->list[j])
            {
                swap(L, j, j + 1);
                flag = 0;
            }
        }
        if (flag == 1)
        {
            break;
        }
        TraverList(*L);
    }
}

基于顺序表的冒泡排序（轻者浮）

本题要求实现基于顺序表的“轻者浮”的冒泡排序算法，就是第一趟排序把最小值排到表首，第二趟排序把次小值排到表首第二位，以此类推。最后要求打印出每一趟的排序结果。顺序表的结构体定义如下

 

typedef int DataType;                                
#define LISTSIZE 100                                
typedef struct
{
    DataType list[LISTSIZE];
    int length;
}SqList;
 

函数接口定义：
 

void BubbleSort(SqList *L);
 

L 是用户传入的参数，代表待排序的顺序表，也是排序后返回的顺序表。要求打印出每一趟的排序结果。
 

裁判测试程序样例：
 

#include <stdio.h>
typedef int DataType;                                // 定义具体数据类型
#define LISTSIZE 100                                // LISTSIZE 表示顺序表可能的最大数据元素数目
/****** 顺序表存储结构 ******/
typedef struct
{
    DataType list[LISTSIZE];
    int length;
}SqList;
/****** 初始化顺序表 ******/
int InitList(SqList* L)                // L为指向顺序表的指针
{
    L->length = 0;
    return 1;
}
/****** 求顺序表表长 ******/
int ListLenth(SqList L)                // L为顺序表
{
    return L.length;
}
/****** 判断顺序表是否为空 ******/
int ListEmpty(SqList L)                // L为顺序表
{
    if (L.length <= 0)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
/****** 向顺序表插入元素 ******/
int ListInsert(SqList* L, int pos, DataType item)
{                                    // L为指向顺序表的指针，pos为插入位置，item为待插入的数据元素
    int i;
    if (L->length >= LISTSIZE)    // 判断顺序表是否已满
    {
        printf("顺序表已满，无法插入\n");
        return 0;
    }
    if (pos <= 0 || pos > L->length + 1)
    {                                // 检查元素插入位置是否在顺序表里
        printf("插入位置不合法\n");
        return 0;
    }
    for (i = L->length - 1; i >= pos - 1; i--)
    {                                // 移动数据元素
        L->list[i + 1] = L->list[i];
    }
    L->list[pos - 1] = item;        // 插入元素
    L->length++;                    // 表长加一
    return 1;
}
/****** 遍历顺序表 ******/
int TraverList(SqList L)            // L为顺序表
{
    int i;
    for (i = 0; i < L.length; i++)
    {
        printf("%d ", L.list[i]);
    }
    printf("\n");
    return 1;
}
/* 交换顺序表里下标为i和j的两个结点 */
void swap(SqList* L, int i, int j)               
{
    DataType temp = L->list[i];
    L->list[i] = L->list[j];
    L->list[j] = temp;
}
/* 本题要求函数 */
void BubbleSort(SqList* L);                
int main()
{
    SqList L;
    DataType x;
    char ch;
    int pos = 1;
    InitList(&L);
    do
    {
        scanf("%d", &x);   // 某些编译器要求此处改为scanf_s
        ListInsert(&L, pos++, x);
    } while ((ch = getchar()) != '\n');
    BubbleSort(&L);
    printf("The sorted List is\n");
    TraverList(L);
    return 0;
}
/* 请在这里填写答案 */
 

 

输入样例：
 

23 45 12 20 31


 

输出样例：
 

12 23 45 20 31 
12 20 23 45 31 
12 20 23 31 45 
The sorted List is
12 20 23 31 45 

 

 答案解析：
 

void BubbleSort(SqList* L)
{
    int i, j;
    int flag;

    for (i = 0; i < L->length - 1; i++)
    {
        flag = 1;
        for (j = L->length - 1; j > i; j--)
        {
            if (L->list[j -1] > L->list[j])
            {
                swap(L, j,j - 1);
                flag = 0;
            }
       }
        if (flag == 1)
        {
            break;
        }
        TraverList(*L);
    }
}
 

注意对比二者的差别方便记忆。

                

        

        

    




    

      

        

            

              
                
                  落影长
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    4
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    15
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
【考研数据结构分类讲解练习】 6-2 排序-选择题--答案讲解篇

				
			

			

				

					Anthony_4926
				

				

					08-21
					
					1155
					
				

			

		

		

			
				
散列函数构造方法

直接定址法
	除留取余法
	数字分析法
	平法取中法
处理冲突的方法

开放地址法
	
	


			
		

	



                

              
                



	

		

			

				
					
PTA-选择排序法

				
			

			

				

					m0_73963762的博客
				

				

					02-15
					
					3579
					
				

			

		

		

			
				
PTA-选择排序法-C语言

输入10个无序的整数，用选择法对10个整数按升序排序。注意：要求排序只排3轮。

输入格式:
在一行中输入10个用空格间隔的无序整数。

输出格式:
在一行中输出变化后的数组，每个整数输出占5列。

			
		

	



                


  
              

                


	

		

			

				
					
PTA:7-9 选择法排序之过程(python和c)

				
			

			

				

					HGGshiwo的博客
				

				

					05-18
					
					6083
					
				

			

		

		

			
				
#7-9 选择法排序之过程 (15 分)
本题要求使用选择法排序，将给定的n个整数从小到大排序后输出，并输出排序过程中每一步的中间结果。
选择排序的算法步骤如下：
第0步：在未排序的n个数（a[0]〜 a[n−1]）中找到最小数，将它与 a[0]交换；
第1步：在剩下未排序的n−1个数（a[1] 〜 a[n−1]）中找到最小数，将它与 a[1] 交换；
……
第k步：在剩下未排序的n−k个数（）中找到最小数，将它与 a[k] 交换；
……
第n−2步：在剩下未排序的2个数（a[n−2] 〜a[n−1]）中.

			
		

	





	

		

			

				
					
6-15 基于顺序表的直接选择排序 (10分)

				
			

			

				

					MRcccccccc的博客
				

				

					06-12
					
					2868
					
				

			

		

		

			
				
本题要求实现基于顺序表的直接选择排序算法，要求打印出每一趟的排序结果。顺序表的结构体定义如下

函数接口定义：
void SelectSort(SqList *L)


L 是用户传入的参数，代表待排序的顺序表，也是排序后返回的顺序表。要求打印出每一趟的排序结果。
裁判测试程序样例：
#include <stdio.h>

int InitList(SqList *L);                      /* 初始化顺序表 */
int ListInsert(SqList *L, in

			
		

	



		

			
		



	

		

			

				
					
PTA-选择法排序

				
			

			

				

					m0_74316503的博客
				

				

					11-28
					
					2962
					
				

			

		

		

			
				
这是一个简单而直观的选择排序算法实现。虽然代码可以进一步优化（例如，可以减少变量mark和t的使用），但总体上，它有效地实现了选择排序算法。

			
		

	





	

		

			

				
					
排序 - 直接插入排序

				
			

			

				

					YY_Song 's blogs
				

				

					03-13
					
					504
					
				

			

		

		

			
				
直接插入排序算法代码理解测试代码运行结果复杂度参考资料
算法
直接插入排序（Straight Insertion Sort）的基本操作：
将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增1的有序表。

注意：
在我们的排序问题中，通常将 数据元素 称为 记录。

代码
理解
测试代码
运行结果
复杂度
参考资料

【1】程杰. 大话数据结构. 北京：清华大学出版社，2011：2.


...

			
		

	





	

		

			

				
					
PTA（拼题A）-浙江大学中国大学mooc数据结构全AC代码与题目解析（C语言）.zip

					
最新发布

				
			

			

				

					06-16
				

			

		

		

			
				
本资源包“PTA（拼题A）-浙江大学中国大学mooc数据结构全AC代码与题目解析（C语言）.zip”是针对浙江大学MOOC（大规模在线开放课程）的数据结构课程的一个宝贵学习资料，主要涵盖了C语言实现的数据结构解决方案和...

			
		

	





	

		

			

				
					
PTA数据结构答案

				
			

			

				

					08-24
				

			

		

		

			
				
例如，"PTA数据结构答案"中的C或C++代码可能包括实现栈和队列的操作、二分查找、树的遍历、图的搜索算法等。解题过程会涉及到动态规划、贪心策略、回溯法等算法思想。这些实践性的题目对于提高编程能力、备战ACM/...

			
		

	





	

		

			

				
					
pta题库答案c语言之线性结构1两个有序链表序列的合并.zip

				
			

			

				

					05-01
				

			

		

		

			
				
在本题“pta题库答案c语言之线性结构1两个有序链表序列的合并”中，主要涉及的是如何合并两个已经排序好的链表，这是一项在数据结构和算法学习中常见的操作。下面将详细介绍这一知识点。  首先，链表是一种动态数据...

			
		

	





	

		

			

				
					
数据结构实验一.rar

				
			

			

				

					04-29
				

			

		

		

			
				
1.建立一个顺序表，随机产生10个100以内的整数，并按要求完成:(1）编写显示函数，在屏幕上显示顺序表中的10个整数; (2）编写查找函数，从键盘输入任-一-整数在顺序表中查找，若找到，返回该元素在顺序表中的位置,...

			
		

	





	

		

			

				
					
pta题库答案c语言之线性结构3ReversingLinkedList.zip

				
			

			

				

					05-01
				

			

		

		

			
				
理解并熟练掌握链表逆序不仅有助于解决编程题，还能为其他更复杂的算法和数据结构打下坚实基础。  在解决此类问题时，要特别注意边界条件，如空链表和只有一个节点的链表。此外，由于C语言不提供自动内存管理，所以...

			
		

	





	

		

			

				
					
排序算法之插入排序的C++实现

				
			

			

				

					xiahangli1的专栏
				

				

					04-12
					
					1275
					
				

			

		

		

			
				
排序(Sorting)是程序设计里面的一种重要的操作，它的功能是  
将原本无序的数据元素集合或序列按照一定规则排列成有序的序列  
排序常用在查找过程中。本文介绍一个简单的插入排序算法

			
		

	





	

		

			

				
					
用C语言实现八大排序算法(附有PTA例题测试每个排序算法的速度以及每个排序法的动图总结)

				
			

			

				

					cczj0的博客
				

				

					05-15
					
					2257
					
				

			

		

		

			
				
八大排序算法：
先上测试的PTA例题：
给定N个（长整型范围内的）整数，要求输出从小到大排序后的结果。
本题旨在测试各种不同的排序算法在各种数据情况下的表现。各组测试数据特点如下：

数据1：只有1个元素；
数据2：11个不相同的整数，测试基本正确性；
数据3：1e3个随机整数；
数据4：1e4个随机整数；
数据5：1e5个随机整数；
数据6：1e5个顺序整数；
数据7：1e5个逆序整数；
数据8：1e5个基本有序的整数；
数据9：1e5个随机正整数，每个数字不超过1000。

输入格式:

输入第一行给出

			
		

	





	

		

			

				
					
【算法排序】直接插入排序详解与实现

				
			

			

				

					山赶着山，山山漫漫结成关
				

				

					05-24
					
					4685
					
				

			

		

		

			
				
插入排序(InsertionSort)，一般也被称为直接插入排序。对于少量元素的排序，它是一个有效的算法。插入排序是一种最简单的排序方法，它的基本思想是将一个记录插入到已经排好序的有序表中，从而一个新的、记录数增 1 的有序表。在其实现过程使用双层循环，外层循环对除了第一个元素之外的所有元素，内层循环对当前元素前面有序表进行待插入位置查找，并进行移动。

			
		

	





	

		

			

				
					
排序之直接插入排序

				
			

			

				

					weixin_46002185的博客
				

				

					01-26
					
					613
					
				

			

		

		

			
				
直接插入排序
扑克牌是我们几乎每个人都可能玩过的游戏。最基本的扑克玩法都是一边摸牌，一边理牌。假如我们拿到了这样一手牌，如图所示。啊，似乎是同花顺呀，别急，我们得理一理顺序才知道是否是真的同花顺。请问，如果是你，应该如何理牌呢？

将 3 和 4 移动到 5 的左侧，再将 2 移动到最左侧，顺序就算是理好了。这里，我们的理牌方法，就是直接插入排序法。
1.直接插入排序算法
直接插入排序（Straight Insertion Sort）的基本操作是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数

			
		

	





	

		

			

				
					
顺序表实现直接插入排序

				
			

			

				

					AlberTesla的博客
				

				

					11-22
					
					1798
					
				

			

		

		

			
				
/*
	Author:Albert Tesla Wizard
	Time:2020/11/22 10:24
*/
#include<bits/stdc++.h>
#define MAXSIZE 1000
using namespace std;
struct Sqlist
{
    int* elem;
    int length;
};
int create(Sqlist&L,int a[],int n)
{
    L.elem=new int[MAXSIZE];
    L.l

			
		

	





	

		

			

				
					
数据结构基于顺序表相关的排序算法

				
			

			

				

					weixin_46144832的博客
				

				

					05-30
					
					564
					
				

			

		

		

			
				
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define maxsize 500
//定义顺序表
typedef struct SSTable{
    int data[maxsize];
    int len;
}SSTable;
//初始化顺序表
void InitList(SSTable &ST){
    for(int i=0;i<maxsize;i++){
      .

			
		

	





	

		

			

				
					
pta c语言 选择法排序

				
			

			

				

					qq_74307999的博客
				

				

					11-09
					
					1688
					
				

			

		

		

			
				
c语言选择法排序pta

			
		

	





	

		

			

				
					
PTA-C语言题库-选择排序（选择排序、冒泡排序+解法+解析）

				
			

			

				

					MoBai0619的博客
				

				

					02-02
					
					1148
					
				

			

		

		

			
				
本题要求将给定的n个整数从大到小排序后输出。输入格式：输入第一行给出一个不超过10的正整数n。第二行给出n个整数，其间以空格分隔。输出格式：在一行中输出从大到小有序的数列，相邻数字间有一个空格，行末不得有多余空格。

			
		

	





	

		

			

				
					
PTA最短路径算法R6-1

				
			

			

				

					05-31
				

			

		

		

			
				
PTA最短路径算法R6-1是一道题目，需要使用Dijkstra算法求解。具体题目描述如下：  给定一个有向带权图，节点从0到n-1编号，求0号节点到n-1号节点的最短路径长度，如果无法从0号节点走到n-1号节点，输出-1。  输入...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值