排序与查找习题

一.对一个数组用堆排的方法排序

#include <iostream>
using namespace std;
const int maxn = 4e3 + 7;
int str[maxn];
void HeapAdjust(int a[], int l, int r)
{
    int rc, j;
    rc = a[l];
    for(j = 2 * l; j <= r; j *= 2)
    {
        if((j < r) && (a[j] < a[j + 1])) ++j;
        if(!(rc <= a[j])) break;
        a[l] = a[j]; l = j;
    }
    a[l] = rc;
}

void HeapSort(int a[], int n)
{
    int i, t;
    for(i = n/2; i > 0; --i)
        HeapAdjust(a,i,n);
    for(i = n; i > 1; --i)
    {
        t = a[1]; a[1] = a[i]; a[i] = t;
        HeapAdjust(a, 1, i-1);
    }
}

int main()
{
    int n;
    cin>>n;
    for(int i = 1; i <= n; i++) cin>>str[i];
    HeapSort(str,n);
    for(int i = 1; i <= n; i++) cout<<str[i]<<" ";
    return 0;
}

二.链表实现插入排序

#define int KeyType  //定义 KeyType 为 int 型 
typedef struct node
{
    KeyType key;     //关键字域
    OtherInfoType info;   //其他信息域
    struct node *next;   //链表中的指针域
}RecNode;     //记录节点类型
typedef RecNode *LinkList;   //单链表用 LinkList表示
void InsertSort(LinkList head)  //链式存储结构的直接插入排序算法，head 是带头节点的单链表
{
    RecNode *p, *q, *s;
    if((head -> next) && (head -> next -> next))  //当表中含有的节点数大于 1
    {
        p = head -> next -> next;  // p 指向第二个节点
        head -> next = NULL;    
        q = head;            //指向插入位置的前趋节点
        while((p) && (q -> next) && (p -> key < q -> next -> key))
            q = q -> next;
        if(p)
        {
            s = p; p = p -> next; //将要插入的节点摘下
            s -> next = q - > next;   //插入合适位置: q 节点后
            q -> next = s;
        }
    }
}

三.设计一个算法，在尽可能少的时间里内重排数组，将所有关键字负值记录放在所有关键字非负值记录之前。O( n ) 的时间复杂度

void Resort(SeqList R)  //重排数组,使负值关键字在前
{
    int i = 1, j = n;   //数组存放在 R[ 1...n ]
    while(i < j)       // i < j 表示尚未扫描完毕
    {
        while(i < j && R[i].key < 0)  //遇到负数继续向后扫描
            i++;
        R[0] = R[i];             // R[0] 辅助空间
        while(i < j && R[i].key > 0)   //遇到正数继续向左扫描
            j--;
        R[i++] = R[j];    //交换两个元素并交换指针
        R[j--] = R[0];
    }
}

四.写双冒泡排序算法。( 排序过程中交替改变扫描方向 )

void BubbleSort(SeqList R)
{
    int i,j,k;
    boolean exchange;   //交换标记
    i= n; j = 1;
    exchange = true;
    while((i > j) && (exchange))
    {
        k = i - 1; exchange = false;
        while(k >= j)    //由下往上扫描
        {
            if(r[k] > r[k+1])
            {
                r[0] = r[k];r[k] = r[k+1]; r[k+1] = r[k];  //交换
                exchange = true;
            } //endif
            k--;
        }
        if(exchange)
        {
            exchange = false;
            j++; k = j + 1;
            while(k <= i)   //由上往下扫描
            {
                if(r[k] < r[k-1])  
                {
                    r[0] = r[k]; r[k] = r[k-1];r[k-1] = r[k];  //交换
                    exchange = true;
                }
                k++;
            }
            i--;
        }
    }
}

五.将两个递增的有序的单链表合并成一个递增有序的单链表。( 算法应利用原有的链表节点空间 )

#define KeyType int //定义 KeyType 为 int 型
#define OtherInfoType string
typedef struct node
{
    KeyType key;     //关键字域
    OtherInfoType info;   //其他信息域
    struct node *next;   //链表中的指针域
}RecNode;     //记录节点类型
typedef RecNode *LinkList;   //单链表用 LinkList表示
void Mergesort(LinkList la, LinkList lb, LinkList lc)  //链式存储结构的直接插入排序算法，head 是带头节点的单链表
{
    RecNode *p, *q, *s, *r;
    lc = la;
    p = la;
    q = lb -> next;
    while((p -> next) && (q))
        if(p -> next -> key <= q -> key)
            p = p -> next;
        else
        {
            s = q; q = q -> next;
            s -> next = p -> next; p -> next = s;
            p = s;
        }
        if(!p->next) p ->next = q;
        free(lb);
}

六.设数组A[0...n-1]中的 n 个互不相同的整数，且每个元素的值均在 0 到 n - 1 之间，写一个时间复杂度为O( n )的算法对数组 A 中的

元素进行排序，结果可以输出到另一个数组 B[0...n-1]中。

void Sort(int a[],int b[])
{
    int i;
    for(i = 0; i < n; i++)
        b[a[i]] = a[i];
}