C语言之桶排序，冒泡排序，快速排序，选择排序算法学习

  由于快找工作了，最近开始练习一些笔试题，学习了一下简单的桶排序，冒泡排序，快速排序，选择排序算法，不过这只是皮毛，懂C语言，数学只要不是很差都能明白这几个算法，学习这个算法主要是参考啊哈磊编著的《啊哈！算法》这本书，这本书讲解的还是满生动形象的，还插入了一些漫画，感觉蛮有趣的。比较适合新手。

  下面贴上代码：

/*********************************************************************************
 *      Copyright:  (C) 2017 zoulei
 *                  All rights reserved.
 *
 *       Filename:  test.c
 *    Description:  This file i
 *
 *        Version:  1.0.0(2017年07月30日)
 *         Author:  zoulei <zoulei121@gmail.com>
 *      ChangeLog:  1, Release initial version on "2017年07月30日 15时28分29秒"
 *
 ********************************************************************************/

#include <stdio.h>
#include <string.h>
int a[101],n;
/* 桶排序之随机输入n个数，最后从小到大排列输出 */
void BucketSort(void)
{
    int a[101];
    int i;
    int j;
    int temp;
    for(i=0;i<=100;i++)
     a[i]=0;
    scanf("%d",&n);
    for(i=1;i<=n;i++)
    {
       scanf("%d",&temp);
       a[temp]++;
    }

    for(i=0;i<=100;i++)
      for(j=1;j<=a[i];j++)
      {
          printf("%d ",i);

      }
    printf("\n");

}
/* 冒泡算法：排序从大到小排序 */
void BubbleSort(void)
{
   int a[100];
   int i;
   int j;
   int temp;
   scanf("%d",&n);
   for(i=1;i<=n;i++)
   {
     scanf("%d",&a[i]);
   }
   /* 冒泡算法核心代码 */
   for(i=1;i<=n-1;i++)
   {
     for(j=1;j<=n-i;j++)
     {
        if(a[j]<a[j+1])
        {temp=a[j];a[j]=a[j+1];a[j+1]=temp;}
     }
   }
   for(i=1;i<=n;i++)
   {
       printf("%d ",a[i]);
   }
   printf("\n");
}
 /*快速排序算法：序列从小到大排列 */
void QuickSort(int left,int right)
{
   int i,j,temp,m;
  if(left>right) /* 退出递归的条件判断 */
   {
    return ;
   }
   m=a[left];  /* m存的是基准数 */
   i=left;
   j=right;
   while(i!=j)
   {
     while(a[j]>=m && i<j) /* 先从右往左找序列中比基准数m大的数 */
     {
         j--;
     }
     while(a[i]<=m && i<j)  /* 再从左往右找序列中比基准数m小的数 */
     {
         i++;
     }
     if(i<j)  /* 满足条件就将比m大的那个数与比m小的那个数进行交换 */
     {
      temp=a[i];
      a[i]=a[j];
      a[j]=temp;
     }
   }
  /* 下面两段代码是将基准数归位 */
     a[left]=a[i];
     a[i]=m;
     QuickSort(left,i-1);    /* 继续处理左边的数，这是一个递归过程 */
     QuickSort(i+1,right);   /*继续处理右边的数，这是一个递归过程 */

}
 /* 选择排序算法:从小到大排列 */
void SelectSort(void)
{
    int i;
    int j;
    int temp;
    scanf("%d",&n); /* 输入数据的长度 */
    for(i=0;i<n;i++)/* 输入数据 */
    {
      scanf("%d",&a[i]);
    }
    /* 选择排序核心代码 */
    for(i=0;i<=n;i++)
    {
       for(j=i+1;j<=n-1;j++)
       {
          if(a[i]>a[j])
          {
            temp=a[i];
            a[i]=a[j];
            a[j]=temp;
          }
       }
    }
    for(i=0;i<n;i++)/* 输出数据 */
    {
      printf("%d ",a[i]);
    }
     printf("\n");
}
/* 快速排序算法：输入序列与输出序列 */
void output_QuickSort()
{
    int i,j;
    scanf("%d",&n);
    for(i=1;i<=n;i++)
     {
        scanf("%d",&a[i]);
     }
     QuickSort(1,n); /* 快速排序递归函数调用 */
    for(i=1;i<=n;i++)
     {
        printf("%d ",a[i]);
     }
    printf("\n");
}
/* 主函数 */
int main(int argc,char**argv)
{
    //output_QuickSort(); /* 快速排序调用 */
    //BucketSort();       /* 桶排序调用 */
    //BubbleSort();       /* 冒泡排序调用 */
    SelectSort();       /* 选择排序调用 */
    return 0;

}

