排序2

本博客的代码的思想和图片参考：好大学慕课浙江大学陈越老师、何钦铭老师的《数据结构》

 

 

排序2

 

1 快速排序

 

1.1 算法思想

 

快速排序的主要思想就是分而治之。选择一个主元，然后把原来的集合分为比主元小和比主元大两个子集合，然后递归的解决左边，递归的解决右边。我们使用一幅图片来进行说明

 

 

 

 

 

 

 

 

 

 

 

 

 

下面是快速排序的伪代码描述

 

void Quicksort( ElementType A[], int N )

 

{

 

if ( N < 2 ) return;

 

pivot = 从A[]中选一个主元;

 

将S = { A[] \ pivot } 分成2个独立子集:

 

A1={ aS | a  pivot } 和

 

A2={ aS | a  pivot };

 

A[] =

 

Quicksort(A1,N1)U

 

pivot}U

 

Quicksort(A2,N2);

 

}

 

1.2 快速排序的性能分析

 

因为快速排序是递归进行的，递归算法的好处体现在每次可以递归的解决规模差不多的子问题。如果主元选的不好，让子集大小很悬殊，那么快速排序就快不起来了。下面是使用一幅图片来说明如果主元选取的不好，那么就会很囧。

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

可以看出，如果主元选的不好，那么快速排序的时间复杂度为O(N^2),很糟糕

 

1.3 常见的选择主元的方法

 

1.随机取 pivot?rand()函数不便宜啊!

 

2.取头、中、尾的中位数

 

例如 8、12、3的中位数就是8

 

下面给出中位数法的伪代码描述

 

ElementType Median3( ElementType A[], int Left, int Right )

 

{

 

int Center = ( Left + Right ) / 2;

 

if ( A[ Left ] > A[ Center ] )

 

Swap( &A[ Left ], &A[ Center ] );

 

if ( A[ Left ] > A[ Right ] )

 

Swap( &A[ Left ], &A[ Right ] );

 

if ( A[ Center ] > A[ Right ] )

 

Swap( &A[ Center ], &A[ Right ] );

 

/* A[ Left ] <= A[ Center ] <= A[ Right ] */

 

Swap( &A[ Center ], &A[ Right-1 ] ); /* 将pivot藏到右边 */

 

/* 只需要考虑 A[ Left+1 ] ... A[ Right–2 ] */

 

return A[ Right-1 ]; /* 返回 pivot */

 

}

 

1.4 子集划分算法

 

使用一幅图片来说明

 

 

 

 

 

 

 

 

 

 

如果有元素正好等于pivot怎么办?

 

1.停下来交换?

 

1.不理它,继续移动指针?

 

举一个极端的例子，如果，如果一个数组全是和主元相等，如果使用停下来交换，就会做无用的交换，如果 不理它,继续移动指针，那么i会一直移动到大于j，此时我们的主元就会在端点，那么所造成的影响就是时间复杂度为O(N^2)

 

所以我们选择 停下来交换

 

 

1.5快速排序的问题

 

1.用递归......

 

对小规模的数据(例如N不到100)可能还不如插入排序快

 

 

2.解决方案

 

当递归的数据规模充分小,则停止递归,直接调用简单排序(例如插入排序)

 

在程序中定义一个Cutoff的阈值 —— 课后去实践一下,比较不同的Cutoff对效率的影响

 

 

1.6快速排序的测试结果

 

 

 

 

 

 

 

 

 

阀值都取100的情况下

 

 

 

 

 

1.7 结果分析

 

对于不同的阀值，发现效率差距并不是很大。但是选择不同pivot，差距很大。从测试结果看

 

中位数效果最好，随机数次之，使用第一个元素作为pivot效果最差。所以今后尽量使用中位数方法。

1.8 快速排序代码

 

/*
 * quickSort.c
 *
 *  Created on: 2017年5月20日
 *      Author: ygh
 */

#include <stdio.h>
#include <stdlib.h>
#define  MAX_LENGTH 100000
typedef int elementType;

/*
 * Swap two integer number value
 */
void swap(elementType *a, elementType *b) {
    int temp = *b;
    *b = *a;
    *a = temp;
}

/*
 * Print the array to console
 * @param a A integer array need to sort
 * @param n The length of the array
 */
void printArray(int a[], int n) {
    int i;
    for (i = 0; i < n; i++) {
        if (i == n - 1) {
            printf("%d", a[i]);
        } else {
            printf("%d ", a[i]);
        }
    }
    printf("\n");
}

/*
 * Get input data from command
 */
