AI 助理
备案控制台
开发者社区 人工智能 文章 正文

[C语言数据结构]万字长文带你学习八大排序

2023-11-13 57
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： [C语言数据结构]万字长文带你学习八大排序

排序

Ⅰ插入排序：

复杂度分析：

时间复杂度O(N^2);

空间复杂度O(N);

算法思路：

原理就是通过构建有序序列，对于未排序的序列，在有序数组中进行扫描在合适的位置插入未排序的数字；

代码：

//插入排序
void InsertSort(int* a, int size)
{
  for (int i = 0; i < size - 1; i++)
  {
    int end = i;
    int temp = a[end + 1];
    while (end >= 0)
    {
      //升序
      if (temp < a[end])
      {
        a[end + 1] = a[end];
        end--;
      }
      else
      {
        break;
      }
    }
    a[end + 1] = temp;
  }
}

Ⅱ希尔排序：

复杂度分析：

时间复杂度O(N^1.3);

空间复杂度O(N);

算法思路：

首先希尔排序的本质就是在插入排序的基础上进行多次的预排序；

预排序：就是将原本数组中的数据用一个变化的间距gap分割成多个组然后对每个组进行插入排序；

关于gap:

gap开始的大小越大，所获得的效益越大，因为可以让小的数据快速的交换到数组的前面，大的数据快速的交换到数组的后面；

gap之后慢慢变小，这时候交换的效率就慢慢降低，但是数组就会越接近有序；

排序的过程如下：

代码：

//希尔排序
void ShellSort(int* a, int size)
{
  int gap = size;
  while (gap > 1)
  {
    gap = gap /= 2;
    for (int i = 0; i < size - gap; i++)
    {
      int end = i;
      int temp = a[end + gap];
      while (end >= 0)
      {
        //升序
        if (temp < a[end])
        {
          a[end + gap] = a[end];
          end-= gap;
        }
        else
        {
          break;
        }
      }
      a[end + gap] = temp;
    }
  }
}

Ⅲ选择排序：

复杂度分析：

时间复杂度O(N^2);

空间复杂度O(N);

①直接选择排序：

算法思路：

假设从小到大排列：

那么就遍历数组找到最小的元素和第一个元素交换，接着在剩下的数字中进行这种选择，然后交换。直到遍历到最后一个数字。最终就会得到一个有序数组。

算法演示：

代码：

int[] arr = { 3, 7, 6, 2, 4, 1, 8, 9, 5 };
  int n = 9;
    for(int i = 0; i < n; i++)
        {
            for(int j = i + 1; j < n; j++)
                {
                    if(arr[i] < arr[j])
                      {
                        int cmp = arr[j];
                        arr[j] = arr[i];
                        arr[i] = cmp;
                      }
                }
        }

优化：

默认升序的情况，循环内部可以每次同时找到最大值和最小值的下标。然后将最小值放到数组头，最大值放到数组尾；

代码：

//选择排序
void SelectSort(int* a, int size)
{
  int begin = 0;
  int end = size - 1;
  while (begin < end)
  {
    int mini = begin;
    int maxi = begin;
    for (int i = begin + 1; i <= end; i++)
    {
      if (a[i] < a[mini])
      {
        mini = i;
      }
      if (a[i] > a[maxi])
      {
        maxi = i;
      }
    }
    Swap(&a[begin] , &a[mini]);
    //排除max在begin位置的情况
    if (maxi == begin)
    {
      maxi = mini;
    }
    Swap(&a[end], &a[maxi]);
    begin++;
    end--;
  }
}

②堆排序：

复杂度分析：

时间复杂度近似O(N*log N);

空间复杂度O(N);

算法思路：利用堆这种数据结构来进行排序(用堆来选择数据)。

需要注意的是，升序建大堆，降序建立小堆;

以升序为例：

①首先建大堆(从最后一个父节点开始向下调整，直到根节点)；

②然后每次将根节点位置的数据(也就是当前的最大数据)和堆尾的数据交换，然后再对剩下的数据进行向下调整；

代码：

//向下调整   O(N)
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 size)
{
  //升序：大堆
  for (int i = (size - 1 - 1) / 2; i >= 0; i--)
  {
    AdjustDown(a, size, i);
  }
  int end = size - 1;
  while (end > 0)
  {
    Swap(&a[end], &a[0]);
    AdjustDown(a, end, 0);
    --end;
  }
}

Ⅳ交换排序：

①冒泡排序：

