数据结构 c 排序大全(快速,分治,外部,bit,桶,堆,二叉树,希尔等)

最新推荐文章于 2025-08-09 20:08:31 发布
最新推荐文章于 2025-08-09 20:08:31 发布
阅读量421 收藏 2
点赞数
分类专栏： 编程 文章标签： 数据结构 c fp tree system null
本文详细介绍了十种经典的排序算法，包括快速排序、分治合并排序、外部排序、位排序、桶排序、堆排序、二叉树排序、希尔排序、插入排序和冒泡排序。每种算法都附带了具体的实现代码，帮助读者更好地理解和掌握这些排序方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 
1.快速排序

# include < stdio. h>
# include < stdlib. h>
# include < time . h>

# define MAX_NUM 20

void print_array( int A[ ] )
{
  int i = 0;
  for ( i= 0; i< MAX_NUM; i+ + )
  {
   if ( ( i+ 1) % 5 = = 0)
     printf ( "%d/n" , A[ i] ) ;
   else
     printf ( "%d/t" , A[ i] ) ;
  }
}

void swap ( int * a, int * b)
{
  int tmp = * a;
  * a = * b;
  * b = tmp;
}
       
int partition ( int A[ ] , int start, int end)
{
   int x = A[ end] ;
   int i = start- 1;
   int j = start;
   for ( ; j< end; j+ + )
    {
      if ( A[ j] < x)
       {
        i+ + ;
        swap ( A+ i, A+ j) ;
       }
    }
    swap ( A+ i+ 1, A+ end) ;
    return i+ 1;
}

void quicksort( int A[ ] , int start, int end)
{
 if ( start< end)
   {
     int q = partition ( A, start, end) ;
     quicksort( A, start, q- 1) ;
     quicksort( A, q+ 1, end) ;
   }
}
  
int main( int argc, char * argv[ ] )
{
  int i;
  int A[ MAX_NUM] ;
  
  srand ( ( unsigned int ) time ( NULL ) ) ;
  for ( i= 0; i< MAX_NUM; i+ + )
    A[ i] = rand ( ) % 30 + 1;
  
  printf ( "the original array is:/n" ) ;
  print_array( A) ;
    
  quicksort( A, 0, MAX_NUM- 1) ;
  printf ( "after quick sort the array is:/n" ) ;
  print_array( A) ;
    
  system ( "PAUSE" ) ;     
  return 0;
}

2.分治合并排序

# include < stdio. h>
# include < stdlib. h>
# include < time . h>

# define MAX_NUM 20
# define MAX_VALUES 9999

void print_array( int A[ ] )
{
  int i = 0;
  for ( i= 0; i< MAX_NUM; i+ + )
  {
   if ( ( i+ 1) % 5 = = 0)
     printf ( "%d/n" , A[ i] ) ;
   else
     printf ( "%d/t" , A[ i] ) ;
  }
}
 
void merge ( int A[ ] , int start, int mid, int end)
{
  int i;
  int j;
  int k;
  
  int L[ mid - start + 2] ;
  int R[ end - mid + 1] ;
  for ( i= 0; i< = mid- start; i+ + )
    L[ i] = A[ i+ start] ;
  L[ i] = MAX_VALUES;
  
  for ( i= 0; i< = end- mid- 1; i+ + )
    R[ i] = A[ i+ mid+ 1] ;
  R[ i] = MAX_VALUES;
  
  i = 0;
  j = 0;
  for ( k= start; k< = end; k+ + )
   {
     if ( L[ i] < = R[ j] )
      {
       A[ k] = L[ i] ;
       i+ + ;
      }
     else
      {
       A[ k] = R[ j] ;
       j+ + ;
      }
   }
}

void mergesort( int A[ ] , int start, int end)
{
 if ( start< end)
  {
   int mid = ( start + end) / 2;
   mergesort( A, start, mid) ;
   mergesort( A, mid+ 1, end) ;
   merge ( A, start, mid, end) ;
  }
}
  