void getInputData(elementType *a, int n) {
    int i;
    elementType x;
    for (i = 0; i < n; i++) {
        scanf("%d", &x);
        a[i] = x;
    }
}

/*
 * Implement insertion sort.
 *@param a A <code>elementType</code> array need to sort
 *@param n The length of the array
 */
void insertion_sort(elementType a[], int n) {
    int i, j;
    elementType temp;
    for (i = 1; i < n; i++) {
        temp = a[i];
        for (j = i; j > 0 && a[j - 1] > temp; j--) {
            a[j] = a[j - 1];
        }
        a[j] = temp;
    }

}

/*
 *Get the pivot by get the median amount three number
 */
elementType getPivotByMedian3(elementType a[], int left, int right) {
    int center = (left + right) / 2;
    /*
     * Let a[left]<= a[center] <= a[right]
     */
    if (a[left] > a[center]) {
        swap(&a[left], &a[center]);
    }

    if (a[left] > a[right]) {
        swap(&a[left], &a[right]);
    }

    if (a[center] > a[right]) {
        swap(&a[center], &a[right]);
    }

    /*
     * We has known the a[right] greater than a[center]
     * so we swap the a[center] and a[right-1],so we just
     * consider from a[left+1] to a[right-2] when we divide sub-set
     */
    swap(&a[center], &a[right - 1]);
    return a[right - 1];

}

elementType getPivotByRandom(elementType a[], int left, int right) {
    int index = rand() % (right - left + 1) + left;
    return index;
}

/*
 * Implement quick sort,we get the pivot by the middle of three numbers
 * @param a A <code>elementType</code> array need to sort
 * @param left The starting index of sub-set
 * @param right The finishing index of sub-set
 * @param A cutoff to determine how many numbers rest we will
 * use the insertion sort.
 */
void qSort(elementType a[], int left, int right, int cutoff) {
    int low, high;
    elementType pivot;
    if (cutoff <= right - left) {
        pivot = getPivotByMedian3(a, left, right);
        low = left;
        high = right - 1;
        while (1) {
            while (a[++low] < pivot)
                ;
            while (a[--high] > pivot)
                ;
            if (low < high) {
                swap(&a[low], &a[high]);
            } else {
                break;
            }
        }
        swap(&a[low], &a[right - 1]);
        qSort(a, left, low - 1, cutoff);
        qSort(a, low + 1, right, cutoff);

    } else {
        insertion_sort(a + left, right - left + 1);
    }
}

/*
 * Implement quick sort,we get the pivot by the middle of three numbers
 * @param a A <code>elementType</code> array need to sort
 * @param left The starting index of sub-set
 * @param right The finishing index of sub-set
 * @param A cutoff to determine how many numbers rest we will
 * use the insertion sort.
 */
void qSortByRandom(elementType a[], int left, int right, int cutoff) {
    int low, high, index;
    elementType pivot;
    if (cutoff <= right - left) {
        index = getPivotByRandom(a, left, right);
        swap(&a[left], &a[index]);
        pivot = a[left];
        low = left;
        high = right;
        while (low < high) {
            while (low < high && a[high] >= pivot) {
                high--;
            }
            a[low] = a[high];
            while (low < high && a[low] <= pivot) {
                low++;
            }
            a[high] = a[low];
        }
        a[low] = pivot;
        qSortByRandom(a, left, low - 1, cutoff);
        qSortByRandom(a, low + 1, right, cutoff);
    } else {
        insertion_sort(a + left, right - left + 1);
    }
}

/*
 * Implement quick sort,we get the pivot by the middle of three numbers
 * @param a A <code>elementType</code> array need to sort
 * @param left The starting index of sub-set
 * @param right The finishing index of sub-set
 * @param A cutoff to determine how many numbers rest we will
 * use the insertion sort.
 */
void qSortByFirstNum(elementType a[], int left, int right, int cutoff) {
    int low, high;
    elementType pivot;
    if (cutoff <= right - left) {
        pivot = a[left];
        low = left;
        high = right;
        while (low < high) {
            while (low < high && a[high] >= pivot) {
                high--;
            }
            a[low] = a[high];
            while (low < high && a[low] <= pivot) {
                low++;
            }
            a[high] = a[low];
        }
        a[low] = pivot;
        qSortByFirstNum(a, left, low - 1, cutoff);
        qSortByFirstNum(a, low + 1, right, cutoff);
    } else {
        insertion_sort(a + left, right - left + 1);
    }
}

/*
 * Implement sort unitized interface
 * @param a A <code>elementType</code> array need to sort
 * @param n The length of the array
 */