复杂度分析：

时间复杂度O(N^2);

空间复杂度O(N);

算法思路：

从前往后多次遍历数组，将相邻的两个元素如果不符合预期的要求就进行交换。

首先要调用两次循环外层循环控制的是整个循环要遍历数组的趟数

内部循环主要的作用是为了将每次将相邻的两个不符合预期要求的两个数字调换位置。

代码：

//冒泡排序
void BubbleSort(int* a, int size)
{
  for (int i = 0; i < size; i++)
  {
    int flag = 0;
    for (int j = 1; j < size - i; j++)
    {
      if (a[j - 1] > a[j])
      {
        Swap(&a[j - 1], &a[j]);
        flag = 1;
      }
    }
    //如果一轮冒泡没有交换数据的话，那么就表示已经有序了
    if (flag == 0)
    {
      break;
    }
  }
}

②快速排序：

复杂度分析：

时间复杂度O(N*log N);

空间复杂度O(log N);

（1）hoare 法：

复杂度分析：

时间复杂度近似：O(N*log N);

空间复杂度O(N);

算法思路：

1．先从数列中取出一个数作为基准数。

2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。

3．再对左右区间重复第二步，直到各区间只有一个数。

代码：

//快速排序
void QuickSort(int* a, int begin, int end)
{
  //如果区间不存在就直接返回
  if (begin >= end)
  {
    return;
  }
  int left = begin, right = end;
  int keyi = left;
  while (left < right)
  {
    //右边先走，找小
    while (left < right && a[right] >= a[keyi])
    {
      right--;
    }
    //左边找大
    while (left < right && a[left] <= a[keyi])
    {
      left++;
    }
    Swap(&a[left], &a[right]);
  }
    Swap(&a[left], &a[keyi]);
    keyi = left;
    QuickSort(a, begin, keyi - 1);
    QuickSort(a, keyi + 1, end);
}
优化：
①对于取key的优化：

首先我们分析当数组为乱序的时候我们这时候选择首元素为key值可以接近于最优的情况或者接近最优的情况；

这时候函数递归的深度大约是log N；

但是当数据接近有序或者有序，那么我们在选择key值的时候只选择首元素为key值的话。这时候就会导致key值排好后的位置恰好在数组头或者尾部的情况，那么就会导致递归深度的大大增加，导致栈溢出，而且时间复杂度也会上升到O(N^2)的情况。

那么这时候我们就可以写一个函数来选key值：

这个函数的原理就是在begin，end和mid这三个位置来选择一个中间值作为key值；

代码：

//三数选择
int GetMidIndex(int* a, int begin, int end)
{
  int mid = (begin + end) >> 1;
  if (a[begin] < a[mid])
  {
    if (a[mid] < a[end])
    {
      return mid;
    }
    else if (a[begin] > a[end])
    {
      return begin;
    }
    else//a[begin] < a[end] && a[end] <  a[mid]
    {
      return end;
    }
  }
  else//a[begin] > a[mid]
  {
    if (a[mid] > a[end])
    {
      return mid;
    }
    else if (a[end] > a[begin])
    {
      return begin;
    }
    else
    {
      return end;
    }
  }
}
//快速排序
void QuickSort(int* a, int begin, int end)
{
  //如果区间不存在就直接返回
  if (begin >= end)
  {
    return;
  }
  int mid = GetMidIndex(a, begin, end);
  Swap(&a[mid], &a[begin]);
  int left = begin, right = end;
  int keyi = left;
  while (left < right)
  {
    //右边先走，找小
    while (left < right && a[right] >= a[keyi])
    {
      right--;
    }
    //左边找大
    while (left < right && a[left] <= a[keyi])
    {
      left++;
    }
    Swap(&a[left], &a[right]);
  }
    Swap(&a[left], &a[keyi]);
    keyi = left;
    QuickSort(a, begin, keyi - 1);
    QuickSort(a, keyi + 1, end);
}
②对于小区间的优化：

所谓小区间就是区间内含有的数据量比较少的时候，这时候我们如果还是老老实实的还是调用递归的话，那么我们所需要的栈空间的成本就很大，如下图所示小区间的调用递归接近整个的一半以上：

所以我们可以采取一种优化方式就是在小区间的情况下，采用插入排序来代替原有的递归，以达到优化的目的；

代码：