int main( int argc, char * argv[ ] )
{
  int i;
  int A[ MAX_NUM] ;
  
  srand ( ( unsigned int ) time ( NULL ) ) ;
  for ( i= 0; i< MAX_NUM; i+ + )
    A[ i] = rand ( ) % 30 + 1;
  
  printf ( "the original array is:/n" ) ;
  print_array( A) ;
    
  mergesort( A, 0, MAX_NUM- 1) ;
  printf ( "after merge sort the array is:/n" ) ;
  print_array( A) ;
    
  system ( "PAUSE" ) ;     
  return 0;
}

3.外部排序

# include < stdio. h>
# include < stdlib. h>

# define MAX_NUM 20

void print_array( FILE * fp)
{
  int num;
  int i ;
  
  for ( i= 0; i< MAX_NUM; i+ + )
   {
    fscanf ( fp, "%d/n" , & num) ;
    
    if ( ( i+ 1) % 5 = = 0)
      printf ( "%d/n" , num) ;
    else
      printf ( "%d/t" , num) ;
   }
}

void externalsort( FILE * fp, int M)
{
  int i = 0;
  int flag = 0;
  int A[ 2] ;
  
  FILE * fp_tmp1 = fopen ( "tmp1.txt" , "wb+" ) ;
  FILE * fp_tmp2 = fopen ( "tmp2.txt" , "wb+" ) ;
  
  for ( i= 1; i< = M; i+ + )
   {
     if ( fscanf ( fp, "%d/n" , & A[ 0] ) ! = EOF )
      {
       fprintf ( fp_tmp1, "%d/n" , A[ 0] ) ;
      }
    }
     
  for ( i= M+ 1; i< = MAX_NUM; i+ + )
   {
     if ( fscanf ( fp, "%d/n" , & A[ 0] ) ! = EOF )
      {
       fprintf ( fp_tmp2, "%d/n" , A[ 0] ) ;
      }
    }
   rewind ( fp_tmp1) ;
   rewind ( fp_tmp2) ;
  
   fscanf ( fp_tmp1, "%d/n" , & A[ 0] ) ;
   fscanf ( fp_tmp2, "%d/n" , & A[ 1] ) ;
   rewind ( fp) ;
   for ( i= 1; i< MAX_NUM+ 1; i+ + )
    {
      if ( A[ 0] < = A[ 1] )
       {
        fprintf ( fp, "%d/n" , A[ 0] ) ;
        if ( fscanf ( fp_tmp1, "%d/n" , & A[ 0] ) = = EOF )
          {
            flag = 1;
            break ;
          }
       }
      else
       {
        fprintf ( fp, "%d/n" , A[ 1] ) ;
        if ( fscanf ( fp_tmp2, "%d/n" , & A[ 1] ) = = EOF )
          {
            flag = 2;
            break ;
          }
       }
    }
   while ( i+ + < MAX_NUM+ 1)
    {
       if ( flag = = 1)
        {
          fprintf ( fp, "%d/n" , A[ 1] ) ;
          while ( fscanf ( fp_tmp2, "%d/n" , & A[ 1] ) ! = EOF )
            fprintf ( fp, "%d/n" , A[ 1] ) ;
        }
       else
        {
          fprintf ( fp, "%d/n" , A[ 0] ) ;
          while ( fscanf ( fp_tmp1, "%d/n" , & A[ 0] ) ! = EOF )
            fprintf ( fp, "%d/n" , A[ 0] ) ;
        }
    }
   remove ( "tmp1.txt" ) ;
   remove ( "tmp2.txt" ) ;
}