void quickSort(elementType a[], int n) {
//    qSort(a, 0, n - 1, 100);
//    qSortByRandom(a, 0, n - 1, 100);
    qSortByFirstNum(a, 0, n - 1, 2);
}



int main() {
    int a[MAX_LENGTH];
    int n;
    scanf("%d", &n);
    getInputData(a, n);
    quickSort(a, n);
    printArray(a, n);
    return 0;
}

 

 

2 表排序

2.1概述

在我们之前学过的排序中，我们都是使用交换两个元素的位置来进行排序。可是如果现在的元素不是两个简单的数字，而是2G的视频，如果进行交换位置的排序，那么就要计算元素移动的时间。那么我们然后对这些元素进排序呢。

2.2 算法思想

下面有一组数据，里面的数据我们可以抽象是结构体存储。每个数据按照key去排序。但是结构体里面不仅仅有key，每个结构体还有2G的视频内容。那我们如何进行排序。例如下图：

 

 

 

 

 

 

那么如何在不进行移动元素的情况下，对数据按key进排序。我们在为数据增加一行指针数组，叫做表(table)，来记录正确顺序的A的角标。初始化指针数组的值和A的角标对应。然后我们安装普通排序的方法(插入排序)对指针数组进排序。如，按照插入排序，第一趟比较f和d的大小 ，d<f,则把table的0角标元素往后面摞一位，然后在table的0角标放入1值。代表指向a[1].keytable的1角标存放0，代表指向a[0].key。然后下面按照插入排序进行对table的元素进排序。

下面使用一幅图片来说明：

 

 

 

2.3 物理排序

上面我们已经在逻辑上把数据排好序了，如果只需顺序输出，那么我只需要做A[table[0]],A[table[1]]… a[table[n-1]]即可。但是如果我们需要把把数据进行排序，让其逻辑上进行有序，那应该怎么做。

首先我们有一个定理：N个数字的排列由若干个独立的环组成

我们来看一下我们最终排序的结果：

 

 

 

 

 

 

由于进行元素的交换，则产生环路。位置和初始状态没有发生改变的独自成环。下面我们需要根据环来对物理数据进行排序。

首先建立一个临时的数据存储单元temp，用来存储临时的变量。我们从A[0]开始。temp=f，通过table[0]找到A[3],让A[0]=A[3],并更新table[0]=0;在通过A[3]的table[3]找到A[1],让A[3]=A[1],更新table[3]=3……

如何判断环结束table[i]==i

2.4 时间复杂度分析

最好情况：一开始有序，那么就不需要进行交换

我们知道，每一个环需要开辟一个temp数组，如果一个环中有T个元素，需要移动T+1次,多了两次temp的移进和移出。

那么最坏的情况是有N/2个环，每个环有2个元素，每个环需要移动3次。总共需移动(3N)/2次

T=O(mN).m为每个元素移动的时间，当元素的移动时间不能忽略时，就必须加上m

3 基数排序

3.1 桶排序

我们首先举一个例子：

 

 

 

 

 

 

 

 

 

3.2基数排序的算法思想

 

 

3.3 基数排序思想的应用

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

表排序的源代码

/*
 * tableSort.c
 *
 *  Created on: 2017年5月22日
 *      Author: ygh
 */
#include <stdio.h>
#include <stdlib.h>
#define MAX_LENGTH 100

typedef int contentType;

typedef struct node element;
typedef struct node {
    char key;
    contentType content;
} data[MAX_LENGTH];

typedef struct node1 *ptrTable;
typedef struct node1 {
    data d;
    int table[MAX_LENGTH];
};

/*
 * Create a empty table to store data
 * @param n The length of the table
 * @return ptrTable A point of structure of the table
 */
ptrTable createEmptyTable(int n) {
    ptrTable table = (ptrTable) malloc(sizeof(struct node1));
    int i;
    for (i = 0; i < n; i++) {
        table->table[i] = i;
    }
    return table;
}

/*
 * Insert a data to table
 * @param table A point of structure of the table
 * @param index The index of the element inserted
 * @param key The key of the element inserted
 * @param content The content of the element inserted
 */
void insertData(ptrTable table, int index, char key, contentType content) {
    table->d[index].content = content;
    table->d[index].key = key;
}

/*
 * Implement table sort.
 * Algorithms thoughts:
 * 1.Because the data in <code>data</code> is too large,So we don't swap them
 * 2.We use a table to record the data position,at the first time,the table's value is
 *     equal the index in the <code>data</code>
 * 3. we sort data by key and record the sorted position by the table
 * 4.When we need to access the table sorted,we just access data[table[i]]
 *
 * @param table A point of structure of the table
 * @param n The length of the table
 */
