2022.12.30发完数据结构就告一段落，22年也尽快过去，疫情也退散了，预祝各位元旦快乐！
冒泡排序
//
// sort_.cpp
// Sort
//
// Created by ljpc on 2018/4/20.
// Copyright © 2018年 ljpc. All rights reserved.
//
#include "sort_.h"
void print_array(int *arr, int n)
// 打印数组
{
if(n==0)
{
printf("ERROR: Array length is ZERO\n");
return;
}
printf("%d", arr[0]);
for (int i=1; i<n; i++)
{
printf(" %d", arr[i]);
}
printf("\n");
}
void sort_array(int *arr, int n)
// 编程实现《冒泡排序算法》：将乱序序列arr转化为升序序列
// 函数参数：乱序整数数组arr 数组长度
// 要求输出：调用print_array(int *arr, int n)输出前三次冒泡操作后的序列，以及最终的升序序列
{
// 请在这里补充代码，完成本关任务
/********** Begin *********/
int i,x,j;
for(j=0; j<n-1; j++)
{
for(i=0; i<n-j-1; i++)
{
if(arr[i]>arr[i+1])
{
x=arr[i];
arr[i]=arr[i+1];
arr[i+1]=x;
}
}
if(j<3) print_array(arr,n);
}
print_array(arr,n);
/********** End **********/
}
选择排序
//
// sort_.cpp
// Sort
//
// Created by ljpc on 2018/4/20.
// Copyright © 2018年 ljpc. All rights reserved.
//
#include "sort_.h"
void print_array(int *arr, int n)
// 打印数组
{
if(n==0)
{
printf("ERROR: Array length is ZERO\n");
return;
}
printf("%d", arr[0]);
for (int i=1; i<n; i++)
{
printf(" %d", arr[i]);
}
printf("\n");
}
void sort_array(int *arr, int n)
// 编程实现《选择排序算法》：将乱序序列arr转化为升序序列
// 函数参数：乱序整数数组（无重复元素） 数组长度
// 要求输出：调用print_array(int *arr, int n)输出前三次选择操作后的序列，以及最终的升序序列
{
// 请在这里补充代码，完成本关任务
/********** Begin *********/
int i,j,x,t;
for(j=0; j<n-1; j++)
{
x=j;
for(i=j+1; i<n; i++)
{
if(arr[i]<arr[x]) x=i;
}
t=arr[x];
arr[x]=arr[j];
arr[j]=t;
if(j<3) print_array(arr,n);
}
print_array(arr,n);
/********** End **********/
}
插入排序
//
// sort_.cpp
// Sort
//
// Created by ljpc on 2018/4/20.
// Copyright © 2018年 ljpc. All rights reserved.
//
#include "sort_.h"
void print_array(int *arr, int n)
// 打印数组
{
if(n==0)
{
printf("ERROR: Array length is ZERO\n");
return;
}
printf("%d", arr[0]);
for (int i=1; i<n; i++)
{
printf(" %d", arr[i]);
}
printf("\n");
}
void sort_array(int *arr, int n)
// 编程实现《插入排序算法》：将乱序序列arr转化为升序序列
// 函数参数：乱序整数数组（无重复元素） 数组长度
// 要求输出：调用print_array(int *arr, int n)输出前三次插入操作后的序列，以及最终的升序序列
{
// 请在这里补充代码，完成本关任务
/********** Begin *********/
int i,j,x;
for(i=0; i<n-1; i++)
{
x=arr[i+1];
j=i;
while(x<arr[j]&&j>-1)
{
arr[j+1]=arr[j];
j--;
}
arr[j+1]=x;
if(i<3) print_array(arr,n);
}
print_array(arr,n);
/********** End **********/
}
希尔排序
//
// sort_.cpp
// Sort
//
// Created by ljpc on 2018/4/20.
// Copyright © 2018年 ljpc. All rights reserved.
//
#include "sort_.h"
void print_array(int *arr, int n)
// 打印数组
{
if(n==0)
{
printf("ERROR: Array length is ZERO\n");
return;
}
printf("%d", arr[0]);
for (int i=1; i<n; i++)
{
printf(" %d", arr[i]);
}
printf("\n");
}
void sort_array(int *arr, int n)
// 编程实现《希尔排序算法》：将乱序序列arr转化为升序序列
// 函数参数：乱序整数数组 数组长度
// 要求输出：调用print_array(int *arr, int n)输出三遍增量排序操作后的序列，以及最终的升序序列
{
// 请在这里补充代码，完成本关任务
/********** Begin *********/
int i = 0,t=0;
int key = 0;
int end = 0;
int Gap[4] = {5,2,1,-1};
int gap = Gap[t];
while (gap > 0)
{
for (i = gap; i < n; i++)
{
key = arr[i];
end = i - gap;
while (end >= 0 && key<arr[end])
{
arr[end + gap] = arr[end];
end=end-gap;
}
arr[end + gap] = key;
}
print_array(arr, n);
t++;
gap=Gap[t];
}
print_array(arr, n);
/********** End **********/
}
归并排序
//
// sort_.cpp
// Sort
//
// Created by ljpc on 2018/4/20.
// Copyright © 2018年 ljpc. All rights reserved.
//
#include "sort_.h"
void print_array(int *arr, int n)
// 打印数组
{
if(n==0){
printf("ERROR: Array length is ZERO\n");
return;
}
printf("%d", arr[0]);
for (int i=1; i<n; i++) {
printf(" %d", arr[i]);
}
printf("\n");
}
int* merge_array(int *arr1, int n1, int* arr2, int n2)
// 编程实现两个有序数组arr1和arr2合并
// 函数参数：有序数组arr1 数组arr1长度 有序数组arr2 数组arr2长度
// 函数返回值：返回从小到大排序后的合并数组
{
// 请在这里补充代码，完成本关任务
/********** Begin *********/
int arr3_length = n1 + n2;
int *arr3 = (int *)malloc(sizeof(int)*arr3_length);
int i=0 , j=0,t=0;
while(i<n1&&j<n2)
{
if(arr1[i]<=arr2[j])
arr3[t++] = arr1[i++];
else
arr3[t++] = arr2[j++];
}
if(i==n1)
{
while(t<arr3_length)
arr3[t++] = arr2[j++];
}
else
{
while(t<arr3_length)
arr3[t++] = arr1[i++];
}
return arr3;
/********** End **********/
}
int* merge_sort(int *arr, int n)
// 基于merge_array函数编程实现归并排序：自上而下的递归方法
// 函数参数：有序数组arr 数组arr长度
// 函数返回值：返回从小到大排序后的数组
{
// 请在这里补充代码，完成本关任务
/********** Begin *********/
int mid ;
int left = 0 ,right = n;
mid = (left+right)/2;
if(right!=1)
{
int *Arr_1 = &arr[left],*Arr_2 = &arr[mid];
Arr_1 = merge_sort(Arr_1,mid);
Arr_2 = merge_sort(Arr_2,right-mid);
arr = merge_array(Arr_1,mid,Arr_2,right-mid);
}
return arr;
/********** End **********/
}
快速排序
//
// sort_.cpp
// Sort
//
// Created by ljpc on 2018/4/20.
// Copyright © 2018年 ljpc. All rights reserved.
//
#include "sort_.h"
void print_array(int *arr, int n)
// 打印数组
{
if(n==0){
printf("ERROR: Array length is ZERO\n");
return;
}
printf("%d", arr[0]);
for (int i=1; i<n; i++) {
printf(" %d", arr[i]);
}
printf("\n");
}
int partition_array(int *arr ,int l,int r)
// 编程实现arr[l, r]分区：选定一个基准，左边比基准小，右边比基准大
// 返回基准所处位置
{
// 请在这里补充代码，完成本关任务
/********** Begin *********/
int pivot = arr[l];
int i = l + 1;
int j = r;
while (i <= j)
{
while (i <= r && arr[i] <= pivot)
{
i++;
}
while (j >= l + 1 && arr[j] >= pivot)
{
j--;
}
if (i < j)
{
swap(arr[i], arr[j]);
}
}
swap(arr[l], arr[j]);
return j;
/********** End **********/
}
int* quick_sort(int *arr, int l, int r)
// 基于partition_array函数编程实现快速排序：自上而下的递归方法
// 函数参数：有序数组arr 初始l=0，r=n-1
// 函数返回值：返回从小到大排序后的数组
{
// 请在这里补充代码，完成本关任务
/********** Begin *********/
if (l >= r)
{
return arr;
}
int pivot = partition_array(arr, l, r);
quick_sort(arr, l, pivot - 1);
quick_sort(arr, pivot + 1, r);
return arr;
/********** End **********/
}
堆排序
//
// sort_.cpp
// Sort
//
// Created by ljpc on 2018/4/20.
// Copyright © 2018年 ljpc. All rights reserved.
//
#include "sort_.h"
void print_array(int *arr, int n)
// 打印数组
{
if(n==0)
{
printf("ERROR: Array length is ZERO\n");
return;
}
printf("%d", arr[0]);
for (int i=1; i<n; i++)
{
printf(" %d", arr[i]);
}
printf("\n");
}
void adjustHeap(int *arr, int param1, int j)
// 编程实现堆的调整
{
// 请在这里补充代码，完成本关任务
/********** Begin *********/
int temp = arr[param1];
int child = 2*param1 + 1;
while(child < j)
{
if(child + 1 < j && arr[child] < arr[child+1 ])
{
child++;
}
if(temp >= arr[child])
{
break;
}
arr[param1] = arr[child];
param1 = child;
child = 2*child +1;
}
arr[param1] = temp;
/********** End **********/
}
int* heap_sort(int *arr, int n)
// 基于adjustHeap函数编程实现堆排序
// 函数参数：无序数组arr 数组长度n
// 函数返回值：返回从小到大排序后的数组
{
// 请在这里补充代码，完成本关任务
/********** Begin *********/
for(int i=n/2 - 1; i>=0; i--)
{
adjustHeap(arr,i, n);
}
for(int i = n-1; i>0; i--)
{
swap(arr[0],arr[i]);
adjustHeap(arr,0, i);
}
return arr;
/********** End **********/
}
计数排序
//
// sort_.cpp
// Sort
//
// Created by ljpc on 2018/4/20.
// Copyright © 2018年 ljpc. All rights reserved.
//
#include "sort_.h"
void print_array(int *arr, int n)
// 打印数组
{
if(n==0)
{
printf("ERROR: Array length is ZERO\n");
return;
}
printf("%d", arr[0]);
for (int i=1; i<n; i++)
{
printf(" %d", arr[i]);
}
printf("\n");
}
void sort_array(int *arr, int n)
// 编程实现《计数排序算法》
// 函数参数：乱序整数数组 数组长度
// 要求输出：调用print_array(int *arr, int n)输出：
// 每一行一个元素及其个数（升序），如 1 1
// 以及最终的升序序列
{
// 请在这里补充代码，完成本关任务
/********** Begin *********/
int max = *max_element(arr,arr+n);
int min = *min_element(arr,arr+n);
int arrLen = max-min+1;
int *jishu = new int[arrLen];
fill(jishu,jishu+arrLen,0);
for(int i=0; i<n; i++)
{
jishu[arr[i]-min] += 1;
}
int index = 0;
for(int i=0; i<arrLen; i++)
{
if(jishu[i]!= 0)
{
printf("%d %d\n", i+min,jishu[i]);
}
}
for(int i=0; i<arrLen; i++)
{
while(jishu[i] != 0)
{
arr[index] = i+min;
jishu[i]--;
index++;
}
}
print_array(arr, n);
/********** End **********/
}
桶排序
//
// sort_.cpp
// Sort
//
// Created by ljpc on 2018/4/20.
// Copyright © 2018年 ljpc. All rights reserved.
//
#include "sort_.h"
void print_array(int *arr, int n)
// 打印数组
{
if(n==0)
{
printf("ERROR: Array length is ZERO\n");
return;
}
printf("%d", arr[0]);
for (int i=1; i<n; i++)
{
printf(" %d", arr[i]);
}
printf("\n");
}
int* sort_array(int *arr, int n)
// 编程实现《桶排序算法》
// 函数参数：乱序整数数组 数组长度
// 函数返回值：返回从小到大排序后的数组
{
// 请在这里补充代码，完成本关任务
/********** Begin *********/
int maxVal = arr[0];
for(int i = 1; i < n; i++)
{
if(arr[i] > maxVal)
maxVal = arr[i];
}
int tmpArrLen = maxVal + 1;
int tmpArr[tmpArrLen];
int i, j;
for( i = 0; i < tmpArrLen; i++)
tmpArr[i] = 0;
for(i = 0; i < n; i++)
tmpArr[ arr[i] ]++;
for(i = 0, j = 0; i < tmpArrLen; i ++)
{
while( tmpArr[ i ] != 0)
{
arr[j ] = i;
j++;
tmpArr[i]--;
}
}
return arr;
/********** End **********/
}
基数排序
//
// sort_.cpp
// Sort
//
// Created by ljpc on 2018/4/20.
// Copyright © 2018年 ljpc. All rights reserved.
//
#include "sort_.h"
void print_array(int *arr, int n)
// 打印数组
{
if(n==0){
printf("ERROR: Array length is ZERO\n");
return;
}
printf("%d", arr[0]);
for (int i=1; i<n; i++) {
printf(" %d", arr[i]);
}
printf("\n");
}
int* sort_array(int *arr, int n)
// 编程实现《基数排序算法》
// 函数参数：乱序整数数组 数组长度
// 函数返回值：返回从小到大排序后的数组
{
// 请在这里补充代码，完成本关任务
/********** Begin *********/
int temp[10][n]= {0};
int order[n]= {0};
int i,j,k;
int t;
int p;
t=1;
while(t <= 100)
{
for(i=0; i<n; i++)
{
k = (arr[i]/t) % 10;
temp[k][order[k]] = arr[i];
order[k]++;
}
p=0;
for(i=0; i<n; i++)
{
if(order[i] != 0)
{
for(j=0; j<order[i]; j++)
{
arr[p] = temp[i][j];
p++;
}
order[i] = 0;
}
}
t *= 10;
}
return arr;
/********** End **********/
}
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