int main( int argc, char * argv[ ] )
{
  int i;
  int num;
  FILE * fp = NULL ;
  
  srand ( ( unsigned int ) time ( NULL ) ) ;
  
  fp = fopen ( "original.txt" , "wb+" ) ;
  for ( i= 1; i< = 10; i+ + )
   {
    num = 2* i- 1;
    fprintf ( fp, "%d/n" , num) ;
   }
  for ( i= 1; i< = 10; i+ + )
   {
    num = 2* i;
    fprintf ( fp, "%d/n" , num) ;
   }
   
  rewind ( fp) ;
  printf ( "the original array is:/n" ) ;
  print_array( fp) ;
  
  rewind ( fp) ;
  externalsort( fp, MAX_NUM/ 2) ;
  
  printf ( "after external sort the array is:/n" ) ;
  rewind ( fp) ;
  print_array( fp) ;
    
  system ( "PAUSE" ) ;     
  return 0;
}

4.bit排序

 

# include < stdio. h>
# include < stdlib. h>
# include < time . h>

# define MAX_NUM 20
# define WIDTH 3
# define MASK 0x07
# define BIT_NUM 3
 
void swap ( int * a, int * b)
{
  int tmp = * a;
  * a = * b;
  * b = tmp;
}

void print_array( int A[ ] )
{
  int i = 0;
  for ( i= 0; i< MAX_NUM; i+ + )
  {
   if ( ( i+ 1) % 5 = = 0)
     printf ( "%d/n" , A[ i] ) ;
   else
     printf ( "%d/t" , A[ i] ) ;
  }
}
     
int get_rand( int NUM[ ] , int start, int end)
{
  int num;
  num = rand ( ) % ( end- start+ 1) + start;
  swap ( NUM+ start, NUM+ num) ;
  return NUM[ start] ;
}

void bit_set( int BIT[ ] , int num)
{
   BIT[ num> > WIDTH] | = ( 1< < ( num& MASK) ) ;
}

int bit_test( int BIT[ ] , int num)
{
   int tmp = BIT[ num> > WIDTH] ;
   
   if ( ( tmp& = ( 1< < ( num& MASK) ) ) ! = 0)
     return 1;
   else
     return 0;
}
 
void bitsort( int A[ ] , int N)
{
  int i = 0;
  int j = 0;
  int BIT[ BIT_NUM] ;
  printf ( "BIT_NUM is %d/n" , BIT_NUM) ;
  for ( i= 0; i< N; i+ + )
     bit_set( BIT, A[ i] ) ;
 
  for ( i= 1; i< = MAX_NUM; i+ + )
   {
      if ( bit_test( BIT, i) )
       {
        A[ j] = i;
        j+ + ;
       }
   }
}
  
int main( int argc, char * argv[ ] )
{
  int i;
  int NUM[ MAX_NUM] ;
  int A[ MAX_NUM] ;
  
  srand ( ( unsigned int ) time ( NULL ) ) ;
  for ( i= 0; i< MAX_NUM; i+ + )
    NUM[ i] = i + 1;
    
  for ( i= 0; i< MAX_NUM; i+ + )
    A[ i] = get_rand( NUM, i, MAX_NUM- 1) ;
  
  
  printf ( "the original array is: /n" ) ;
  print_array( A) ;
  
  bitsort( A, MAX_NUM) ;
  printf ( "after bit sort the array is:/n" ) ;
  print_array( A) ;
    
  system ( "PAUSE" ) ;     
  return 0;
}

5.桶排序

 

# include < stdio. h>
# include < stdlib. h>
# include < time . h>

# define MAX_NUM 20
# define MAX_VAULE 40

void print_array( int A[ ] )
{
  int i = 0;
  for ( i= 0; i< MAX_NUM; i+ + )
  {
   if ( ( i+ 1) % 5 = = 0)
     printf ( "%d/n" , A[ i] ) ;
   else
     printf ( "%d/t" , A[ i] ) ;
  }
}

