数据结构课设——排序综合(C语言)

已于 2023-03-28 08:35:53 修改
阅读量2k 收藏 45
点赞数 21
分类专栏： C 文章标签： 数据结构 c语言 排序算法
于 2023-01-05 10:16:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_60781793/article/details/128558620
版权
本文详细介绍了C语言实现的六种排序算法，包括插入排序、希尔排序、冒泡排序、快速排序、选择排序和归并排序，并提供了每种排序方法的步骤、时间复杂度和空间复杂度。此外，程序还统计了每种排序方法的性能，通过比较运行时间来找出最快的方法。
摘要由CSDN通过智能技术生成

数据结构课设——排序综合(C语言)

文章目录

题目

利用随机函数产生N个随机整数（20000以上）,对这些数进行多种方法进行排序。

要求：

  1. 至少采用四种方法实现上述问题求解（提示，可采用的方法有插入排序、希尔排序、冒泡排序、快速排序、选择排序、堆排序、归并排序）。并把排序后的结果保存在不同的文件中。
  2. 统计每一种排序方法的性能（以上机运行程序所花费的时间为准进行对比，），找出其中两种较快的方法。

本程序中用到了6种排序方法。

随机数的生成

srand((unsigned)time(NULL));

srand用来初始化随机种子，会提供一个种子，这个种子会对应一个随机数。
为了防止随机数每次重复，这里使用系统时间来作为随机种子。

1.插入排序

步骤

  1. 从第一个元素开始，该元素可以认为已经被排序
  2. 取下一个元素temp,从已排序的元素序列从后往前遍历
  3. 如果该元素大于temp,则将该元素移到下一位
  4. 重复步骤3，直到找到已排序元素中小于等于temp的元素
  5. temp插入到元素的后面，如果已排序的元素都大于temp，则将temp插入到下标为0的位置
  6. 重复步骤2~5

动图演示如下:
selectionSort.gif

void insertSort()
{
    for (int i = 1; i < CAPACITY; i++)
	{
		int temp = array[i];
		int j = i - 1;
		while (j >= 0)
		{
			//说明前面已经有序了
			if (array[j] <= temp)
			{
				break;
			}
			//移动j的值到j+1
			array[j + 1] = array[j];
			j--;
		}
		array[j + 1] = temp;
	}
}
  • 时间复杂度:最坏情况:O( N 2 N^2 N2),最好情况 O(N)
  • 空间复杂度:O(1)
  • 稳定性:稳定

2.希尔排序

希尔排序又称缩小增量法

步骤

  1. 先定义一下分组个数gap
  2. 把整个数组分成gap个组，每个组里有CAPACITY/gap个元素
  3. 把每个小组分别用插入方式排序
  4. 逐渐缩小这个gap，直到gap=1时，全部排序完成

shell.gif
image.png

void shellSort()
{
	int gap = CAPACITY / 2;
	while (gap > 0)
	{
		shell( gap);
		gap /= 2;
	}
}
//核心代码
void shell( int gap)
{

	for (int i = gap; i < CAPACITY; i++) 
	{
		int temp = array[i];
		int j = i - gap;
		while (j >= 0)
		{
			if (array[j] <= temp) 
			{
				break;
			}
			array[j + gap] = array[j];
			j -= gap;
		}
		array[j + gap] = temp;
	}
}
  • 时间复杂度:O( N 1.25 N^{1.25} N1.25) ~ O( N 1.5 N^{1.5} N1.5)
  • 空间复杂度:O(1)
  • 稳定性:不稳定

3.冒泡排序

左边大于右边交换一趟排下来最大的在右边
bubble.gif

void bubbleSort()
{
	for (int i = 0; i < CAPACITY - 1; i++) {
		int set = 0;
		for (int j = 0; j < CAPACITY - 1 - i; j++) 
		{
			if (array[j] > array[j + 1]) 
			{
				swap(j, j + 1);
				set = 1;
			}
			
		}
		if (set==0)
		{
			break;
		}
		
	}
}
void swap(int left, int right)
{
	int temp = array[left];
	array[left] = array[right];
	array[right] = temp;
}
  • 时间复杂度:O( N 2 N^2 N2)
  • 空间复杂度:O(1)
  • 稳定性:稳定