void tableSort(ptrTable table, int n) {
    int i, j;
    char key;
    int t;
    for (i = 1; i < n; i++) {
        key = table->d[i].key;
        t = table->table[i];
        for (j = i; j > 0 && table->d[table->table[j - 1]].key > key; j--) {
            table->table[j] = table->table[j - 1];
        }
        table->table[j] = t;
    }
}

/*
 * Implement the data physical sort according the table
 * @param table A point of structure of the table
 * @param n The length of the table
 *
 */
void physicalSort(ptrTable table, int n) {
    int i, j;
    int t;
    element temp;
    for (i = 0; i < n; i++) {
        if (table->table[i] != i) {
            temp = table->d[i];
            t = table->table[i];
            table->d[i] = table->d[t];
            table->table[i] = i;
            j = t;
            while (t != i) {
                t = table->table[j];
                if (t == i) {
                    break;
                }
                table->d[j] = table->d[t];
                table->table[j] = j;
                j = t;
            }
            table->d[j] = temp;
            table->table[j] = j;
        } else {
            continue;
        }
    }
}

/*
 * Print the table's content to console
 * @param table A point of structure of the table
 * @param n The length of the table
 */
void toStringTale(ptrTable table, int n) {
    int i;
    for (i = 0; i < n; i++) {
        printf("key:%c,content:%d\n", table->d[table->table[i]].key,
                table->d[table->table[i]].content);
    }
}

int main() {
    char arr[] = "fdcagbhe";
    int i;
    int n = 8;
    ptrTable table = createEmptyTable(n);
    for (i = 0; i < n; i++) {
        insertData(table, i, arr[i], i);
    }
    tableSort(table, n);
    //toStringTale(table, n);
    physicalSort(table, n);
    toStringTale(table, n);
    return 0;
}

表排序的测试结果：

key:a,content:3
key:b,content:5
key:c,content:2
key:d,content:1
key:e,content:7
key:f,content:0
key:g,content:4
key:h,content:6

 

基数排序LSD

/*
 * radixSortLSD.c
 * Implement radix sort of Least Significant Digit
 *
 *  Created on: 2017年5月23日
 *      Author: ygh
 */
#include <stdio.h>
#include <stdlib.h>

#define  MAX_LENGTH 10000

/*
 *The quantity of the the keys of element
 *For example 0-9999 have four keys
 */
#define MAX_DIGIT 6
/*
 *The quantity of the bucket.In this case ,we sort integer number
 *So the buckets is from 0 to 9
 */
#define RADIX 10

#define BEGIN_DIGIT 0

/*
 * The type of the element type
 */
typedef int elementType;

/*
 * Define a data structure for bucket node
 */
typedef struct node *ptrToNode;
typedef struct node {
    /*
     * The element type the bucket node store
     */
    elementType key;
    /*
     * A next point to point next element
     */
    ptrToNode next;

};

/*
 * Define a data structure for bucket head that
 * store the head point and rear point for the elements
 */
typedef struct headNode {
    ptrToNode head, rear;
};

/*
 * Define a array of headNode to store the all buckets
 */
typedef struct headNode bucket[RADIX];

/*
 * Get the digit by the current number and current needed digit
 * @param x The current number
 * @param d The current digit
 * @return The digit needed
 */
int getDigit(elementType x, int d) {
    int i;
    int di;
    for (i = 0; i < d; i++) {
        di = x % RADIX;
        x = x / RADIX;
    }
    return di;
}

void LSDRadixSort(elementType a[], int n) {
    int d, di, i;
    /*
     * Define a bucket array to store all buckets
     */
    bucket b;

    /*
     * Define three node point
     * @param temp Store temporary node
     * @param p A node point will be used when search
     * @param list A node point to build elements list and recovery
     * elements from finished sort
     */
    ptrToNode temp, p, list;

    /*
     * Initialize each bucket head and rear into NULL
     */
    for (i = BEGIN_DIGIT; i < RADIX; i++) {
        b[i].head = b[i].rear = NULL;
    }

    /*
     * Change array elements into list elements,but it is DESC
     */
    for (i = 0; i < n; i++) {
        temp = (ptrToNode) malloc(sizeof(struct node));
        temp->key = a[i];
        temp->next = list;
        list = temp;
    }

    /*
     * Do radix sort
     */
    for (d = 1; d <= MAX_DIGIT; d++) {
        p = list;
        while (p) {
            di = getDigit(p->key, d);
            if (di < 0) {
                di = di * (-1);
            }
            /*
             * Delete this element from the list
             */
            temp = p;
            p = p->next;
            temp->next = NULL;
            if (b[di].head == NULL) {
                b[di].head = b[di].rear = temp;
            } else {
                b[di].rear->next = temp;
                b[di].rear = temp;
            }
        }

        /*
         * Recover the elements has been deal with,using
         * the list to point the head
         */
        list = NULL;
        for (di = RADIX - 1; di >= BEGIN_DIGIT; di--) {
            if (b[di].head) {
                b[di].rear->next = list;
                list = b[di].head;
                /*
                 * Clear the head and rear
                 */
                b[di].rear = b[di].head = NULL;
            }
        }
    }

    /*
     * Put sorted list data to array
     */
    for (i = 0; i < n; i++) {
        temp = list;
        list = list->next;
        a[i] = temp->key;
        free(temp);
    }

}