1.桶排序核心思想： 桶排序主要就是将一些数放在一个数组中，每个数对应的是数组下标，刚开始将数组里的每一个元素初始化为0，以后一个数只要出现一次，对应的数组下标里的值就自加1，最后将出现过的数打印输出即可。

2.冒泡排序核心思想：冒泡排序就是每次比较一个序列中两个相邻的元素，如果它们的顺序错误就把他们交换过来。举个例子：假设我们将n个数从小到大排序，相邻两个数进行比较，如果前者比后者小，就要将这两个数交换，然后将这两个数中的较小者与下一个相邻的数进行比较，这样一直循环下去，直到与最后一个数进行比较，看谁小，小的那个数就是最后一个数，就将那个数归位。最后输出来，第一次进行n-1次比较判断，第二次进行n-2次比较判断，一直循环操作，直到最后一个尚未归位的数，已经归为的数无需再进行比较。

3.快速排序核心思想：快速排序就是在一个序列中的随机找一个数作为基准数，这是一个参照数，主要用来将这个序列中的比这个基准数小的放在基准数的右（左）边，比这个基准数大的放在基准数的左（右）边，直到从一个序列的两边查找碰头后，就将这个基准数与那个碰头的那个数进行交换。最后将这个基准数左边的序列数重复同样的步骤，同时将这个基准数右边的序列数重复同样的步骤，最后就可以进行从小到大或则从大到小的排序，这个快速排序采用了“二分”的思想，代码中也就是用递归思想实现。

4.选择排序核心思想：就是10个数则是需要排9次，若按降序排列，第一次比较：则是将数组的第一个元素与数组中从第二个元素开始到最后的元素进行比较找到最大的数记录下来然后将值赋值给数组的第一个元素，然后进行第二次比较：则是将数组的第二个元素与数组中从第三个元素开始到最后的元素进行比较，找最大的数记录下来将值赋值给数组的第二个元素。。。依次循环找完。

更新：

由于之前学习了链表的基本操作，现在又学习了一些简单的排序算法，下面再举个例子来熟悉这些算法，下面进行编程实现将链表中的数据进行排序（采用冒泡算法）。

上代码：

/*********************************************************************************
 *      Copyright:  (C) 2017 zoulei
 *                  All rights reserved.
 *
 *       Filename:  link_data_sort.c
 *    Description:  This file
 *
 *        Version:  1.0.0(2017年07月31日)
 *         Author:  zoulei <zoulei121@gmail.com>
 *      ChangeLog:  1, Release initial version on "2017年07月31日 19时45分26秒"
 *
 ********************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef struct LinkNode
{
   int data;
   struct LinkNode *next;
}Node;
 /* 创建一个带头节点的单向链表 */
Node*Create_link(int n)
{
   Node*head;
   Node*pnext;
   Node*plast;
   int i;
   head=(Node*)malloc(sizeof(Node));
   assert(NULL != head);
   head->next=NULL;

   while(n!=0)
   {
      plast=head;
      for(i=0;i<n;i++)
      {
         pnext=(Node*)malloc(sizeof(Node));
         printf("向第%d个节点输入数据:",i+1);
         scanf("%d",&pnext->data);
         plast->next=pnext;
         plast=plast->next;
      }
      pnext->next=NULL;
      break;
   }
   return head;
}
/*将链表中各节点的数据进行排序函数*/
void link_BubbleSort(Node*head,int n)
{
   int i;
   int j;
   int temp;
   Node*ptr;
 
   ptr=head->next;
   /* 冒泡算法核心代码 */
   for(i=1;i<=n-1;i++)
   {
        for(j=1;j<=n-i;j++)
        {
         if(ptr!=NULL && ptr->next!=NULL)
           {
            if(ptr->data>ptr->next->data)
             {
               temp=ptr->data;
               ptr->data=ptr->next->data;
               ptr->next->data=temp;
             }
             ptr=ptr->next;
           }
          else
          {
           return ;
          }
        }
          ptr=head->next;
   }
}
  /*各节点数据输出函数*/
void print(Node*head)
{
  Node*temp;
  temp=head->next;
   printf("输出数据:");
  while(temp!=NULL)
  {
     printf("%d ",temp->data);
     temp=temp->next;
  }
  printf("\n");
}
 /* 销毁链表函数 */
void Destory(Node *head)
{
  Node*pnext;
  pnext=head->next;
  while(pnext!=NULL)
  {
     free(pnext);
     pnext=pnext->next;
  }
}
int main(int argc,char**argv)
{
    Node*head;
    head=Create_link(4);
    link_BubbleSort(head,4);
    print(head);
    Destory(head);
    return 0;
}

测试结果：