//插入排序
void InsertSort(int* a, int size)
{
  for (int i = 0; i < size - 1; i++)
  {
    int end = i;
    int temp = a[end + 1];
    while (end >= 0)
    {
      //升序
      if (temp < a[end])
      {
        a[end + 1] = a[end];
        end--;
      }
      else
      {
        break;
      }
    }
    a[end + 1] = temp;
  }
}
//快速排序
void QuickSort(int* a, int begin, int end)
{
  //如果区间不存在就直接返回
  if (begin >= end)
  {
    return;
  }
  //如果是小区的话那么我们就采用插入排序的方法；
  if ((end - begin) < 15)
  {
    InsertSort(a, end - begin);
  }
  int mid = GetMidIndex(a, begin, end);
  Swap(&a[mid], &a[begin]);
  int left = begin, right = end;
  int keyi = left;
  while (left < right)
  {
    //右边先走，找小
    while (left < right && a[right] >= a[keyi])
    {
      right--;
    }
    //左边找大
    while (left < right && a[left] <= a[keyi])
    {
      left++;
    }
    Swap(&a[left], &a[right]);
  }
    Swap(&a[left], &a[keyi]);
    keyi = left;
    QuickSort(a, begin, keyi - 1);
    QuickSort(a, keyi + 1, end);
}
③对于具有较多相同值的优化：

算法原理：

采用三路划分的思想：

①跟key相等的值放在中间；

②比key小的值放到左边；

③比key大的值放在右边；

代码：

//快速排序
void QuickSort(int* a, int begin, int end)
{
  //三路划分
  if (begin >= end)
  {
    return;
  }
  {
    int mid = GetMidIndex(a, begin, end);
    Swap(&a[begin], &a[mid]);
    int left = begin, right = end;
    int key = a[left];
    int cur = begin + 1;
    while (cur <= right)
    {
      if (a[cur] < key)
      {
        Swap(&a[cur], &a[left]);
        cur++;
        left++;
      }
      else if (a[cur] > key)
      {
        Swap(&a[cur], &a[right]);
        --right;
      }
      else // a[cur] == key
      {
        cur++;
      }
    }
    // [begin, left-1][left, right][right+1,end]
    QuickSort(a, begin, left - 1);
    QuickSort(a, right + 1, end);
  }
}
（2）挖坑法

相较于 hoare 法是多了一个坑位的办法，将key值存储在一个变量里，更加容易的理解。

算法原理：

①先将第一个数据存储到临时变量中，这样就第一个位置也就是left的位置就形成了一个坑位；

②然后先让right指针寻找小于key的值，找到之后就和right交换，交换完之后right的位置就是新的坑位的位置；

③让left指针寻找大于key的值，找到之后就和right交换，那么left的位置就形成了一个新的坑位；

然后递归上面的过程；

代码：

//三路划分
  if (begin >= end)
  {
    return;
  }
  {
    int mid = GetMidIndex(a, begin, end);
    Swap(&a[begin], &a[mid]);
    int left = begin, right = end;
    int key = a[left];
    int cur = begin + 1;
    while (cur <= right)
    {
      if (a[cur] < key)
      {
        Swap(&a[cur], &a[left]);
        cur++;
        left++;
      }
      else if (a[cur] > key)
      {
        Swap(&a[cur], &a[right]);
        --right;
      }
      else // a[cur] == key
      {
        cur++;
      }
    }
    // [begin, left-1][left, right][right+1,end]
    QuickSort(a, begin, left - 1);
    QuickSort(a, right + 1, end);
  }
}
（3）前后指针法：

算法原理：

定义两个指针prev和cur指针；

①cur指针找比key小的，找到后停下来；

②prev++,交换prev和cur的值；

prev的位置就是key的位置

最后交换prev和key(begin)的数据即可；

代码：

//三路划分
  if (begin >= end)
  {
    return;
  }
  {
    int mid = GetMidIndex(a, begin, end);
    Swap(&a[begin], &a[mid]);
    int left = begin, right = end;
    int key = a[left];
    int cur = begin + 1;
    while (cur <= right)
    {
      if (a[cur] < key)
      {
        Swap(&a[cur], &a[left]);
        cur++;
        left++;
      }
      else if (a[cur] > key)
      {
        Swap(&a[cur], &a[right]);
        --right;
      }
      else // a[cur] == key
      {
        cur++;
      }
    }
    // [begin, left-1][left, right][right+1,end]
    QuickSort(a, begin, left - 1);
    QuickSort(a, right + 1, end);
  }
}
（4）非递归方法：