/*
 * Print the array to console
 * @param a A integer array need to sort
 * @param n The length of the array
 */
void printArray(int a[], int n) {
    int i;
    for (i = 0; i < n; i++) {
        if (i == n - 1) {
            printf("%d", a[i]);
        } else {
            printf("%d ", a[i]);
        }
    }
    printf("\n");
}

/*
 * Get input data from command
 */
void getInputData(elementType *a, int n) {
    int i;
    elementType x;
    for (i = 0; i < n; i++) {
        scanf("%d", &x);
        a[i] = x;
    }
}

/*
 * Separate a array into positive array and negative array
 * @param a A array store the positive number or negative number
 * @param n The length of the a
 * @param pL The length of the positive array
 * @param pL The length of the negative array
 */
void separate(elementType *a, int n, int *pL, int *nL,
        elementType positiveArr[], elementType negativeArr[]) {
    int i;
    for (i = 0; i < n; i++) {
        if (a[i] < 0) {
            negativeArr[(*nL)++] = a[i];
        } else {
            positiveArr[(*pL)++] = a[i];
        }
    }
}

/*
 * Implement radix sort
 */
void radixSort(elementType a[], int n) {
    int positiveArr[MAX_LENGTH];
    int negativeArr[MAX_LENGTH];
    int pL = 0, nL = 0, i, j;
    separate(a, n, &pL, &nL, positiveArr, negativeArr);
    LSDRadixSort(positiveArr, pL);
    LSDRadixSort(negativeArr, nL);
    i = nL - 1;
    j = 0;
    while (i >= 0) {
        a[j] = negativeArr[i];
        i--;
        j++;
    }
    i = 0;
    while (i < pL) {
        a[j] = positiveArr[i];
        i++;
        j++;
    }

}

int main() {
    elementType a[MAX_LENGTH];
    int n;
    scanf("%d", &n);
    getInputData(a, n);
    radixSort(a, n);
    printArray(a, n);
    return 0;
}

基数排序MSD

/*
 * radixSortMSD.c
 *Implement radix sort(Most Significant Digit)
 *  Created on: 2017年5月24日
 *      Author: ygh
 */
#include <stdio.h>
#include <stdlib.h>

#define MAX_LENGTH 100000
#define RADIX 10
#define MAX_DIGIT 3
#define BEGIN_DIGIT 0

/*
 * Define element type the array or list store
 */
typedef int elementType;

/*
 * Define a list to store elememts from array
 */
typedef struct node *ptrToNode;
typedef struct node {
    elementType key;
    ptrToNode next;
};

/*
 * Define a bucket to point the each bucket list head and rear
 */
typedef struct headNode {
    ptrToNode head, rear;
};

/*
 *Define a bucket array to store all buckets
 */
typedef struct headNode bucket[RADIX];

/*
 * Get the current number digit by current digit needed
 * @param x The number current need to sort
 * @param d The digit current need to get
 * @return A current digit of this number
 */
int getDigit(elementType x, int d) {
    int i;
    int de;
    for (i = 0; i < d; i++) {
        de = x % RADIX;
        x = x / RADIX;
    }
    return de;
}

/*
 * Implement radix sort by MSD,we will recursive to implement it
 */