4.快速排序

挖坑法找基准

  1. left下标的值当做默认的基准值，这时left的位置就空出来了
  2. right向左移动，找到比基准值小的值，放到left的位置
  3. left向右移动，找到比基准值大的值，放到right的位置
  4. 当left 与right相遇时，把之前记录的基准值放在相遇的下标
  5. 返回相遇点下标，这就是基准的下标

quic.gif

//快速排序
void quickSort()
{
	const int N = 1e2;
    start = clock();

	quickSortProcess(0, CAPACITY - 1);

	end = clock();
	printf("time: %f s\n", ((double)(end - start)) / CLOCKS_PER_SEC / N);

}
//核心代码
void quickSortProcess(int left, int right)
{
	if (left>=right)
	{
		return;
	}
	//找基准
	int pivot= partitionHole(left, right);
	quickSortProcess(left, pivot);
	quickSortProcess( pivot+1,right);

}

int partitionHole(int left, int right)
{
	int pivotValue = array[left];
	
	while (left < right) 
	{
		while (right > left && array[right] >= pivotValue) 
		{
			right--;
		}
		array[left] = array[right];
		while (left < right && array[left] <= pivotValue) 
		{
			left++;
		}
		array[right] = array[left];
	}
	array[left] = pivotValue;
	return left;
}

  • 时间复杂度：O(N* l o g N logN logN)

  • 空间复杂度：O( l o g N logN logN)

  • 稳定性:不稳定

5.选择排序

步骤

  1. 定义数组边界，left=0,right=CAPACITY-1
  2. 定义i用来遍历
  3. 定义最小值下标minIndex=left,maxIndex=left
  4. 在i遍历的过程中，找到比最小值小的元素更新minIndex,找到比最大值大的元素更新maxIndex
  5. 一轮遍历完成后，left与minIndex交换，right与maxIndex交换
  6. 循环终止条件是left<rigth

select.gif

//选择排序
void selectSort()
{
	int left = 0;
	int right = CAPACITY - 1;
	while (left < right) 
	{
		int minIndex = left;
		int maxIndex = left;
		//找最大值和最小值
		for (int i = left + 1; i <= right; i++) 
		{
			if (array[i] < array[minIndex]) 
			{
				minIndex = i;
			}
			if (array[i] > array[maxIndex]) 
			{
				maxIndex = i;
			}
		}
		if (left != minIndex) 
		{
			swap(left, minIndex);
		}
		if (left == maxIndex) 
		{
			minIndex = maxIndex;
		}
		if (right != maxIndex) 
		{
			swap(right, maxIndex);
		}
		left++;
		right--;
	}
}
  • 时间复杂度:O( N 2 N^2 N2)
  • 空间复杂度:O(1)
  • 稳定性:不稳定

6.归并排序

步骤

  1. 把大数组分解成若干个小数组

  2. 把小数组做归并操作，并在归并的过程中完成排序

    1. 在归并的过程中，需要用到一个临时数组来存储排序好的数据，那么这个数组的容量为 right-left+1
    2. 确定每个小数组的开始与结束下标
    3. 合并两个数组，合并的方法可以参考合并有序数组的过程
      1. 两个数组都不为空的情况下，比当前位置元素的大小，小的那一个直接加入到临时数组里
      2. 如果两个数组的元素个数不一样多，那么就要处理有剩余元素的数组，直接把剩余元素追加到临时数组里

  3. 把临时数组中排序好的元素，覆盖到原数组对应的下标

image.png