利用栈来模拟实现函数递归的效果

算法原理：

①首先将begin和end入栈；

②进入循环每次先去到栈顶的前两个数据分别对应right和left(顺序很重要)；

③随便选一种方法（hoare，挖坑法，前后指针法）进行排序；

④排完序后将两个区间入栈(需要注意顺序，详细看代码)；

重复循环以上②③④步骤；

代码：

//快速排序
void QuickSort(int* a, int begin, int end)
{
  如果区间不存在就直接返回
  //if (begin >= end)
  //{
  //  return;
  //}
  如果是小区的话那么我们就采用插入排序的方法；
  //if ((end - begin + 1) < 15)
  //{
  //  InsertSort(a + begin, end - begin + 1);
  //}
  //  int keyi = PartSort3(a, begin, end);
  //
  //  QuickSort(a, begin, keyi - 1);
  //  QuickSort(a, keyi + 1, end);
  //三路划分
  if (begin >= end)
  {
    return;
  }
  {
    int mid = GetMidIndex(a, begin, end);
    Swap(&a[begin], &a[mid]);
    int left = begin, right = end;
    int key = a[left];
    int cur = begin + 1;
    while (cur <= right)
    {
      if (a[cur] < key)
      {
        Swap(&a[cur], &a[left]);
        cur++;
        left++;
      }
      else if (a[cur] > key)
      {
        Swap(&a[cur], &a[right]);
        --right;
      }
      else // a[cur] == key
      {
        cur++;
      }
    }
    // [begin, left-1][left, right][right+1,end]
    QuickSort(a, begin, left - 1);
    QuickSort(a, right + 1, end);
  }
}

Ⅴ归并排序：

（1）递归：

时间复杂度分析：

时间复杂度：O(N * log N)

空间复杂度：O(N)

算法原理(如下图所示)：

①将原数组进行分解，分解到不能分解为止

②然后开始合并，合并的时候按照合并两个有序数组的思路来合并；

代码：

//归并排序
void _MergeSort(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);
  //归并
  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[begin2++];
    }
    else
    {
      tmp[i++] = a[begin1++];
    }
  }
  //迁移剩下的部分
  while (begin1 <= end1)
  {
    tmp[i++] = a[begin1++];
  }
  while (begin2 <= end1)
  {
    tmp[i++] = a[begin2++];
  }
  //转移数据
  memcpy(a + begin, tmp + begin, (end - begin + 1) * sizeof(int));
}
void MergeSort(int* a, int size)
{
  int* tmp = (int*)malloc((size) * sizeof(int));
  if (tmp == NULL)
  {
    perror("malloc failed");
    exit(-1);
  }
  _MergeSort(a, 0,  size - 1, tmp);
}
（2）非递归：

利用循环的方式来非递归实现

算法原理：

定义一个变量 rangeN 来记录间距的问题， 定义一个tmp数组用来存储每次归并的结果；

rangeN从1开始每次*2来时归并的过程；

最后归并结束后将tmp中的存储的数据全部拷贝到原数组中

如下图的方法来实现用 rangeN 来分割数组：

越界问题：

当我们不对边界做判断处理的时候就容易出现越界的情况，导致排序的结果中有随机值的情况；

观察可知：

①begin1不可能越界；

②end1， begin2，end2 越界；

解决方案：

end1修正为当前区间的结尾；

将begin2 和 end2的置成不存在区间

③begin2， end2 越界；

解决方案：

将begin2 和 end2的置成不存在区间

④end2 越界；

解决方案：

将end2修正为第二个小区间的结尾

代码：

void MergeSortS(int* a, int size)
{
  int* tmp = (int*)malloc(sizeof(int) * size);
  if (tmp == NULL)
  {
    perror("malloc fail");
    exit(-1);
  }
  // 归并每组数据个数，从1开始，因为1个认为是有序的，可以直接归并
  int rangeN = 1;
  while (rangeN < size)
  {
    for (int i = 0; i < size; i += 2 * rangeN)
    {
      // [begin1,end1][begin2,end2] 归并
      int begin1 = i, end1 = i + rangeN - 1;
      int begin2 = i + rangeN, end2 = i + 2 * rangeN - 1;
      int j = i;
      // end1 begin2 end2 越界
      // 修正区间  ->拷贝数据 归并完了整体拷贝 or 归并每组拷贝
      if (end1 >= size)
      {
        end1 = size - 1;
        // 不存在区间
        begin2 = size;
        end2 = size - 1;
      }
      else if (begin2 >= size)
      {
        // 不存在区间
        begin2 = size;
        end2 = size - 1;
      }
      else if (end2 >= size)
      {
        end2 = size - 1;
      }
      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, tmp, sizeof(int) * (size));
    rangeN *= 2;
  }
  free(tmp);
  tmp = NULL;
}