void radixSortMSD(elementType a[], int left, int right, int d) {
    int di, i, j;
    /*
     * Define three point of the list
     * @param p The point is used for searching
     * @param temp The point is used for temporary store
     * @param list The point is used for store all elements
     */
    ptrToNode p, temp, list = NULL;
    /*
     * Define a bucket array for all buckets
     */
    bucket b;

    /*
     * recursive end conditional
     */
    if (d == 0) {
        return;
    }
    /*
     * Initialize all bucket,let head and rear get NULL
     */
    for (i = BEGIN_DIGIT; i < RADIX; i++) {
        b[i].head = b[i].rear = NULL;
    }

    /*
     * Change array storing into list storing,it make the data
     * easily to be deal with
     */
    list = NULL;
    for (i = left; i <= right; i++) {
        temp = (ptrToNode) malloc(sizeof(struct node));
        temp->key = a[i];
        temp->next = list;
        list = temp;
    }

    p = list;
    /*
     * Get digit from current number and deal with them
     */
    while (p) {
        di = getDigit(p->key, d);
        temp = p;
        p = p->next;
        temp->next = NULL;
        if (b[di].head == NULL) {
            b[di].rear = temp;
            b[di].head=temp;
        } else {
            temp->next = b[di].head;
            b[di].head = temp;
        }

    }

    /*
     * recover elements from bucket
     */
    i = j = left;
    for (di = 0; di < RADIX; di++) {
        if (b[di].head) {
            p = b[di].head;
            while (p) {
                temp = p;
                p = p->next;
                a[j++] = temp->key;
                free(temp);
            }
            /*
             *recursive caller this method
             */
            radixSortMSD(a, i, j - 1, d - 1);
            i = j;
        }
    }
}

/*
 * Implement radix sort
 */
void radixSort(elementType a[], int n) {
    radixSortMSD(a, 0, n - 1, MAX_DIGIT);
}

/*
 * Print the array to console
 * @param a A integer array need to sort
 * @param n The length of the array
 */
void printArray(int a[], int n) {
    int i;
    for (i = 0; i < n; i++) {
        if (i == n - 1) {
            printf("%d", a[i]);
        } else {
            printf("%d ", a[i]);
        }
    }
    printf("\n");
}

/*
 * Get input data from command
 */
void getInputData(elementType *a, int n) {
    int i;
    elementType x;
    for (i = 0; i < n; i++) {
        scanf("%d", &x);
        a[i] = x;
    }
}

int main() {
    elementType a[MAX_LENGTH];
    int n;
    scanf("%d", &n);
    getInputData(a, n);
    radixSort(a, n);
    printArray(a, n);
    printf("just test");
    return 0;
}

 

练习题：

10-排序4 统计工龄   (20分)

给定公司NNN名员工的工龄，要求按工龄增序输出每个工龄段有多少员工。
输入格式:

输入首先给出正整数NNN（≤105\le 10^5≤10​5​​），即员工总人数；随后给出NNN个整数，即每个员工的工龄，范围在[0, 50]。
输出格式:

按工龄的递增顺序输出每个工龄的员工个数，格式为：“工龄:人数”。每项占一行。如果人数为0则不输出该项。
输入样例:

8
10 2 0 5 7 2 5 2

输出样例:

0:1
2:3
5:2
7:1
10:1

    时间限制：400ms
    内存限制：64MB
    代码长度限制：16kB
    判题程序：系统默认
    作者：陈越
    单位：浙江大学

题目判定
解题程序
编译器：*
程序代码：*
提交

我使用了归并排序为基础，下面是代码的实现

/*
 * countAge.c
 *
 *  Created on: 2017年5月24日
 *      Author: ygh
 */

#include <stdio.h>
#include <stdlib.h>
#define  MAX_LENGTH 100000

typedef int elementType;

/*
 * Swap two integer number value
 */
void swap(elementType *a, elementType *b) {
    int temp = *b;
    *b = *a;
    *a = temp;
}

/*
 * Merge sub-sequence to original array.
 * @param a original <code>elementType</code> array to store the elements
 * @param tmpA temporary  <code>elementType</code> array to store the temporary elements
 * @param l The start index of left sub-sequence
 * @param r The start index of left sub-sequence
 * @param rightEnd The end index of left sub-sequence
 */
void merge(elementType a[], elementType tmpA[], int l, int r, int rightEnd) {
    /*
     * lefeEnd is the r-1,the sub-sequence is adjacent
     */
    int leftEnd = r - 1;
    /*
     * tmp is the counter of the <code>tmpA</code>
     * we should let <code>tmpA</code> index corresponding original array
     */
    int tmp = l;
    /*
     * Record the quantity of the all elements
     */
    int numElements = rightEnd - l + 1;
    int i;
    while (l <= leftEnd && r <= rightEnd) {
        if (a[l] <= a[r]) {
            tmpA[tmp++] = a[l++];
        } else {
            tmpA[tmp++] = a[r++];
        }
    }
    while (l <= leftEnd) {
        tmpA[tmp++] = a[l++];
    }
    while (r <= rightEnd) {
        tmpA[tmp++] = a[r++];
    }

    /*
     * Put <code>tmpA</code> elements into the original array
     */
    for (i = 0; i < numElements; i++, rightEnd--) {
        a[rightEnd] = tmpA[rightEnd];
    }
}