//归并排序
void mergeSort()
{
    mergeSortProcessor( 0, CAPACITY - 1);
}
void mergeSortProcessor(int left, int right)
{
    //1、终止条件
    if (left >= right) {
        return;
    }
    //2、找中间下标
    int mid = (left + right) / 2;
    //3、分解左右区段
    mergeSortProcessor( left, mid);
    mergeSortProcessor( mid + 1, right);
    //4、合并
    marge( left, mid, right);
}
void marge(int left, int mid, int right)
{
    //1、创建临时数组
    //int n = (right - left + 1);

    int *temp=(int*)malloc((right - left + 1)*sizeof(int));
    int index = 0;
    //2、确定每个小数组的下标
    int start1 = left;
    int end1 = mid;
    int start2 = mid + 1;
    int end2 = right;
    //3、合并
    while (start1 <= end1 && start2 <= end2) {
        if (array[start1] < array[start2]) {
            temp[index++] = array[start1++];
        }
        else {
            temp[index++] = array[start2++];
        }
    }
    //剩余元素添加到temp中
    while (start1 <= end1) {
        temp[index++] = array[start1++];
    }
    while (start2 <= end2) {
        temp[index++] = array[start2++];
    }
    //4、temp写到原数组中
    for (int i = 0; i < index; i++) {
        array[i + left] = temp[i];
    }
    free(temp);
    temp = NULL;
}
  • 时间复杂度:O(N* l o g N logN logN)
  • 空间复杂度:O(N)
  • 稳定性:稳定

完整代码

sort.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
#define CAPACITY 20000
int array[CAPACITY];
clock_t start, end;


void initArray();
void save(char* name1);
void dispaly();
void swap(int i, int minIndex);
//插入排序
void insertSort();
//希尔排序
void shellSort();
void shell(int gap);
//冒泡排序
void bubbleSort();
//快速排序
void quickSort();
void quickSortProcess(int left, int right);
int partitionHole(int left, int right);

//选择排序
void selectSort();

//归并排序
void mergeSort();
void mergeSortProcessor(int left, int right);
void marge(int left, int mid, int right);

sort.c

#include"sort.h"
void initArray()
{
	srand((unsigned)time(NULL));
	for (int i = 0; i < CAPACITY; i++)
	{
		array[i] = rand();
	}

}

void save(char* name1)
{
	FILE* fp;

	char* name2 = ".txt";
	char* name = (char*)malloc(strlen(name1) + strlen(name2));
	strcpy(name, name1);
	strcat(name, name2);
	fp = fopen(name, "w");
	int count = 0;
	for (int i = 0; i < CAPACITY; i++)
	{
		fprintf(fp, "%6d", array[i]);
		count++;
		if (count%100==0)
		{
			fprintf(fp, "\n");
		}
	}
	fclose(fp);
}

void dispaly()
{
	int count = 0;

	for (int i = 0; i < CAPACITY; i++)
	{
		printf("%6d", array[i]);
		count++;
		if (count % 20 == 0)
		{
			printf("\n");
		}

	}
	printf("\n");

}

//插入排序
void insertSort()
{
	const int N = 1e2;
	start = clock();
	for (int i = 1; i < CAPACITY; i++)
	{
		int temp = array[i];
		int j = i - 1;
		while (j >= 0)
		{
			//说明前面已经有序了
			if (array[j] <= temp)
			{
				break;
			}
			//移动j的值到j+1
			array[j + 1] = array[j];
			j--;
		}
		array[j + 1] = temp;
	}
	end = clock();
	printf("time: %f s\n", ((double)(end - start)) / CLOCKS_PER_SEC / N);
}


//希尔排序
void shellSort()
{
	const int N = 1e2;
	start = clock();
	int gap = CAPACITY / 2;
	while (gap > 0)
	{
		shell( gap);
		gap /= 2;
	}
	end = clock();
	printf("time: %f s\n", ((double)(end - start)) / CLOCKS_PER_SEC / N);

}

void shell( int gap)
{

	for (int i = gap; i < CAPACITY; i++) 
	{
		int temp = array[i];
		int j = i - gap;
		while (j >= 0)
		{
			if (array[j] <= temp) 
			{
				break;
			}
			array[j + gap] = array[j];
			j -= gap;
		}
		array[j + gap] = temp;
	}
}

void swap(int left, int right)
{
	int temp = array[left];
	array[left] = array[right];
	array[right] = temp;
}