void bucketsort( int A[ ] , int value)
{
   int B[ value] ;
   int i;
   int j;
   int count = 0;
  
   for ( i= 0; i< value; i+ + )
     B[ i] = 0;
   
   for ( i= 0; i< MAX_NUM; i+ + )
     B[ A[ i] ] + + ;
    
   for ( i= 1; i< value; i+ + )
   {
    while ( B[ i] - - )
     {
       A[ count ] = i;
       count + + ;
     }
   }
      
}
  
int main( int argc, char * argv[ ] )
{
  int i;
  int A[ MAX_NUM] ;
  
  srand ( ( unsigned int ) time ( NULL ) ) ;
  for ( i= 0; i< MAX_NUM; i+ + )
    A[ i] = rand ( ) % MAX_VAULE + 1;
  
  printf ( "the original array is:/n" ) ;
  print_array( A) ;
    
  bucketsort( A, MAX_VAULE+ 1) ;
  printf ( "after bucket sort the array is:/n" ) ;
  print_array( A) ;
    
  system ( "PAUSE" ) ;     
  return 0;
}

 

6.堆排序

 

# include < stdio. h>
# include < stdlib. h>
# include < time . h>

# define MAX_NUM 20

typedef struct heap
{
  int size;
  int * num;
} HEAP;

void print_array( HEAP* H)
{
  int i = 1;
  for ( i= 1; i< = MAX_NUM; i+ + )
  {
   if ( i% 5 = = 0)
     printf ( "%d/n" , H- > num[ i] ) ;
   else
     printf ( "%d/t" , H- > num[ i] ) ;
  }
}

void swap ( int * a, int * b)
{
  int tmp = * a;
  * a = * b;
  * b = tmp;
}

int get_rand( int NUM[ ] , int start, int end)
{
  int num;
  num = rand ( ) % ( end- start+ 1) + start;
  swap ( NUM+ start, NUM+ num) ;
  return NUM[ start] ;
}

void init_heap( HEAP* * H)
{
  * H = ( HEAP* ) malloc ( sizeof ( HEAP) ) ;
  ( * H) - > size = 0;
  ( * H) - > num = ( int * ) malloc ( sizeof ( int ) * ( MAX_NUM+ 1) ) ;
  ( * H) - > num[ 0] = 0;
}

void insert_heap( HEAP* H, int num)
{
   int i;
   for ( i= + + ( H- > size) ; H- > num[ i/ 2] > num; i/ = 2)
     H- > num[ i] = H- > num[ i/ 2] ;
   H- > num[ i] = num;
}

int delete_min( HEAP* H)
{
  int i;
  int min = H- > num[ 1] ;
  int size = H- > size;
  int last_num = H- > num[ ( H- > size) - - ] ;
  int child;
  
  for ( i= 1; i* 2< = H- > size; i= child)
   {
     child = 2* i;
     if ( H- > num[ child] > H- > num[ child+ 1] )
      child+ + ;
     
     if ( last_num > H- > num[ child] )
       H- > num[ i] = H- > num[ child] ;
     else
       break ;
   }
   
   H- > num[ i] = last_num;
   H- > num[ size] = min ;
   return min ;
}

void heapsort( HEAP* H, int N)
{
  int i;
  for ( i= 1; i< N+ 1; i+ + )
    insert_heap( H, H- > num[ i] ) ;
  
  for ( i= 1; i< N+ 1; i+ + )
    delete_min( H) ;
          
}

int main( int argc, char * argv[ ] )
{
  int i;
  int NUM[ MAX_NUM] ;
  
  HEAP* H = NULL ;
  init_heap( & H) ;
  
  srand ( ( unsigned int ) time ( NULL ) ) ;
  for ( i= 0; i< MAX_NUM; i+ + )
    NUM[ i] = i + 1;
    
  for ( i= 0; i< MAX_NUM; i+ + )
   {
    H- > num[ i+ 1] = get_rand( NUM, i, MAX_NUM- 1) ;
   }
  
  printf ( "the original array is: /n" ) ;
  print_array( H) ;
  
  heapsort( H, MAX_NUM) ;

  printf ( "after heap sort the array is:/n" ) ;
  print_array( H) ;
    
  system ( "PAUSE" ) ;     
  return 0;
}

 

