C++ 设计算法实现双向起泡排序。

题目：

设计算法实现双向起泡排序。

实现代码：

源文件代码：

#include<iostream>
#include<cstdio>
#include<malloc.h>
#include<cstdlib>
#include"Recsort.h"
#include<ctime>

using namespace std;

void insert_sort(RecType r[], int n) {
	int i, j;
	RecType tmp;
	for (i = 1; i < n; ++i) {
		if (r[i].key < r[i - 1].key) {		
			tmp = r[i];
			j = i - 1;
			do {
				r[j + 1] = r[j];
				j--;
			} while (j >= 0 && r[j].key > tmp.key);
			r[j + 1] = tmp;
		}
	}
}

void binary_insert_sort(RecType r[], int n) {
	int i, low, high, mid, j;
	RecType tmp;
	for (i = 1; i < n; ++i) {
		if (r[i].key < r[i - 1].key) {		
			tmp = r[i];
			low = 0, high = i - 1;
			while (low <= high) {
				mid = (low + high) / 2;
				if (tmp.key < r[mid].key)
					high = mid - 1;
				else
					low = mid + 1;
			}
			for (j = i - 1; j >= high + 1; j--)
				r[j + 1] = r[j];
			r[high + 1] = tmp;
		}
	}
}

void shell_sort(RecType r[], int n) {
	int i, j, d;
	RecType tmp;
	d = n / 2;
	while (d > 0) {
		for (i = d; i < n; ++i) {		
			tmp = r[i];
			j = i - d;
			while (j >= 0 && tmp.key < r[j].key)
			{
				r[j + d] = r[j];
				j = j - d;
			}
			r[j + d] = tmp;
		}
		d = d / 2;
	}
}

void bubble_sort(RecType r[], int n) {
	int i, j;
	bool exchange;
	for (i = 0; i < n; ++i) {
		exchange = false;
		for (j = n - 1; j > i; --j)
			if (r[j].key < r[j - 1].key) {
				swap(r[j], r[j - 1]);
				exchange = true;
			}
		if (!exchange)
			return;
	}
}

int partition(RecType r[], int s, int t) {
	int i = s, j = t;
	RecType base = r[i];	
	while (i < j) {		
		while (i < j && r[j].key >= base.key)		
			--j;
		if (i < j) {
			r[i] = r[j];
			++i;
		}
		while (i < j && r[i].key <= base.key)		
			++i;
		if (i < j) {
			r[j] = r[i];
			--j;
		}
	}
	r[i] = base;
	return i;
}

void quick_sort(RecType r[], int s, int t) {
	int i;
	if (s < t) {
		i = partition(r, s, t);
		quick_sort(r, s, i - 1);
		quick_sort(r, i + 1, t);
	}
}

void select_sort(RecType r[], int n) {
	int i, j, k;
	for (i = 0; i < n; ++i) {
		k = i;
		for (j = i + 1; j < n; ++j)
			if (r[j].key < r[k].key)
				k = j;
		if (k != i)
			swap(r[k], r[i]);

	}
}

void sift(RecType r[], int low, int high) {
	int i = low + 1, j = 2 * i;
	RecType tmp = r[i - 1];
	while (j <= high + 1) {
		if (r[j - 1].key < r[j].key && j < high + 1)
			++j;
		if (tmp.key < r[j - 1].key) {
			r[i - 1] = r[j - 1];
			i = j;
			j = 2 * i;
		}
		else
			break;
	}
	r[i - 1] = tmp;
}

void heap_sort(RecType r[], int n) {
	int i;
	for (i = n / 2 - 1; i >= 0; --i)
		sift(r, i, n);
	for (i = n - 1; i >= 1; i--) {
		swap(r[0], r[i]);
		sift(r, 0, i - 1);
	}
}

void merge(RecType r[], int low, int mid, int high) {	
	RecType* r1;
	int i = low, j = mid + 1, k = 0;
	r1 = (RecType*)malloc((high - low + 1) * sizeof(RecType));
	while (i <= mid && j <= high) {		
		if (r[i].key <= r[j].key) {
			r1[k] = r[i];
			++i; ++k;
		}
		else {
			r1[k] = r[j];
			++j; ++k;
		}
	}
	while (i <= mid) {
		r1[k] = r[i];
		++i; ++k;
	}
	while (j <= high) {
		r1[k] = r[j];
		++j; ++k;
	}
	for (k = 0, i = low; i <= high; ++k, ++i)
		r[i] = r1[k];
	free(r1);
}

void merge_pass(RecType r[], int length, int n) {		
	int i;
	for (i = 0; i + 2 * length - 1 < n; i = i + 2 * length)
		merge(r, i, i + length - 1, i + 2 * length - 1);
	
	if (i + length - 1 < n - 1)
		merge(r, i, i + length - 1, n - 1);
}

void merge_sort(RecType r[], int n) {
	int length;
	for (length = 1; length < n; length *= 2) {
		merge_pass(r, length, n);
	}
}


void radix_sort(Nodetype*& p, int r, int d) {
	Nodetype* head[MAX], * tail[MAX], * t = p;
	int i, j, k;
	for (i = 0; i < d; ++i) {
		for (j = 0; j < r; ++j)		
			head[j] = tail[j] = NULL;
		while (p != NULL) {			
			k = p->data[i] - '0';
			if (head[k] == NULL) {
				head[k] = p;
				tail[k] = p;
			}
			else {
				tail[k]->next = p;	
				tail[k] = p;
			}
			p = p->next;
		}
		p = NULL;
		for (j = 0; j < r; ++j) {
			if (head[j] != NULL) {
				if (p == NULL) {		
					p = head[j];
					t = tail[j];
				}
				else {
					t->next = head[j];
					t = tail[j];
				}
			}
		}
		t->next = NULL;
	}
}

头文件代码：
 

#pragma once
#ifndef RECSORT_H

#include"student.h"
typedef char InfoType;
typedef float KeyType;
#define MAX 500
typedef struct
{
	KeyType key;
	int num;
	char name[MAX1];
	int math_grade;
	int linear_algebra_garde;
	int english_grade;
	int physical_grade;
}RecType;

typedef struct node
{
	char data[MAX];
	struct node* next;
}Nodetype;

void insert_sort(RecType r[], int n);

void binary_insert_sort(RecType r[], int n);

void shell_sort(RecType r[], int n);

void bubble_sort(RecType r[], int n);

void quick_sort(RecType r[], int s, int t);

void select_sort(RecType r[], int n);

void heap_sort(RecType r[], int n);

void merge_sort(RecType r[], int n);
#endif