考研排序算法

#include <iostream>
#define MAXSIZE 100

结构体

typedef struct {
    int key;
//    int other;
}recordtype;
typedef struct{
    recordtype r[MAXSIZE+1];
    int length;
}table;

1.直接插入排序(插入排序)

/**
 * 无哨兵
 * 算法思想：数组a是从0开始索引的，所以将i指向索引为1的元素，然后第一次比较就是比较0-1的元素的大小，i相当于做一个零界点而i所在的位置置空，将值放于X。
 * 然后将j于i比较再互换位置，之后j比较完再往前查找再比较。直到j=0的时候或者找到一个比x更小的元素，才比较完成，再吧x的值放到j+1处，i再往后移动添加一个新元素进来再进行比较排序。
 * 所以直接插入排序不将最后一个元素排完，所有的元素的目前所在位置都不一定是最后的位置。
 * @param a
 * @param n
 */
void insertsort(int a[],int n){
    int i,j,x;
    for (i=1;i<n;i++){
        x=a[i];
        j=i-1;
        while(j>=0 && a[j] > x){
            a[j+1]=a[j];
            j--;
        }
        a[j+1]=x;
    }
}

/**
 * 有哨兵：与无哨兵的差别在于，将A[0]空出作为哨兵，其作用与x相当用于存放i所指的元素的值
 * @param a
 * @param n
 */
void insertsortsb(int a[],int n){
    int i,j;
    for (i=1;i<n;i++){
        a[0]=a[i];
        j=i-1;
        while(j>=0 && a[j] > a[0]){
            a[j+1]=a[j];
            j--;
        }
        a[j+1]=a[0];
    }
}

2.二分插入排序(插入排序)

/**
 * 算法思想：
 * 索引0为空的用于存储元素，第一次划分1-2索引的元素进行二分插入排序，然后i++就是1-3的进行排序以此类推！
 * @param tab
 */
void binarysort(table* tab){
    int i,j,left,right,mid;
    for (i = 2; i < tab->length; ++i) {
        tab->r[0] = tab->r[i];//保存待插入的元素
        left=1;right=i-1;
        while (left <=right){
            mid=(right+left)/2;
            if (tab->r[i].key <tab->r[mid].key)//如果i的值比mid对应的值小，所有i应该插入在mid的左边所以right=right-1
                right=right-1;
            else
                left=left+1;
        }
        for (j=i-1; j >= left ; j--) {//j=i-1空一个位置插入然后将剩余的元素移动到相应的位置
            tab->r[j+1]=tab->r[j];
            tab->r[left]=tab->r[0];
        }
    }
}

3.希尔排序(插入排序)

void shellinsertsort(table* tab)
{
    int i,j,d;
    d=tab->length/2;
    while (d>=1){
        for (i = d+1; i <=tab->length; i++) {
            tab->r[0]=tab->r[i];//保存第i个元素
            j=i-d;
            while (j > 0 && tab->r[0].key < tab->r[j].key)
            {
                tab->r[j+d]=tab->r[j];
                j=j-d;
            }
            tab->r[j+d]=tab->r[0];
        }
        d/2;
    }
}

void shellinsertsort2(int a[],int length)
{
    int i,j,x,d;
    d=length/2;
    while(d>=1){
        for (i = d;  i< length; i++) {
            x=a[i];
            j=i-d;
            while (x<a[j] && j>=0)
            {
                a[j+d]=a[j];
                j=j-d;
            }
            a[j+d]=x;
        }
        d=d/2;
    }
}

4.直接选择排序(选择排序)

/**
 * 算法思想：每次找到一个最小的元素与i交换
 * @param tab
 */
void simpleelectsort(table* tab)
{
    int i,j,k;
    for (i = 1; i <=tab->length-1; i++) {//每次选择一个最小的元素和i进行交换
        k=i;//k指向最小的元素
        for (j = i+1; j <=tab->length; j++) {
            if (tab->r[j].key < tab->r[k].key)
                k=j;
            if (k!=i){
                tab->r[0]=tab->r[k];
                tab->r[k]=tab->r[i];
                tab->r[i]=tab->r[0];
            }
        }
    }
}

void simpleelectsort2(int a[],int length)
{
    int i,j,k;
    for (i = 1; i <=length-1; i++) {//每次选择一个最小的元素和i进行交换
        k=i;//k指向最小的元素
        for (j = i+1; j <=length; j++) {
            if (a[j] < a[k])
            {
                k=j;
            }
            if (k!=i){
                a[0]=a[k];
                a[k]=a[i];
                a[i]=a[0];
            }
        }
    }
}

5.冒泡排序(交换排序)

void bubblesort(table* tab){
    int i,j,done;
    i=1;
    done=1; //done=1代表发生了交换
    while(i<=tab->length && done)   //最多进行tab->length次排序,没有发生交换(done=0)则结束排序
    {
        done = 0;
        for(j=1;j<=tab->length-i;j++){
            if (tab->r[j + 1].key < tab->r[j].key)
            {
                tab->r[0] = tab->r[j];//已第0个元素作为中间元素
                tab->r[j] = tab->r[j + 1];
                tab->r[j + 1] = tab->r[0];
                done = 1;
            }
        }
        i++;
    }
}

void bubblesort2(int a[],int length){
    int i,j,done;
    i=1;
    done=1; //done=1代表发生了交换
    while(i<=length && done)   //最多进行tab->length次排序,没有发生交换(done=0)则结束排序
    {
        done = 0;
        for(j=1;j<=length-i;j++){
            if (a[j + 1] < a[j])
            {
                a[0] = a[j];//已第0个元素作为中间元素
                a[j] = a[j + 1];
                a[j + 1] = a[0];
                done = 1;
            }
        }
        i++;
    }
}

6.快速排序(交换排序)

void quicksort(table* tab, int left, int right)
{
    int i, j;
    if (left < right)
    {
        i = left; j = right;
        tab->r[0] = tab->r[i];
        do {
            while (tab->r[j].key > tab->r[0].key && i < j)
                j--;
            if (i < j)
            {
                tab->r[i].key = tab->r[j].key;
                i++;
            }
            while (tab->r[i].key < tab->r[0].key && i < j)
                i++;
            if (i < j)
            {
                tab->r[j].key = tab->r[i].key;
                j--;
            }
        } while (i != j);
        tab->r[i]=tab->r[0];
        quicksort(tab, left, i - 1);
        quicksort(tab, i + 1, right);
    }
}

void quicksort2(int a[],int length, int left, int right)
{
    int i, j;
    if (left < right)
    {
        i = left; j = right;
        a[0] = a[i];
        do {
            while (a[j] > a[0] && i < j)
                j--;
            if (i < j)
            {
                a[i] = a[j];
                i++;
            }
            while (a[i] < a[0] && i < j)
                i++;
            if (i < j)
            {
                a[j] = a[i];
                j--;
            }
        } while (i != j);
        a[i]=a[0];
        quicksort2(a,length, left, i - 1);
        quicksort2(a,length, i + 1, right);
    }
}

int main() {
    int a[]={0,27,46,5,18,16,51,32,26};
    int size = 9;
    quicksort2(a,size,1,size);
    for (int i = 1; i < size; i++) {
        printf("%d\t",a[i]);
    }
    return 0;
}