//冒泡排序
void bubbleSort()
{
	const int N = 1e2;
	start = clock();
	for (int i = 0; i < CAPACITY - 1; i++) {
		int set = 0;
		for (int j = 0; j < CAPACITY - 1 - i; j++) 
		{
			if (array[j] > array[j + 1]) 
			{
				swap(j, j + 1);
				set = 1;
			}
			
		}
		if (set==0)
		{
			break;
		}
		
	}
	end = clock();
	printf("time: %f s\n", ((double)(end - start)) / CLOCKS_PER_SEC / N);

}

//快速排序
void quickSort()
{
	const int N = 1e2;
    start = clock();

	quickSortProcess(0, CAPACITY - 1);

	end = clock();
	printf("time: %f s\n", ((double)(end - start)) / CLOCKS_PER_SEC / N);

}
//核心代码
void quickSortProcess(int left, int right)
{
	if (left>=right)
	{
		return;
	}
	//找基准
	int pivot= partitionHole(left, right);
	quickSortProcess(left, pivot);
	quickSortProcess( pivot+1,right);

}

int partitionHole(int left, int right)
{
	int pivotValue = array[left];
	
	while (left < right) 
	{
		while (right > left && array[right] >= pivotValue) 
		{
			right--;
		}
		array[left] = array[right];
		while (left < right && array[left] <= pivotValue) 
		{
			left++;
		}
		array[right] = array[left];
	}
	array[left] = pivotValue;
	return left;
}



//选择排序
void selectSort()
{
	const int N = 1e2;
    start = clock();
	int left = 0;
	int right = CAPACITY - 1;
	while (left < right) 
	{
		int minIndex = left;
		int maxIndex = left;
		//找最大值和最小值
		for (int i = left + 1; i <= right; i++) 
		{
			if (array[i] < array[minIndex]) 
			{
				minIndex = i;
			}
			if (array[i] > array[maxIndex]) 
			{
				maxIndex = i;
			}
		}
		if (left != minIndex) 
		{
			swap(left, minIndex);
		}
		if (left == maxIndex) 
		{
			minIndex = maxIndex;
		}
		if (right != maxIndex) 
		{
			swap(right, maxIndex);
		}
		left++;
		right--;
	}
	end = clock();
    printf("time: %f s\n", ((double)(end - start)) / CLOCKS_PER_SEC / N);

}


//归并排序
void mergeSort()
{
	
    const int N = 1e2;
	start = clock();

	mergeSortProcessor( 0, CAPACITY - 1);
	end = clock();
    printf("time: %f s\n", ((double)(end - start)) / CLOCKS_PER_SEC / N);

}
void mergeSortProcessor(int left, int right)
{
	//1、终止条件
	if (left >= right) {
		return;
	}
	//2、找中间下标
	int mid = (left + right) / 2;
	//3、分解左右区段
	mergeSortProcessor( left, mid);
	mergeSortProcessor( mid + 1, right);
	//4、合并
	marge( left, mid, right);
}
void marge(int left, int mid, int right)
{
	//1、创建临时数组
	//int n = (right - left + 1);
	
	int *temp=(int*)malloc((right - left + 1)*sizeof(int));
	int index = 0;
	//2、确定每个小数组的下标
	int start1 = left;
	int end1 = mid;
	int start2 = mid + 1;
	int end2 = right;
	//3、合并
	while (start1 <= end1 && start2 <= end2) {
		if (array[start1] < array[start2]) {
			temp[index++] = array[start1++];
		}
		else {
			temp[index++] = array[start2++];
		}
	}
	//剩余元素添加到temp中
	while (start1 <= end1) {
		temp[index++] = array[start1++];
	}
	while (start2 <= end2) {
		temp[index++] = array[start2++];
	}
	//4、temp写到原数组中
	for (int i = 0; i < index; i++) {
		array[i + left] = temp[i];
	}
	free(temp);
	temp = NULL;
}

main.c

