数据结构-排序

于 2024-01-17 20:15:24 发布
阅读量350 收藏 9
点赞数 8
文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoyuwyh/article/details/135659311
版权

Stack.h

#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>
// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
    STDataType* a;
    int top;        // 栈顶
    int capacity;  // 容量 
}Stack;

// 初始化栈 
void StackInit(Stack* ps);

// 入栈 
void StackPush(Stack* ps, STDataType data);

// 出栈 
void StackPop(Stack* ps);

// 获取栈顶元素 
STDataType StackTop(Stack* ps);

// 获取栈中有效元素个数 
int StackSize(Stack* ps);

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps);

// 销毁栈 
void StackDestroy(Stack* ps);

Stack.c

#include"stack.h"

void StackInit(Stack* ps)
{
    assert(ps);

    ps->a = NULL;
    ps->top = 0;
    ps->capacity = 0;
}

void StackPush(Stack* ps, STDataType data)
{
    assert(ps);

    //扩容
    if (ps->top == ps->capacity)
    {
        int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
        STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapacity);
        if (tmp == NULL)
        {
            perror("realloc");
            return;
        }
        ps->a = tmp;
        ps->capacity = newcapacity;
    }

    ps->a[ps->top] = data;
    ps->top++;
}

void StackPop(Stack* ps)
{
    assert(ps);
    // 不为空
    assert(ps->top > 0);

    ps->top--;
}

STDataType StackTop(Stack* ps)
{
    assert(ps);
    // 不为空
    assert(ps->top > 0);

    return ps->a[ps->top - 1];
}

int StackSize(Stack* ps)
{
    assert(ps);

    return ps->top;
}

int StackEmpty(Stack* ps)
{
    assert(ps);
    /*if (pst->top == 0)
    {
        return true;
    }
    else
    {
        return false;
    }*/
    return ps->top == 0;
}

void StackDestroy(Stack* ps)
{
    assert(ps);

    free(ps->a);
    ps->a = NULL;
    ps->top = ps->capacity = 0;
}

Assign.c

#include"Assign.h"
#include"Stack.h"

// 插入排序
void InsertSort(int* a, int n)
{
    for (int i = 1; i < n; i++)  // 遍历整个序列，从第二个元素开始（第一个元素默认为有序）
    {
        int end = i - 1;  // 保存当前元素的下标
        int tmp = a[i];  // 将当前元素保存到 tmp 中
        while (end >= 0)  // 从当前元素开始向前遍历
        {
            if (tmp < a[end])  // 如果 tmp 小于前面的元素，则将前面的元素后移
            {
                a[end + 1] = a[end];    //挪动覆盖
                end--;
            }
            else  // 如果 tmp 大于等于前面的元素，则将 tmp 插入到当前位置
            {                                           
                break;
            }
        }
        a[end + 1] = tmp;  // 将 tmp 插入到当前位置
    }
}


// 希尔排序
void ShellSort(int* a, int n)
{
    int gap = 3;
    for (int j = 0; j < gap; j++)   //gap组
    {
        for (int i = j; i < n - gap; i += gap)  //每组进行的循环，间隔为gap
        {
            int end = i;
            int tmp = a[end + gap];
            while (end > 0)
            {
                if (tmp < a[end])
                {
                    a[end + gap] = a[end];
                    end -= gap;
                }
                else
                {
                    break;
                }
            }
            a[end + gap] = tmp;
        }
    }
}
//优化版【多组并排】
//void ShellSort(int* a, int n)
//{
//    int gap = 3;
//    
//    for (int i = 0; i < n - gap; i++ )
//    {
//        int end = i;
//        int tmp = a[end + gap];
//        while (end > 0)
//        {
//            if (tmp < a[end])
//            {
//                a[end + gap] = a[end];
//                end -= gap;
//            }
//            else
//            {
//                break;
//            }
//        }
//        a[end + gap] = tmp;
//    }
//}

// 选择排序
void SelectSort(int* a, int n)
{
    int begin = 0;
    int end = n - 1;
    while (begin > end)     
    {
        int mini = begin, maxi = begin;
        for (int i = begin + 1; i <= n; i++)    //一次遍历
        {
            if (a[i] < a[mini])     
            {
                mini = i;       //把现在的数标记为mini
            }
            if (a[i] > a[maxi])
            {
                maxi = i;       //把现在的数标记为maxi
            }
        }
        Swap(&a[begin], &a[mini]);
        if (maxi == begin)      //这里做出判断是为了防止
        {
            maxi = mini;
        }
        Swap(&a[end], &a[maxi]);

        ++begin;    
        --end;
    }

}


// 堆排序
void Swap(int* p1, int* p2)
{
    int tmp = *p1;
    *p1 = *p2;
    *p2 = tmp;
}