Ⅵ基数排序：

1.1基数排序原理图：

1.2代码实现:

#define _CRT_SECURE_NO_WARNINGS 1
#include"RadSort.h"
Queue q0;
Queue q1;
Queue q2;
Queue q3;
Queue q4;
Queue q5;
Queue q6;
Queue q7;
Queue q8;
Queue q9;
//初始化
void Init()
{
  QueueInit(&q0);
  QueueInit(&q1);
  QueueInit(&q2);
  QueueInit(&q3);
  QueueInit(&q4);
  QueueInit(&q5);
  QueueInit(&q6);
  QueueInit(&q7);
  QueueInit(&q8);
  QueueInit(&q9);
}
Queue* q[10] = { &q0,&q1,&q2,&q3,&q4,&q5,&q6,&q7,&q8,&q9 };
//获取key
int GetKey(int value, int k)
{
  int key = 0;
  while (k >= 0)
  {
    key = value % 10;
    value /= 10;
    k--;
  }
  return key;
}
//放数据
void PushNum(int arr[], int left, int right, int k)
{
  for (int i = left; i < right; i++)
  {
    int key = GetKey(arr[i], k);
    QueuePush(q[key], arr[i]);
  }
}
//回收数据
void CollectNum(int arr[])
{
  int j = 0;
  for (int i = 0; i < 10; i++)
  {
    while (!QueueEmpty(q[i]))
    {
      arr[j++] = QueueFront(q[i]);
      QueuePop(q[i]);
    }
  }
}
//打印数组
void Print(int arr[], int size)
{
  for (int i = 0; i < size; i++)
  {
    printf("%d ", arr[i]);
  }
}
//基数排序
void RadSort(int arr[], int left, int right,  int k)
{
  Init();
  for (int i = 0; i < k; i++)
  {
    //放数据
    PushNum(arr, left, right, i);
    //回收数据
    CollectNum(arr);
  }
  //打印结果
  Print(arr, right);
}

到这本篇博客的内容就到此结束了。
如果觉得本篇博客内容对你有所帮助的话，可以点赞，收藏，顺便关注一下！
如果文章内容有错误，欢迎在评论区指正