7.二叉树排序

 

# include < stdio. h>
# include < stdlib. h>
# include < time . h>

# define MAX_NUM 20

typedef struct tree
{
  int num;
  struct tree* lchild;
  struct tree* rchild;
} TREE;

int count = 0;
void print_array( int A[ ] )
{
  int i = 0;
  for ( i= 0; i< MAX_NUM; i+ + )
  {
   if ( ( i+ 1) % 5 = = 0)
     printf ( "%d/n" , A[ i] ) ;
   else
     printf ( "%d/t" , A[ i] ) ;
  }
}

void add_tree( TREE* * T, int num)
{
  if ( * T = = NULL )
   {
     * T = ( TREE* ) malloc ( sizeof ( TREE) ) ;
     ( * T) - > num = num;
     ( * T) - > lchild = NULL ;
     ( * T) - > rchild = NULL ;
     }
   else if ( ( * T) - > num > num)
     add_tree( & ( ( * T) - > lchild) , num) ;
   else
     add_tree( & ( ( * T) - > rchild) , num) ;
}

void midwalk( TREE* T, int A[ ] )
{
  if ( T!=NULL)
   {
     midwalk( T- > lchild, A) ;
     A[ count + + ] = T- > num;
     midwalk( T- > rchild, A) ;
   }
}

void treesort( int A[ ] , int N)
{
  int i;
  TREE* T = NULL ;
  
  for ( i= 0; i< N; i+ + )
    add_tree( & T, A[ i] ) ;
  
  midwalk( T, A) ;
}
   
int main( int argc, char * argv[ ] )
{
  int i;
  int A[ MAX_NUM] ;
  srand ( ( unsigned int ) time ( NULL ) ) ;
  
  for ( i= 0; i< MAX_NUM; i+ + )
    A[ i] = rand ( ) % 100+ 1;
  
  printf ( "the original array is:/n" ) ;
  print_array( A) ;
    
  treesort( A, MAX_NUM) ;
  
  printf ( "after tree sort the array is:/n" ) ;
  print_array( A) ;
  
  system ( "PAUSE" ) ;     
  return 0;
}

8.希尔排序

# include < stdio. h>
# include < stdlib. h>
# include < time . h>

# define MAX_NUM 20


void print_array( int A[ ] )
{
  int i = 0;
  for ( i= 0; i< MAX_NUM; i+ + )
  {
   if ( ( i+ 1) % 5 = = 0)
     printf ( "%d/n" , A[ i] ) ;
   else
     printf ( "%d/t" , A[ i] ) ;
  }
}

void swap ( int * a, int * b)
{
  int tmp = * a;
  * a = * b;
  * b = tmp;
}

void shellsort( int A[ ] , int N)
{
  int i;
  int increment = N/ 2;
  for ( ; increment> 0; increment/ = 2)
    for ( i= 0; i< N- increment; i+ + )
     {
       if ( A[ i] > A[ i+ increment] )
         swap ( A+ i, A+ i+ increment) ;
     }
}
   
int main( int argc, char * argv[ ] )
{
  int i;
  int A[ MAX_NUM] ;
  srand ( ( unsigned int ) time ( NULL ) ) ;
  
  for ( i= 0; i< MAX_NUM; i+ + )
    A[ i] = rand ( ) % 100+ 1;
  
  printf ( "the original array is:/n" ) ;
  print_array( A) ;
    
  shellsort( A, MAX_NUM) ;
  
  printf ( "after tree sort the array is:/n" ) ;
  print_array( A) ;
  
  system ( "PAUSE" ) ;     
  return 0;
}

 

9.插入排序

 

