排序

排序

 

#include <stdio.h>
#include "sort.h"

int main()
{
    struct recordnode sort_array[]={{49},{38},{65},{97},{76},{13},{27},{49}};
    Psortobject psb = create_sortobject(sort_array, 8);

    struct recordnode rec[] = {{1},{3},{5},{2},{4},{6},{7}};
    struct recordnode merge_rec[7];

    merger(rec, merge_rec, 0, 2, 6);

    for(int i = 0; i < 7; i++)
        printf("%d ", merge_rec[i]);
    //insert_sort(psb);
    //shell_sort(psb, psb->n / 2);

    //select_sort(psb);
    //bubble_sort(psb);

    //quick_sort(psb, 0, 7);

   // for(int i = 0; i < psb->n; i++)
    //    printf("%d ", psb->record[i].key);

    return 0;
}

 

 

 

#include <stdlib.h>
#include "sort.h"

Psortobject create_sortobject(struct recordnode* sample, int m)
{
    Psortobject psort = (Psortobject)malloc(sizeof(struct sortobject));
    psort->n = m;
    psort->record = (struct recordnode*)malloc(
        sizeof(struct recordnode) * m);
    for(int i = 0; i < m; i++)
        psort->record[i] = sample[i];

    return psort;
}

void insert_sort(Psortobject pvector)
{
   struct recordnode temp;
   struct recordnode* data = pvector->record;

   for(int i = 1; i < pvector->n; i++){
        temp = data[i];
        int j;
        for(j = i - 1; temp.key < data[j].key && j >= 0; j--)
            data[j+1] = data[j];
        if(j != i -1)
            data[j+1] = temp;
   }
}

void shell_sort(Psortobject pvector, int d)
{
   struct recordnode temp;
   struct recordnode* data = pvector->record;

   for(int inc = d; inc > 0; inc /= 2){
        for(int i = inc; i < pvector->n; i++){
            temp = data[i];
            int j;
            for(j = i - inc; temp.key < data[j].key && j >= 0; j-=inc)
                data[j+inc] = data[j];
            //if(j != i -1)
            data[j+inc] = temp;
        }
   }
}

void select_sort(Psortobject pvector)
{
    struct recordnode temp;
    struct recordnode* data = pvector->record;

    for(int i = 0; i < pvector->n-1; i++){
        int k = i;
        for(int j = i + 1; j < pvector->n; j++)
            if(data[j].key < data[k].key)
                k = j;
        if(k != i){
            temp = data[i];
            data[i] = data[k];
            data[k] = temp;
        }
    }
}
void bubble_sort(Psortobject pvector)
{
    struct recordnode temp;
    struct recordnode* data = pvector->record;

    for(int i = 0; i < pvector->n-1; i++){
        BOOL noswap = TRUE;
        for (int j = 0; j < pvector->n-i-1; j++)
            if (data[j+1].key < data[j].key){
                temp = data[j];
                data[j] = data[j+1];
                data[j+1] = temp;
                noswap = FALSE;
            }
        if(noswap)
            break;
    }
}

void quick_sort(Psortobject pvector, int l, int r)
{
    int i = l;
    int j = r;

    struct recordnode* data = pvector->record;
    struct recordnode temp = data[i];

    if(l >= r)
        return;

    while(i != j){
        while(i<j && data[j].key >= temp.key)
            j--;
        if(i < j)
            data[i++] = data[j];

        while(i<j && data[i].key <= temp.key)
            i++;
        if(i < j)
            data[j--] = data[i];
    }
    data[i] = temp;

    quick_sort(pvector, l, i-1);
    quick_sort(pvector, i+1, r);
}

void merger(struct recordnode* r, struct recordnode* r1, int low, int mid, int high)
{
    int i = low;
    int j = mid + 1;
    int k = low;

    while(i <= mid && j <= high)
        if(r[i].key <= r[j].key)
            r1[k++] = r[i++];
        else
            r1[k++] = r[j++];

    while(i <= mid)
        r1[k++] = r[i++];

    while(j <= high)
        r1[k++] = r[j++];
}

 

 

、

#ifndef SORT_SORT_H
#define SORT_SORT_H

struct recordnode
{
    int key;
    int info;
};
struct sortobject
{
    int n;
    struct recordnode* record;
};
typedef struct sortobject* Psortobject;

typedef enum {FALSE, TRUE} BOOL;

Psortobject create_sortobject(struct recordnode* sample, int m);
void insert_sort(Psortobject pvector);
void shell_sort(Psortobject pvector, int d);
void select_sort(Psortobject pvector);
void bubble_sort(Psortobject pvector);

void quick_sort(Psortobject pvector, int l, int r);

void merger(struct recordnode* r, struct recordnode* r1, int low, int mid, int high);

#endif //SORT_SORT_H