/*
 * Implement the merge sort
 * @param a original <code>elementType</code> array to store the elements
 * @param tmpA temporary  <code>elementType</code> array to store the temporary elements
 * @param l The start index of the array which need to sort
 * @param rightEnd The end index of the array which need to sort
 */
void mergetSortRecursive(elementType a[], elementType tmpA[], int l,
        int rightEnd) {
    int center;
    if (l < rightEnd) {
        center = (l + rightEnd) / 2;
        mergetSortRecursive(a, tmpA, l, center);
        mergetSortRecursive(a, tmpA, center + 1, rightEnd);
        merge(a, tmpA, l, center + 1, rightEnd);
    }
}

/*
 * Implement merge sort
 * @param a A integer array need to sort
 * @param n The length of the array
 */
void merger_sortRecursive(elementType a[], int n) {
    elementType *tmpA;
    tmpA = malloc(n * sizeof(elementType));
    if (tmpA != NULL) {
        mergetSortRecursive(a, tmpA, 0, n - 1);
        free(tmpA);
    } else {
        printf("no enough space to apply for temporary array");
    }
}

/*
 *merge ordered sub-sequence
 * @param a original <code>elementType</code> array to store the elements
 * @param tmpA temporary  <code>elementType</code> array to store the temporary elements
 * @param n The length of the a
 * @param the ordered current sub-sequence length
 */
void mergerPass(elementType a[], elementType tmpA[], int n, int lenth) {
    int i, j;
    /*
     * The loop will stop when meet the last two ordered sub-sequence
     * The rest may be two sub-sequence of one sub-sequence
     */
    for (i = 0; i <= n - 2 * lenth; i += lenth * 2) {
        merge(a, tmpA, i, i + lenth, i + 2 * lenth - 1);
    }
    /*
     *If the rest of is two sub-sequence
     */
    if (i + lenth < n) {
        merge(a, tmpA, i, i + lenth, n - 1);
    } else {
        for (j = i; j < n; j++)
            tmpA[j] = a[j];
    }
}

/*
 * Use loop method to implement the merge sort
 * @param a A integer array need to sort
 * @param n The length of the array
 */
void merger_SortLoop(elementType a[], int n) {
    int length;
    elementType *tmpA;
    length = 1;
    tmpA = malloc(n * sizeof(elementType));
    if (tmpA != NULL) {
        while (length < n) {
            /*
             * merge ordered sub-sequence into <code>tmpA</code>
             */
            mergerPass(a, tmpA, n, length);
            length *= 2;
            /*
             * merge ordered sub-sequence from <code>tmpA</code> into <code>a</code>
             */
            mergerPass(tmpA, a, n, length);
            length *= 2;
        }
        free(tmpA);
    } else {
        printf("no enough to apply for temporary array");
    }
}

/*
 * Print the array to console
 * @param a A integer array need to sort
 * @param n The length of the array
 */
void printArray(int a[], int n) {
    int i;
    for (i = 0; i < n; i++) {
        if (i == n - 1) {
            printf("%d", a[i]);
        } else {
            printf("%d ", a[i]);
        }
    }
    printf("\n");
}

/*
 * Get input data from command
 */
void getInputData(elementType *a, int n) {
    int i;
    elementType x;
    for (i = 0; i < n; i++) {
        scanf("%d", &x);
        a[i] = x;
    }
}

/*
 * Count age and print them to console
 */
void countAge(elementType a[], int n) {
    int i;
    int key = a[0];
    int counter = 1;
    for (i = 1; i < n; i++) {
        if (a[i] == key) {
            counter++;
        } else {
            printf("%d:%d\n",key,counter);
            key = a[i];
            counter=1;
        }
    }
    printf("%d:%d\n",key,counter);
}

int main() {
    int a[MAX_LENGTH];
    int n;
    scanf("%d", &n);
    getInputData(a, n);
    merger_SortLoop(a, n);
    countAge(a, n);
    return 0;
}

 

 

 

4 练习

4.1 Sort with Swap(0, i)

Given any permutation of the numbers {0, 1, 2,..., N−1}, it is easy to sort them in increasing order. But what if Swap(0, *) is the ONLY operation that is allowed to use? For example, to sort {4, 0, 2, 1, 3} we may apply the swap operations in the following way:

Swap(0, 1) => {4, 1, 2, 0, 3}
Swap(0, 3) => {4, 1, 2, 3, 0}
Swap(0, 4) => {0, 1, 2, 3, 4}