# include < stdio. h>
# include < stdlib. h>
# include < time . h>

# define MAX_NUM 20


void print_array( int A[ ] )
{
  int i = 0;
  for ( i= 0; i< MAX_NUM; i+ + )
  {
   if ( ( i+ 1) % 5 = = 0)
     printf ( "%d/n" , A[ i] ) ;
   else
     printf ( "%d/t" , A[ i] ) ;
  }
}

void swap ( int * a, int * b)
{
  int tmp = * a;
  * a = * b;
  * b = tmp;
}

void insertsort( int A[ ] , int N)
{
  int i;
  int j;
  int tmp;
  
  for ( i= 1; i< N; i+ + )
   {
    int tmp = A[ i] ;
    for ( j= i; j> 0& & A[ j- 1] > tmp; j- - )
     A[ j] = A[ j- 1] ;
    
    A[ j] = tmp;
   }
}
   
int main( int argc, char * argv[ ] )
{
  int i;
  int A[ MAX_NUM] ;
  srand ( ( unsigned int ) time ( NULL ) ) ;
  
  for ( i= 0; i< MAX_NUM; i+ + )
    A[ i] = rand ( ) % 100+ 1;
  
  printf ( "the original array is:/n" ) ;
  print_array( A) ;
    
  insertsort( A, MAX_NUM) ;
  
  printf ( "after insert sort the array is:/n" ) ;
  print_array( A) ;
  
  system ( "PAUSE" ) ;     
  return 0;
}

 

10.冒泡排序

 

# include < stdio. h>
# include < stdlib. h>
# include < time . h>

# define MAX_NUM 20


void print_array( int A[ ] )
{
  int i = 0;
  for ( i= 0; i< MAX_NUM; i+ + )
  {
   if ( ( i+ 1) % 5 = = 0)
     printf ( "%d/n" , A[ i] ) ;
   else
     printf ( "%d/t" , A[ i] ) ;
  }
}

void swap ( int * a, int * b)
{
  int tmp = * a;
  * a = * b;
  * b = tmp;
}

void bubblesort( int A[ ] , int N)
{
  int i;
  int j;
  for ( i= 0; i< N- 1; i+ + )
    for ( j= 0; j< N- i- 1; j+ + )
     {
       if ( A[ j] > A[ j+ 1] )
         swap ( A+ j, A+ j+ 1) ;
     }
}
   
int main( int argc, char * argv[ ] )
{
  int i;
  int A[ MAX_NUM] ;
  srand ( ( unsigned int ) time ( NULL ) ) ;
  
  for ( i= 0; i< MAX_NUM; i+ + )
    A[ i] = rand ( ) % 100+ 1;
  
  printf ( "the original array is:/n" ) ;
  print_array( A) ;
    
  bubblesort( A, MAX_NUM) ;
  
  printf ( "after tree sort the array is:/n" ) ;
  print_array( A) ;
  
  system ( "PAUSE" ) ;     
  return 0;
}

 