void AdJustDown(int* a, int size, int parent)
{
    int child = parent * 2 + 1;

    while (child < size)
    {
        // 假设左孩子小，如果解设错了，更新一下

        if (child + 1 < size && a[child + 1] < a[child])
        {
            ++child;
        }

        if (a[child] < a[parent])
        {
            Swap(&a[child], &a[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
        {
            break;
        }
    }
}
void HeapSort(int* a, int n)
{
    for (int i = (n -1 - 1) / 2; i > 0; i--)
    {
        AdJustDown(a, n, i);
    }

    int end = n - 1;
    while (end > 0)
    {
        Swap(&a[0], &a[end]);
        AdJustDown(a, end, 0);
        --end;
    }
}

// 冒泡排序
void BubbleSort(int* a, int n) 
{
    for (int i = 0; i < n - 1; i++) 
    {
        for (int j = 1; j < n - i; j++) 
        {
            if (a[j - 1] > a[j]) 
            {
                Swap(&a[j - 1], &a[j]);
            }
        }
    }
}

//快排(前序)
void QuickSort(int* a, int left, int right)
{
    if (left >= right)  // 左右边界相等或左边界大于右边界，直接返回
        return;
    //int keyi = PartSort3(a,left,right);
    //int keyi =PartSort2(a,left,right);
    int keyi =PartSort1(a,left,right);

    QuickSort(a, left, keyi-1);
    QuickSort(a, keyi+1, right);
}

//三数取中
int GetMid(int* a, int begin, int end)
{
    int midi = (begin + end) / 2;
    // begin midi end 三个数选中位数
    if (a[begin] < a[midi])
    {
        if (a[midi] < a[end])
            return midi;
        else if (a[begin] > a[end])
            return begin;
        else
            return end;
    }
    else // a[begin] > a[midi]
    {
        if (a[midi] > a[end])
            return midi;
        else if (a[begin] < a[end])
            return begin;
        else
            return end;
    }
}

// 快速排序前后指针法
int PartSort3(int* a, int begin, int end)
{
    int keyi = begin;
    int midi = GetMid(a,begin ,end);
    Swap(&a[midi], &a[begin]);
    int prev = begin, cur = begin + 1;

    //前指针找小，后指针找大
    while (cur < end+1)
    {
        if (a[cur] > a[keyi])
        {
            cur++;
        }
        else
        {
            prev++;
            Swap(&a[prev], &a[cur]);
            cur++;
        }
    }
    Swap(&a[prev], &a[keyi]);
    keyi = prev;
    return keyi; 
}

// 快速排序挖坑法
int PartSort2(int* a, int left, int right)
{
    int keyi = left;
    int midi = GetMid(a, left, right);
    Swap(&a[midi], &a[left]);
    int hole = left;

    while (left < right)    //相遇就停止
    {
        while(a[right] >= a[keyi] && left < right )
        {
            right--;
        }
        a[hole] = a[right];
        hole = right;
        while(a[left] <= a[keyi] && left < right)
        {
            left++;
        }
        a[hole] = a[left];
        hole = left;
    }
    a[hole] = a[keyi];
    return hole;
}

// 快速排序hoare版本
int PartSort1(int* a, int left, int right)
{
    int keyi = left;
    int midi = GetMid(a, left, right);
    Swap(&a[midi], &a[left]);

    while (left < right)
    {
        while (a[right] >= a[keyi] && left < right)
        {
            right--;
        }
        while (a[left] <= a[keyi] && left < right)
        {
            left++;
        }
        Swap(&a[left], &a[right]);
    }
    Swap(&a[keyi], &a[left]);
    return keyi;
}

// 快速排序 非递归实现
void QuickSortNonR(int* a, int begin, int end)
{
    Stack s;
    StackInit(&s);
    StackPush(&s, begin);
    StackPush(&s, end);
    if (!StackEmpty(&s))
    {
        int left = StackTop(&s);
        StackPop(&s);
        int right = StackTop(&s);
        StackPop(&s);

        int keyi = PartSort3(a, left, right);
        if (left < keyi - 1)
        {
            StackPush(&s, left);
            StackPush(&s, keyi - 1);
        }
        if (keyi + 1 < right)
        {
            StackPush(&s, keyi + 1);
            StackPush(&s, right);
        }
    }
    StackDestroy(&s);
}

void QuickSort(int* a, int begin, int end)
{
    if (begin >= end)
        return;
    int keyi = PartSort2(a, begin, end);
    QuickSort(a, begin, keyi - 1);
    QuickSort(a, keyi + 1, end);

}

//归并排序(后序)
//递归
void* _MegreSort(int* a, int begin, int end, int* tmp)
{
    if (begin >= end)
        return;

    int mid = (begin + end) / 2;
    // [begin, mid][mid+1, end]

    _MergeSort(a, begin, mid, tmp);
    _MergeSort(a, mid + 1, end, tmp);
    // [begin, mid][mid+1, end]归并

    int begin1 = begin, end1 = mid;
    int begin2 = mid + 1, end2 = end;
    int i = begin;
    while (begin1 <= end1 && begin2 <= end2)
    {
        if (a[begin1] < a[begin2])
        {
            tmp[i++] = a[begin1++];
        }
        else
        {
            tmp[i++] = a[begin2++];
        }
    }

    while (begin1 <= end1)
    {
        tmp[i++] = a[begin1++];
    }

    while (begin2 <= end2)
    {
        tmp[i++] = a[begin2++];
    }

    memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
}

void* MergeSort(int* a, int n)
{
    int* tmp = (int*)malloc(sizeof(int) * n);
    if (tmp == NULL)
    {
        perror("malloc fail");
        return;
    }

    _MergeSort(a, 0, n - 1, tmp);

    free(tmp);
}
//非递归
void* MergeSortNonR(int* a, int n)
{
    int* tmp = (int*)malloc(sizeof(int)* n);
    if (tmp == NULL)
    {
        perrpr("malloc fail");
        return;
    }

    int gap = 1;
    while (gap < n)
    {

        for (int i = 0; i <= gap - n + 1; i += gap * 2)
        {
            int begin1 = i, end1 = i + gap - 1,
                begin2 = i + gap, end2 = i + 2 * gap - 1;
            // [begin1, end1][begin2, end2] 归并

            // 边界的处理
            if (end1 >= n || begin2 >= n)
            {
                break;
            }

            if (end2 >= n)
            {
                end2 = n - 1;
            }

            int j = begin1;
            while (begin1 <= end1 && begin2 <= end2)
            {
                if (a[begin1] < a[begin2])
                {
                    tmp[j++] = a[begin1++];
                }
                else
                {
                    tmp[j++] = a[begin2++];
                }
            }

            while (begin1 <= end1)
            {
                tmp[j++] = a[begin1++];
            }

            while (begin2 <= end2)
            {
                tmp[j++] = a[begin2++];
            }

            memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));
        }
        printf("\n");

        gap *= 2;
    }

    free(tmp);
}


void CountSort(int* a, int n) 
{
    int max = a[0], min = a[0];

    for (int i = 0; i < n; i++)
    {
        if (a[i] > max)
        {
            max = a[i];
        }
        if (a[i] < min)
        {
            min = a[i];
        }
    }

    int range = max - min + 1;
    int* count = (int*)calloc(range ,sizeof(int) * n);
    if (count == NULL)
    {
        printf("calloc fail\n");
        return;
    }

    for (int j = 0; j < n; j++)
    {
        count[a[j] - min]++;
    }

    for (int i = 0,j = 0; i < range; i++)
    {
        while (count[i]--)
        {
            a[j++] = min + i;
        }
    }
}

Assign.h

#include<stdio.h>
#include<string.h>
#include<assert.h>

// 插入排序
void InsertSort(int* a, int n);

// 希尔排序
void ShellSort(int* a, int n);

// 选择排序
void SelectSort(int* a, int n);


// 堆排序
void AdJustDown(int* a, int n, int root);
void HeapSort(int* a, int n);

// 冒泡排序
void BubbleSort(int* a, int n)

// 快速排序递归实现
// 快速排序hoare版本
int PartSort1(int* a, int left, int right)
// 快速排序挖坑法
int PartSort2(int* a, int left, int right);
// 快速排序前后指针法
int PartSort3(int* a, int left, int right);
void QuickSort(int* a, int left, int right);

// 快速排序 非递归实现
void QuickSortNonR(int* a, int left, int right);

//归并排序
void* _MegreSort(int* a, int begin, int end, int* tmp);
void* MergeSort(int* a, int n);

//非递归实现
void* MergeSortNonR(int* a, int n);

//计数排序
void CountSort(int* a, int n);

xiaoyuwyh
关注
  • 8
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构-排序整理 md版
03-15
主要是CSDN上广告太多啦，给大家提供md文档，简洁美观。完全是那篇博客的版本喔。
数据结构-排序(包括常用的插入排序，选择排序，冒泡排序等)
最新发布
01-11
数据结构-排序(包括常用的插入排序，选择排序，冒泡排序等)
数据结构-排序算法（c语言实现篇）
CHAKMING1的博客
08-08 8837
数据结构中最全的排序算法（C语言实现）
数据结构-排序算法之快速排序
席木木的博客
02-08 2494
排序算法之快速排序1-快速排序的基本思想2-快速排序的过程图解第一次排序过程第二次分治排序过程子列表1的排序过程子列表2的排序过程子列表2-1的分治排序过程排序结果3-Java代码实现4-例题题目描述结题思路代码编写     快速排序属于交换排序的一种，其基本思想是基于分治法的。其算法时间复杂度为O(log2N)，堪称是所有内部排序算法中平均性能最优的排序算法。。 1-快速排序的基本思想     从待排序表L：【0…n】中任取
数据结构—八大排序
热门推荐
想要上进的coder的博客
01-09 3万+
一、直接插入排序 void InsertSort(int* a, int n) { assert(a); for (int i = 0; i < n - 1; ++i) { int end = i; int x=a[end+1];//将end后面的值保存到x里面了 //将x插入到[0，end]的有序区间 while (end >= 0) { if (a[end] > x) { a[end + 1] = a[end]; //往后挪动一位
数据结构-排序基础代码
IT1995的博客
12-17 5299
数据结构-排序基础代码
数据结构-排序篇
weixin_52575498的博客
04-09 1657
1. 插入排序 1.1 直接插入排序-原理： 整个区间被分为：1. 有序区间；2. 无序区间；每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入。 1.2 实现： public class InsertSort { public static void sort(int[] array){ // 一共要取多少个元素来进行插入过程（无序区间里有多少个元素） for (int i = 0; i < ar...
数据结构--冒泡排序
li94263的博客
03-24 1525
1、（1）冒泡排序：沉石排序，每一趟循环两两比较，大的向后挪动，最终最大值放在最后，假设有n个书数据，则需要跑n-1趟。 代码： void BubbleSort(int* arr, int len) { for (int i = 0; i < len - 1l; i++) { for (int j = 0; j + 1 < len-i; j++)//比较的下一位j+1<每一趟的最后一位数(len-i) { if (arr[j] > arr[j + 1]).
数据结构--排序之快速排序
qq_52363432的博客
02-08 7530
快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。快排每一趟都会有一个元素回到它真正的位置。
数据结构-十大排序算法
weixin_46160781的博客
12-26 3656
十大排序算法分别是直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序、基数排序、外部排序。其中插入排序包括直接插入排序、折半插入排序、希尔排序；交换排序包括冒泡排序、快速排序；选择排序包括简单选择排序、堆排序。
数据结构-十大经典排序算法
qq_64010161的博客
12-09 3608
数据结构-十大经典排序算法（冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序）
数据结构-排序-基本概念
qq_40731414的博客
05-16 2573
排序的基本概念 1. 排序码与关键码 假设一个文件由这N个记录R1，R2,R3,…组成,所谓排序就是以记录中某个或者某几个字段值以增加或者减少的次序， 将这N个记录重新排序，其中该字段称为排序码，能够唯一标识一个记录的字段称为关键码。 2.内排序和外排序 内排序：指排序的过程中数据存储在内存中，不需要使用外存的排序方法。 外排序：对于数据量很大的文件，内存不足的情况下需要使用外存，这种排序方法...
数据结构--排序--思维导图.pdf
08-29
"数据结构--排序--思维导图" 数据结构中排序是指将一组无序的记录序列按照一定的规则排列成有序的序列，排序的目的是为了提高数据的存储和检索效率。排序算法的稳定性是指在排序过程中，如果待排序表中有两个元素Ri...
数据结构-排序算法对比
08-06
数据结构——排序算法对比
数据结构-排序.pdf
09-30
数据结构-排序.pdf
数据结构-排序课件
12-12
数据结构-排序课件，严蔚敏课本课件，比较好用
数据结构-排序(1).ppt
07-11
数据结构中的排序是计算机科学中一个基础且关键的概念，它涉及到如何有效地重新组织一组无序的数据，以便根据特定的关键字（key）实现升序或降序的排列。排序在多种应用中都至关重要，例如提高查找效率、建立数据库...
数据结构思维导图-排序.pdf
08-23
以上是数据结构中关于排序的一些基本知识，包括排序的稳定性、比较次数、内部排序和外部排序的定义，以及直接插入排序、折半插入排序、希尔排序和冒泡排序的原理和特点。这些排序算法各有优缺点，选择哪种排序算法取...
数据结构-排序 约瑟夫环.rar_数据结构 课程设计_数据结构课程设计_约瑟夫_约瑟夫环_约瑟夫环实验报告
09-20
提供的压缩包文件“数据结构-排序 约瑟夫环”很可能包含了关于这两个主题的详细资料，可能包括课程讲义、代码示例、实验报告模板等。另一个文件“www.pudn.com.txt”可能是从PUDN网站下载的资源链接或说明，可以帮助...
"内部排序方法详解-排序算法比较-数据结构学习要点
数据结构中的排序是计算机内常见的操作，其目的是将一组无序的记录序列调整为有序的记录序列。在内部排序中，排序的主要目的是将数据表中的记录按照关键字进行排序，以便于后续的查找和操作。排序算法的好坏可以通过...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值