文章标签：
算法
C语言
存储
搜索推荐
关键词：
数据结构c语言
数据结构学习
C语言数据结构
C语言排序
数据结构排序
小米睡不醒
目录
相关文章
ephemerals__
|
24天前
|
C语言
【数据结构】栈和队列（c语言实现）（附源码）
本文介绍了栈和队列两种数据结构。栈是一种只能在一端进行插入和删除操作的线性表，遵循“先进后出”原则；队列则在一端插入、另一端删除，遵循“先进先出”原则。文章详细讲解了栈和队列的结构定义、方法声明及实现，并提供了完整的代码示例。栈和队列在实际应用中非常广泛，如二叉树的层序遍历和快速排序的非递归实现等。
ephemerals__
114 9
肾透侧视攻城狮
|
27天前
|
存储 算法 安全
2024重生之回溯数据结构与算法系列学习之串（12）【无论是王道考研人还是IKUN都能包会的；不然别给我家鸽鸽丟脸好嘛？】
数据结构与算法系列学习之串的定义和基本操作、串的储存结构、基本操作的实现、朴素模式匹配算法、KMP算法等代码举例及图解说明；【含常见的报错问题及其对应的解决方法】你个小黑子；这都学不会；能不能不要给我家鸽鸽丢脸啊~除了会黑我家鸽鸽还会干嘛？！！！
肾透侧视攻城狮
24 2
2024重生之回溯数据结构与算法系列学习之串（12）【无论是王道考研人还是IKUN都能包会的；不然别给我家鸽鸽丟脸好嘛？】
ephemerals__
|
23天前
|
存储 搜索推荐 算法
【数据结构】树型结构详解 + 堆的实现（c语言）（附源码）
本文介绍了树和二叉树的基本概念及结构，重点讲解了堆这一重要的数据结构。堆是一种特殊的完全二叉树，常用于实现优先队列和高效的排序算法（如堆排序）。文章详细描述了堆的性质、存储方式及其实现方法，包括插入、删除和取堆顶数据等操作的具体实现。通过这些内容，读者可以全面了解堆的原理和应用。
ephemerals__
61 16
ephemerals__
|
19天前
|
搜索推荐 算法 C语言
【排序算法】八大排序（上）（c语言实现）（附源码）
本文介绍了四种常见的排序算法：冒泡排序、选择排序、插入排序和希尔排序。通过具体的代码实现和测试数据，详细解释了每种算法的工作原理和性能特点。冒泡排序通过不断交换相邻元素来排序，选择排序通过选择最小元素进行交换，插入排序通过逐步插入元素到已排序部分，而希尔排序则是插入排序的改进版，通过预排序使数据更接近有序，从而提高效率。文章最后总结了这四种算法的空间和时间复杂度，以及它们的稳定性。
ephemerals__
63 8
ephemerals__
|
19天前
|
搜索推荐 算法 C语言
【排序算法】八大排序（下）（c语言实现）（附源码）
本文继续学习并实现了八大排序算法中的后四种：堆排序、快速排序、归并排序和计数排序。详细介绍了每种排序算法的原理、步骤和代码实现，并通过测试数据展示了它们的性能表现。堆排序利用堆的特性进行排序，快速排序通过递归和多种划分方法实现高效排序，归并排序通过分治法将问题分解后再合并，计数排序则通过统计每个元素的出现次数实现非比较排序。最后，文章还对比了这些排序算法在处理一百万个整形数据时的运行时间，帮助读者了解不同算法的优劣。
ephemerals__
58 7
ephemerals__
|
23天前
|
C语言
【数据结构】二叉树（c语言）（附源码）
本文介绍了如何使用链式结构实现二叉树的基本功能，包括前序、中序、后序和层序遍历，统计节点个数和树的高度，查找节点，判断是否为完全二叉树，以及销毁二叉树。通过手动创建一棵二叉树，详细讲解了每个功能的实现方法和代码示例，帮助读者深入理解递归和数据结构的应用。
ephemerals__
78 8
ephemerals__
|
26天前
|
存储 C语言
【数据结构】手把手教你单链表（c语言）（附源码）
本文介绍了单链表的基本概念、结构定义及其实现方法。单链表是一种内存地址不连续但逻辑顺序连续的数据结构，每个节点包含数据域和指针域。文章详细讲解了单链表的常见操作，如头插、尾插、头删、尾删、查找、指定位置插入和删除等，并提供了完整的C语言代码示例。通过学习单链表，可以更好地理解数据结构的底层逻辑，提高编程能力。
ephemerals__
51 4
肾透侧视攻城狮
|
27天前
|
算法 安全 搜索推荐
2024重生之回溯数据结构与算法系列学习之单双链表精题详解（9）【无论是王道考研人还是IKUN都能包会的；不然别给我家鸽鸽丢脸好嘛？】
数据结构王道第2.3章之IKUN和I原达人之数据结构与算法系列学习x单双链表精题详解、数据结构、C++、排序算法、java、动态规划你个小黑子；这都学不会；能不能不要给我家鸽鸽丢脸啊~除了会黑我家鸽鸽还会干嘛？！！！
肾透侧视攻城狮
22 2
肾透侧视攻城狮
|
27天前
|
算法 安全 NoSQL
2024重生之回溯数据结构与算法系列学习之栈和队列精题汇总（10）【无论是王道考研人还是IKUN都能包会的；不然别给我家鸽鸽丢脸好嘛？】
数据结构王道第3章之IKUN和I原达人之数据结构与算法系列学习栈与队列精题详解、数据结构、C++、排序算法、java、动态规划你个小黑子；这都学不会；能不能不要给我家鸽鸽丢脸啊~除了会黑我家鸽鸽还会干嘛？！！！
肾透侧视攻城狮
21 1
ephemerals__
|
26天前
|
C语言
【数据结构】双向带头循环链表（c语言）（附源码）
本文介绍了双向带头循环链表的概念和实现。双向带头循环链表具有三个关键点：双向、带头和循环。与单链表相比，它的头插、尾插、头删、尾删等操作的时间复杂度均为O(1)，提高了运行效率。文章详细讲解了链表的结构定义、方法声明和实现，包括创建新节点、初始化、打印、判断是否为空、插入和删除节点等操作。最后提供了完整的代码示例。
ephemerals__
40 0