各种排序

最新推荐文章于 2020-08-07 21:22:18 发布

原创最新推荐文章于 2020-08-07 21:22:18 发布 · 1.6k 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#vector #shell #struct #numbers #iostream #input

C++资料专栏收录该内容

6 篇文章

订阅专栏

选择法排序:
选择排序(Selection Sort)的基本思想是：每一趟从待排序的记录中选出关键字最小的记录，顺序放在已排好序的子文件的最后，直到全部记录排序完毕。

#include <stdio.h>

int selectSort( int x[], int );

int main()
{
int *p;
int i;
int a[10] = { 3,6,10,54,32,24,56,26,98,87 };

p = a;
sort( p, 10 );

for (p = a, i = 0; i < 10; i ++)
{
printf("%d/n", *p);
p++;
}

return 0;
}

int selectSort( int x[], int n )
{
int i, j, k, t;
for ( i = 0; i < n - 1; i ++ )
{
  k = i;
  for ( j = i + 1; j < n; j ++ )
   if ( x[j] > x[k])
    k = j;
      if ( k != i )
   {
    t = x[i];
    x[i] = x[k];
    x[k] = t;
   }
}
return 0;
}

冒泡法排序:
冒泡排序的基本思想是：两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止。将被排序的记录数组R[1..n]垂直排列，每个记录R[i]看作是重量为R[i].key的气泡。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R：凡扫描到违反本原则的轻气泡，就使其向上"飘浮"。如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。

#include <iostream>
using namespace std;

int main()
{
int a[11];
int i, j, t;

cout << "input 10 numbers: /n";

for (i = 1; i < 11; i++)
{
cin >> a[i];
}

cout << "/n";

for ( j = 1; j <= 9; j ++ )
  for (i = 1; i <= 10 - j; i ++)
   if (a[i] > a[i + 1])
   {
    t = a[i];
    a[i] = a[i + 1];
    a[i + 1] = t;
   }
   cout << "the sorted numbers: /n";

for (i = 10; i > 0; i --)
cout << a[i] << " ";

system("pause");
}

快速排序:
快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。
分治法的基本思想是：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。

#include<stdio.h>

#define MAXNUM 100
#define TRUE 1
#define FALSE 0
typedef int KeyType;
typedef int DataType;

typedef struct {
KeyType key; /* 排序码字段 */
/*DataType info; 记录的其它字段 */
} RecordNode;

typedef struct {
int n; /* n为文件中的记录个数，n<MAXNUM */
RecordNode record[MAXNUM];
} SortObject;

void quickSort(SortObject * pvector, int l, int r) {
    int i, j;
    RecordNode temp;
    RecordNode *data = pvector->record;

    if (l >= r) return;   /* 只有一个记录或无记录，则无须排序 */

    i = l;
    j = r;
    temp = data[i];

    while (i != j)
    {        /* 寻找Rl的最终位置 */
        while( data[j].key >= temp.key && j > i )
            j--;         /* 从右向左扫描，查找第1个排序码小于temp.key的记录 */
        if (i < j)
            data[i++] = data[j];

        while( data[i].key <= temp.key && j > i )
            i++;         /* 从左向右扫描，查找第1个排序码大于temp.key的记录 */
        if (i < j)
            data[j--] = data[i];
    }

    data[i] = temp;                 /* 找到Rl的最终位置 */
    quickSort(pvector, l, i-1);                 /* 递归处理左区间 */
    quickSort(pvector, i+1, r);            /* 递归处理右区间 */
}

SortObject vector = {8, 49,38,65,97,76,13,27,49};

int main(){
    int i;
    quickSort(&vector, 0, 7);
    for(i = 0; i < 8; i++)
        printf("%d ", vector.record[i]);
    getchar();
    return 0;
}

Shell排序:

Shell排序是以发明者命名的一种较快的排序方法。Shell排序基本算法思想是：将整个无序序列分割成若干小的子序分别进行插入排序。

　子序列的分割方法为：将相隔某个增量h的元素构成一个子序列。在排序过程中，逐次减小这个增量，最后当h减到1时，进行一次插入排序，排序就完成。

　在本函数中，增量序列取 ht=2t－1，1 tlog2n其中n为待排序序列的长度。

　例：（/* 将输入的数据排序后,输出一个测试Shell排序的主函数*/）

＃define SIZE 10

void shell();

main()
{
int d[SIZE],i;

printf("Input %d numbers/n",SIZE);

for(i = 0; i < SIZE; i++)
　　 scanf("%d", &d[i]);

　　shell(d, SIZE);

　　printf("After sort:/n")

　　for(i = 0; i < SIZE; i++)
　　 printf("%5d", d[i]);

　　printf("/n");
}

/*把数组V的元素按增序排序*/

void shell(int v[], int n)
{

int gap, i, j, temp;

　　for(gap = n/2; gap > 0; gap /= 2)

　　for(i = gap; i
　　for(j=i－gap;j>=0 && v[j])

　　v[j＋gap];j－=gap)

　　{ temp=v[j];

　　v[j]=v[j＋gap];

　　v[j＋gap]=temp; }

　注：这里，数组作为函数参数，参数组中元素值的改变就会反过来影响到实参数组。

二分查找(Binary Search):
　二分查找又称折半查找，它是一种效率较高的查找方法。
　二分查找要求：线性表是有序表，即表中结点按关键字有序，并且要用向量作为表的存储结构。不妨设有序表是递增有序的

/* 二分法插入排序的算法源程序*/

#include<stdio.h>

#define MAXNUM 100
typedef int KeyType;
typedef int DataType;

typedef struct {
    KeyType key;       /* 排序码字段 */
    /*DataType info;   记录的其它字段 */
} RecordNode;

typedef struct {
    int n;               /* n为文件中的记录个数，n<MAXNUM */
    RecordNode record[MAXNUM];
} SortObject;

void binSort(SortObject * pvector) {      /* 按递增序进行二分法插入排序 */
    int i, j, left, mid, right;
    RecordNode temp;
    RecordNode *data = pvector->record;
    
    for( i = 1; i < pvector->n; i++ ) {
        temp = data[i];
        left = 0;  right = i-1;           /* 置已排序区间的下、上界初值 */
        while (left <= right) {
            mid = (left + right)/2;       /* mid指向已排序区间的中间位置 */
            if (temp.key < data[mid].key)
                right = mid-1;            /* 插入元素应在左子区间 */
            else left = mid+1;            /* 插入元素应在右子区间 */
        }
        for (j = i-1;  j >= left;  j--)
            data[j+1] = data[j];          /* 将排序码大于ki的记录后移 */
        if (left != i) data[left] = temp;
    }
}

SortObject vector={10, 49,38,65,97,76,13,27,49,50,101};

int main(){
    int i;
    binSort(&vector);
    for(i = 0; i < vector.n; i++)
        printf("%d ", vector.record[i]);
    getchar();
    return 0;
}