Now you are asked to find the minimum number of swaps need to sort the given permutation of the first N nonnegative integers.

Input Specification:

Each input file contains one test case, which gives a positive N (≤10​5​​) followed by a permutation sequence of {0, 1, ..., N−1}. All the numbers in a line are separated by a space.

Output Specification:

For each case, simply print in a line the minimum number of swaps need to sort the given permutation.

Sample Input:

10
3 5 7 2 6 4 9 0 8 1

Sample Output:

9

• 时间限制：400ms

• 内存限制：64MB

• 代码长度限制：16kB

• 判题程序：系统默认

• 作者：陈越

• 单位：浙江大学

4.2 算法思想

这道题目要求我们和零交换来实现排序，那么我们联想到之前的表排序，如何对下表实现物理排序，那么需要在每个环中进行位置的交换。在环中进行位置交换的时候，我们会先使用一个临时的空间去存放第一个需要交换的元素，然后让第一个元素有一个空位，然后把下一个元素移动到第一个元素的位置。直到环中的最后一个元素，把临时空间中的元素移动到最后一个元素的位置。根据此算法思想，我们可以衍生此题的解法。我们把每次移动的空闲位置区域看做是0，然后每次移动元素时，就相当和0进行交换。如果有的环不包括0，怎么办？我们可以把0换到环里，然后进行移动。

 

4.3 环的分类

 

 

4.4 程序的实现

我们知道0-N个元素有序排列应该这样

下标	0	1	2	3	4	5	6	7	8	9
A[]	0	1	2	3	4	5	6	7	8	9

但是现在题目所给的序列为这样

下标	0	1	2	3	4	5	6	7	8	9
A[]	3	5	7	2	6	4	9	0	8	1

我们需要建立如下一个数组T[],来记录当前元素存储的位置，例如A[0]应该存放0元素，但是我们不能遍历一遍A[]去查找0元素，这样太慢了。我们在插入0时就应该记录0所在的位置。例如插入0的时候，i为7，我们需要记录T[A[i]]=i。这样我们就可以很快的通过A[0]=0=A[T[0]]

下面我们构造T[]数组

下标	0	1	2	3	4	5	6	7	8	9
T[]	7	9	3	0	5	1	4	2	8	6

这样我们可以建立一个环了。

 

 

下面是代码：代码可以通过PTA所有的测试点

/*
 * SortwithSwap.c
 *
 *  Created on: 2017年5月25日
 *      Author: ygh
 */
#include <stdio.h>
#include <stdlib.h>

#define MAX_LENGTH 100000

typedef int elementType;
/*
 * Define a data structure to store data
 */
typedef struct dataNode *ptrToData;
typedef struct dataNode {
    elementType a[MAX_LENGTH];
    int table[MAX_LENGTH];
};

/*
 * Create empty array point
 */
ptrToData createEmptyData() {
    ptrToData data = (ptrToData) malloc(sizeof(struct dataNode));
    return data;
}

/*
 * Insert element to data and record the index
 * @param data A point to point the data
 * @param n The length of the arrays
 */
void insertElement(ptrToData data, int n) {
    elementType x;
    int i;
    for (i = 0; i < n; i++) {
        scanf("%d", &x);
        data->a[i] = x;
        data->table[x] = i;
    }
}

/*
 *Calculate the swap times.when we access next element by
 *circle, we let the counter increase one. If the circle contain zero,counter decrease one
 *otherwise counter increase one.
 * @param data A point to point the data
 * @param n The length of the arrays
 * @param m The counter of the multiple circle
 * @param s The counter of the single circle
 */
int calculateSwapTimes(ptrToData data, int n) {
    /*
     * @param key  The index to record the next element by circle
     * @param j The index the current element
     */
    int i,key,j;
    /*
     * record the all swap
     */
    int counter=0;
    for (i = 0; i < n; i++) {
        if(i==data->table[i]){
            continue;
        }else{
            key = data->table[i];
            counter++;
            data->table[i]=i;
            j=key;
            while(key!=i){
                key=data->table[j];
                counter++;
                data->table[j]=j;
                j = key;
            }
            if(i==0){
                counter--;
            }else{
                counter++;
            }
        }
    }
    return counter;
}

void toString(ptrToData data, int n) {
    int i;
    for (i = 0; i < n; i++) {
        printf("%d ", data->a[data->table[i]]);
    }
}

int main() {
    ptrToData data = createEmptyData();
    int n,count;
    scanf("%d", &n);
    insertElement(data, n);
    count = calculateSwapTimes(data, n);
    printf("%d",count);
    return 0;
}