常见八大排序(纯C语言版)
ikuunnnn的博客
06-08 2016
关于基本排序的万字讲解大全图文齐全
数据结构基础 排序算法（二） 概念篇
稚枭天卓
08-02 1679
六、鸡尾酒排序/双向冒泡排序 1）算法简介         鸡尾酒排序等于是冒泡排序的轻微变形。不同的地方在于从低到高然后从高到低，而冒泡排序则仅从低到高去比较序列里的每个元素。他可以得到比冒泡排序稍微好一点的效能，原因是冒泡排序只从一个方向进行比对(由低到高)，每次循环只移动一个项目。 2）算法描述和分析      1、依次比较相邻的两个数，将小数放在前面
bitmap与桶方式对1000万数据进行排序（转+自己实现理解）
weixin_34419321的博客
08-20 190
1.  100万数据的产生,随机数方式 #include &lt;iostream&gt;#include &lt;time.h&gt;#include &lt;assert.h&gt;#include &lt;stdio.h&gt;#include &lt;stdlib.h&gt;using namespace std;const int size = 10000000;int num[s...
外部排序--归并算法实现
hyx的博客
12-02 8754
#include<stdio.h> #include<stdlib.h>//此部分直接硬写出来的，没参考网上代码，写的可能拙劣一点 //非递归 void sort(int num[], int n) //接受待排序数组和数组长度 { int tempnum = 1; int *temp; temp = (int*)malloc(n * sizeof(int)); //构建辅助
bitmap与桶方式对1000万数据进行排序
net_assassin的专栏
07-16 2541
1.  100万数据的产生,随机数方式 #include #include #include #include #include using namespace std; const int size = 10000000; int num[size]; int main() { int n; FILE *fp = fopen("data.txt", "w");
数据结构之经典八大排序的实现(万字详谈）
Ly的博客
01-18 1001
对数据结构中比较经典的八大排序进行讲解，万字详谈，分析仔细
数据结构和算法之排序总结
DanceBit的博客
12-28 6354
一、排序的概念及应用 ???? 排序的概念 ???? 排序的运用 ???? 常见的排序算法 二、常见排序算法的实现 ???? 插入排序 1、直接插入排序 2、希尔排序 ???? 选择排序 1、直接选择排序 2、堆排序 ???? 交换排序 1、冒泡排序 2、快速排序 ???? 归并排序 ???? 非比较排序 1、计数排序 2、基数排序 ???? 文件排序 (拓展) ???? 性能测试 三、排序算法复杂度及稳定性分析 四、概念选择题
秋招八股--数据结构-基础知识
weixin_41171614的博客
04-01 1730
秋招八股--数据结构-基础知识
C 数据结构之十大排序 三大查找
热门推荐
牧野的博客
11-08 1万+
本文gif图片来自 一像素 排序问题相关描述 排序问题： 整理文件中的记录，使之按关键字递增或递减的顺序排列起来。 排序算法的稳定性： 若排序对象中存在多个关键字相同的记录，经过排序后，相同关键字的记录之间的相对次序保持不变，则该排序方法是稳定的，若次序发生变化(哪怕只有两条记录之间)，则该排序方法是不稳定的。不稳定的排序有选择排序、希尔排序、堆排序和快速排序。 排序方法的分类： ...
十大经典排序算法（图解与代码）——冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序（Python and Java）
un357951的博客
09-07 695
排序算法的稳定性 内部排序 冒泡排序 快速排序 选择排序 堆排序 插入排序 希尔排序 归并排序 计数排序 桶排序 Python Java 外部排序 失败树 置换-选择排序 最佳归并树
"C语言排序算法大全：快速排序及其他九种排序方法详解
快速排序是一种常用且高效的排序算法，通过不断地将数组分割成较小的子数组，并按照基准值进行排序，最终实现整个数组的排序。其基本思想是选择一个基准值，然后将数组分为两部分，小于基准值的放在左边，大于基准值...
java - 数据结构，算法，排序
ryy1999的博客
03-09 748
3.3、插入排序的性能分析 插入排序的稳定性： 结论希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数n，把待排序文件中所有记录分成n个组，所有距离为 (数据量/n) 的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达只有一个组时，所有记录在统一组内排好序。 五、选择排序 5.1、原理 优化 定义 一个 变量， 用来记录 此时的 i 后面最小值的下标。等 j 遍历完了，最小值的下标也就拿到了。此时，再进行交换。 这样就不必让上面那样，遇到比 i下标元素
应届毕业生面试必考：十种经典排序总结（C语言实现）
LUCAS004的博客
08-16 1132
       十大排序算法可以说是每个程序员都必须得掌握的，对于毕业生，掌握十种排序也能在面试中加分不少。因此我花了一天的时间将十种排序进行整理，并且附上代码以供大家学习。 十大排序1. 冒泡排序2. 选择排序3. 插入排序4. 希尔排序5. 堆排序6. 归并排序7. 快速排序8. 计数排序9. 基数排序10. 桶排序 1. 冒泡排序 冒泡排序算法的思路如下： (1). 比较相邻的元素，如果前一个比后一个大，就交换他们两个。 (2).
数据结构——图及其C++实现 多源最短路径 FloydWarshall算法
学习日记
08-06 950
前两篇学习的Dijkstra算法和Bellman-Ford算法都是用来求解图的单源最短路径，即从图中指定的一个源点出发到图中其他任意顶点的最短路径。Dijkstra算法不能求解带有负权重的图的最短路径，而Bellman-Ford算法弥补了这个缺点。本篇文章再来见识一下一个求解多源最短路径的算法——Floyd-Warshall算法。多源最短路径–Floyd-Warshall算法Floyd-Warshall算法是一种解决多源最短路径问题（任意两点间的最短路径）的算法。
嵌入式 - 数据结构：循环链表和内核链表
m0_74911141的博客
08-05 502
/ 数据域// 前驱指针// 后继指针} linknode;// 首尾自环Linux 内核中通过// 后继指针// 前驱指针初始化初始化头节点，使其首尾自环；插入（头插）、（尾插）；删除从链表中移除节点；遍历遍历数据元素，其中member为数据结构中成员的名称；数据定位通过节点指针ptr找到数据结构的首地址（核心宏，通过指针运算实现）。使用内核链表时，需在自定义数据结构中嵌入// 示例：定义一个包含内核链表节点的进程结构int pid;// 进程ID// 进程名。
C语言的数组与字符串练习题2
HW-BASE的博客
08-06 956
数组与字符串
【数据结构初阶】--单链表（二）
yhrxh_ymq的博客
08-06 949
本文详细介绍了单链表的基本操作实现，包括查找、指定位置插入/删除等核心接口。主要内容包括：1）单链表查找函数的实现与测试；2）在指定位置前/后插入节点的实现方法及注意事项；3）删除指定位置节点及其后继节点的实现；4）单链表的销毁操作。文中通过完整代码示例(包含.h、.c和测试文件)展示了每个接口的具体实现，并配有测试结果验证。作者强调画图理解和亲手实践的重要性，为后续学习双向链表等数据结构打下基础。文章结构清晰，代码注释详细，适合数据结构初学者循序渐进地学习单链表操作。
（数据结构）链表
2402_83411382的博客
08-08 953
本文详细介绍了单向链表和双向链表的实现原理及基本操作。在单向链表部分，讲解了链表结构定义、打印、尾插/头插、尾删/头删等操作的实现方法，重点分析了指针传递问题（需使用二级指针修改头节点）。双向链表部分则展示了带头双向循环链表的结构优势，详细说明了初始化、插入、删除等操作的实现逻辑，强调通过画图辅助理解指针操作。文章还对比了两种链表的特点：单向链表结构简单但功能有限，适合作为子结构；双向链表结构复杂但操作高效，适合单独存储数据。所有代码示例都配有详细注释，帮助理解指针操作和边界条件处理。
排序概念以及插入排序
最新发布
2503_92099422的博客
08-09 440
c.虽然很多算法本身具有稳定或不稳定排序性质但是任何排序只要稍作修改就可以修改稳定性，例如在冒泡排序中判断交换顺序的依据是if(a>b)只要变成if(a>=b)就可以破坏稳定性。2.内部排序和外部排序：待排序数据可以一次性载入到内存中为内部排序，反之数据量过大就是外部排序。3.稳定排序：排序前后序列中键值相等的元素在相对位置不发生变化的就是稳定排序。就地排序只是在原数组空间进行排序处理，也就是输入的数组和得到的数组是同一个。3.如果待排序的元素，已经有序，只有极个别的元素是无序,插入速度较快。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值