#include"sort.h"
void menu()
{
	printf("+===================================+\n");
	printf("+        欢迎使用综合排序系统       +\n");
	printf("+            1.插入排序             +\n");
	printf("+            2.希尔排序             +\n");
	printf("+            3.冒泡排序             +\n");
	printf("+            4.快速排序             +\n");
	printf("+            5.选择排序             +\n");
	printf("+            6.归并排序             +\n");
	printf("+            0.退出程序             +\n");
	printf("+===================================+\n");

}
void setting()
{
	system("color 0b");
	
}
int main()
{
	setting();
	while (1)
	{
		int select;
		//生成随机数组
		initArray();
		//dispaly();
		menu();
		printf("请选择需要进行的操作:");
		scanf("%d", &select);
		switch (select)
		{
		case 1:
			insertSort();
			save("插入排序");
			system("pause");
			system("cls");
			break;
		case 2:
			shellSort();
			save("希尔排序");
			system("pause");
			system("cls");
			break;
		case 3:
			bubbleSort();
			save("冒泡排序");
			system("pause");
			system("cls");
			break;
		case 4:
			quickSort();
			save("快速排序");
			//dispaly();
			system("pause");
			system("cls");
			break;
		case 5:
			selectSort();
			save("选择排序");
			system("pause");
			system("cls");
			break;

		case 6:
			mergeSort();
			save("归并排序");
			system("pause");
			system("cls");
			break;
		case 0:
			printf("拜拜,欢迎下次使用.....\n");
			return 0;
			break;
		default:
			printf("选择无效,请重新选择!!!\n");
			system("pause");
			system("cls");
			break;
		}
	}
}
小 王
关注
专栏目录
数据结构课程设计----综合排序
wsswsswss123的博客
03-30 4353
《数据结构课程设计》报告 日期： 项目名称： 综合排序 一、项目简介和需求分析 排序（sorting是计箅机程序设计的一种重要操作，它的功能是将一组任意顺序数据元素（记录），根据某一个（或几个）关键字按一定的顺序里新排列成为有序的序列。由于待排序的记录数量不同，使得排序过程中涉及的存储器的不同，可将排序方法分为两大类：一类是内部排序，指的是待排序的记录存放在计算机随机存储器中进行的排序过程；另一类是外部排序，指的是待排序记录的数量很大，以致内存一次不能容纳全部记
数据结构课程设计之排序综合
热门推荐
Wang.T的博客
01-04 1万+
题目：**实现功能： 利用随机函数产生N个随机整数（20000以上），对这些数进行多种方法进行排序。 要求： 1) 至少采用三种方法实现上述问题求解（提示，可采用的方法有插入排序、希尔排序、起泡排序、快速排序、选择排序、堆排序、归并排序）。并把排序后的结果保存在不同的文件中。 2) 统计每一种排序方法的性能（以上机运行程序所花费的时间为准进
数据结构课程设计——排序综合课程设计
06-24
这是数据结构课程设计 有关于排序综合课程设计 可四个人合作
数据结构课程设计(排序综合)
06-21
数据结构课程设计(排序综合)利用随机函数产生N个随机整数（20000以上），对这些数进行多种方法进行排序
数据结构课程设计—排序综合
04-21
数据结构课程设计—排序综合，是一个用C语言编写的集合各种排序算法的程序。包含有运行过程以及运行结果。
数据结构课设——单词统计.pdf
11-17
在这个数据结构课程设计中，主要涉及的是如何使用链表数据结构来实现单词的统计和排序。以下是关于这个程序的关键知识点： 1. **链表数据结构**：程序使用了单链表来存储单词及其出现的次数。`LinkWord` 结构体定义...
数据结构课设——学生成绩管理系统
MayMarch的博客
11-07 1万+
比较完善的学生成绩管理系统，所实现的功能很完备
数据结构课设——教学计划编制问题
12-20
在这个名为“数据结构课设——教学计划编制问题”的项目中，我们将深入研究如何应用数据结构来解决实际问题，特别是与教学计划编制相关的挑战。 教学计划编制问题通常涉及合理安排课程、教师、教室资源，以满足学生...
数据结构的排序综合 排序
06-28
数据结构 排序综合（插入排序、希尔排序、起泡排序、快速排序、选择排序、堆排序、归并排序）
数据结构 排序综合
06-13
数据结构 排序 利用随机函数产生N个随机整数（20000以上），对这些数进行多种方法进行排序。 （1）至少采用三种方法（希尔排序、快速排序、堆排序）实现上述问题求解； （2）统计每一种排序方法的性能（以上机运行程序所花费的时间为准进行对比），找出其中两种较快的方法； （3）统计每种算法所用的比较次数和交换次数，最后列表显示；
数据结构课程设计报告 综合排序
07-01
利用随机函数产生N个随机整数（20000以上），对这些数进行多种方法进行排序。 要求： 1) 至少采用三种方法实现上述问题求解（提示，可采用的方法有插入排序、希尔排序、起泡排序、快速排序、选择排序、堆排序、归并排序）。并把排序后的结果保存在不同的文件中。 2) 统计每一种排序方法的性能（以上机运行程序所花费的时间为准进行对比），找出其中两种较快的方法。 3) 如果采用4种或4种以上的方法者，可适当加分。
数据结构课程设计-排序综合系统
07-04
本程序的编程使用了友好的交互界面，用户可以通过交互界面轻松选择所要进行的操作，执行结果在界面显示的同时也输出到文件。算法当面对直接插入排序、快速排序、希尔排序、选择排序、堆排序、冒泡排序的操作。
综合排序系统课程设计(C++实现，有内部排序和外部排序)
06-27
该排序系统利用内部排序和外部排序对6万条图书信息和1000条出版社信息进行各种排序。 本综合排序系统所能达到的功能： 1.内部排序：使用8种内部排序算法（冒泡排序、插入排序、选择排序、希尔排序、快速排序、归并排序、基数排序、堆排序），对出版社信息按照指定关键字进行排序，分析其时空复杂度（在实验报告的总结与思考中会有相应的回答）。关键字为：出版社编号、出版社名的字典顺序、出版社电话。 2.外部排序：利用外部排序算法实现对图书信息按照指定关键字从低到高排序。关键字为：图书编号、图书名的字典顺序、图书定价、图书页数。 本系统的模块化设计非常合理，将各个大的功能分成若干个.cpp文件，每个文件功能明确清晰，代码的可读性非常好，与用户的交互可以轻松实现，用户所有的操作本系统都会有相应的提示。 我写的这个排序系统总共有1300行左右的代码，分成了6大功能模块，花费了我很多时间和精力，做这个课程设计题目的小伙伴们，有需求的就抓紧下载吧，绝对物有所值，不会让你失望的！
数据结构课设：C语言+学生成绩管理系统（文件索引功能）
最新发布
02-01
数据结构课设——基于C开发的学生成绩管理系统（具有索引文件功能实现）源码 基本功能如下： 1.录入学生信息 2.打印学生信息 3.保存学生信息 4.读取学生信息 5.统计所有学生人数 6.修改学生信息 7.删除学生信息 8....
数据结构课程设计源码---综合排序
金州饿霸吃不饱的博客
05-31 2305
头文件：#include &lt;iostream&gt; //1插入类的排序： //希尔排序：取增量d1的分为一组，共分成d1组分别进行插入排序，然后每组对应元素放在一起，然后取d2...知道d=1 //希尔排序的代码可以近乎看成把1换成dk /*我们简单处理增量序列：增量序列d = {n/2 ,n/4, n/8 .....1} n为要排序数的个数 即：先将要排序的一组记录按某个增量d（n...
数据结构之排序大综合
HPU_FRDHR的博客
12-13 480
冗杂了：           直接插入排序           折半插入排序           希尔排序           冒泡排序           快速排序           选择排序           堆排序           归并排序 的一个程序。。。 #include&lt;bits/stdc++.h&gt; #include &lt;windows.h&gt; ...
数据结构笔记-排序综合
Don2100的博客
08-25 231
我
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小 王

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值