c++面向对象的程序设计第四版第九章课后作业程序

9-1
array.h

先是头文件

#pragma once
#ifndef ARRAY_H_
#define ARRAY_H_
#include <cassert>

template <class T>
class Array {
private:
	T* list;
	int size;
public:
	Array(int sz = 50);
	Array(const Array<T>& a);
	~Array();
	Array<T>& operator = (const Array<T>& rhs);//返回自己而不是自己的拷贝 所以这里要加&
	T& operator[] (int i);
	const T& operator[] (int i) const;
	operator T* ();
	operator const T* () const;
	int getSize() const;
	void resize(int sz);
};

template <class T>
Array<T>::Array(int sz) {
	assert(sz > 0);
	size = sz;
	list = new T[size];
}

template <class T>
Array<T>::~Array() {
	delete[] list;
}

template <class T>
Array<T>::Array(const Array<T> &a) {
	size = a.size;
	list = new T[size];
	for (int i = 0; i < size; i++)
		list[i] = a.list[i];
}

template <class T>
Array<T>& Array<T>::operator =(const Array<T> &rhs) {
	if (&rhs != this) {
		if (size != rhs.size) {
			delete[]list;
			size = rhs.size;
			list = new T[size];
		}
		for (int i = 0; i < size; i++)
			list[i] = rhs.list[i];
	}
	return *this;
}

template <class T>
T& Array<T>::operator [](int i) {
	assert(i >= 0 && i < size);
	return list[i];
}

template <class T>
const T& Array<T>::operator [](int i) const {
	assert(i >= 0 && i < size);
	return list[i];
}

template <class T>
Array<T>::operator T *() {
	return list;
}

template <class T>
Array<T>::operator const T *() const {
	return list;
}

template <class T>
int Array<T>::getSize() const {
	return size;
}

template <class T>
void Array<T>::resize(int sz) {
	assert(sz >= 0);
	if (sz == size)
		return;
	T* newList = new T[sz];
	int n = (sz < size) ? sz : size;
	for (int i = 0; i < n; i++)
		newList[i] = list[i];
	delete[]list;
	list = newList;
	size = sz;
}

#endif  //ARRAY_H_

限免的

#include <iostream>
#include "array.h"
using namespace std;

//面向对象的程序设计第九章课后习题
//9-1


int main()
{
	int n;
	double average,total = 0;
	cout << "请输入学生人数：";
	cin >> n;
	Array<float>  score(n);
	for (int i=0; i<n; i++)
	{
		cout << "请输入第" << i+1 <<"个学生的课程A成绩(0~100)：";
		cin >> score[i];
		total += score[i];
	}
	average = total/n;
	cout << "平均成绩为" <<  average << endl;
	//setprecision(4) 设置输出流显示浮点数的个数
	return 0;
}

}

9-4

//dnode.h
#ifndef DOUBLY_LINKED_NODE_CLASS
#define DOUBLY_LINKED_NODE_CLASS

template <class T>
class DNode
{
    private:
		// circular links to the left and right
        DNode<T> *left;  //左指针
        DNode<T> *right;  //右指针
    public: 
		T data;  //结点数据
        
		// 构造函数
        DNode(void); 
        DNode (const T& item);
        
        
        // 链表修改算法
        void insertRight(DNode<T> *p);
        void insertLeft(DNode<T> *p);
        DNode<T> *deleteNode(void);
        
        
        // 获取左侧和右侧相邻结点的地址
        DNode<T> *nextNodeRight(void) const;
        DNode<T> *nextNodeLeft(void) const;
};

// 构造函数创建一个空结点，不初始化数据成员，用于链表头结点
template <class T>
DNode<T>::DNode(void)
{
	// 初始化结点，使之指向自身
    left = right = this;
}

// 构造函数，创建一个空结点并初始化数据成员
template <class T>
DNode<T>::DNode(const T& item)
{
	// 使结点指针指向自身并初始化数据成员
    left = right = this;
    data = item;
}

// 在当前结点的右侧插入一个结点p
template <class T>
void DNode<T>::insertRight(DNode<T> *p)
{
	// 将p与右结点连接
    p->right = right;
	right->left = p;
	
	// 将当前结点连接到p结点的左侧
    p->left = this;
    right = p;
}

//在当前结点的左侧插入一个结点p
template <class T>
void DNode<T>::insertLeft(DNode<T> *p)
{
	// 将p与左结点连接
    p->left = left;
    left->right = p;
    
	//将当前结点连接到p结点的右侧
    p->right = this;
    left = p;
}

// 断开当前结点与链表的连接，并返回当前结点地址
template <class T>
DNode<T> *DNode<T>::deleteNode(void)
{
	// 使当前结点的左侧结点连接到当前结点的右侧结点
    left->right = right;
    
	// 使当前结点的右侧结点连接到当前结点的左侧结点
    right->left = left;
    
    // 返回当前结点地址
    return this;
}

// 返回指向右结点的指针
template <class T>
DNode<T> *DNode<T>::nextNodeRight(void) const
{
    return right;
}

// 返回指向左结点的指针
template <class T>
DNode<T> *DNode<T>::nextNodeLeft(void) const
{
    return left;
}

#endif	// DOUBLY_LINKED_NODE_CLASS

9-10

#include <iostream>
using namespace std;


template <class T>
void insertSort(T A[], int n)
{
	int i, j;
	T   temp;
	
	// 将下标为1～n-1的元素逐个插入到已排序序列中适当的位置
	for (i = 1; i < n; i++) 
	{
		//从A[i-1]开始向A[0]方向扫描各元素,寻找适当位置插入A[i]
		j = i;
		temp = A[i];
		while (j > 0 && temp < A[j-1]) 
		{   //逐个比较，直到temp>=A[j-1]时，j便是应插入的位置。
			//若达到j==0，则0是应插入的位置。
			A[j] = A[j-1];                    //将元素逐个后移，以便找到插入位置时可立即插入。
			j--;
		}
		// 插入位置已找到，立即插入。
		A[j] = temp;
		
		//输出数据
		for(int k=0;k<n;k++)
			cout << A[k] << "  ";
		cout << endl;
		//结束输出	
	}
}

int main()
{
	int i;
	
	int data1[]={1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20};
	cout << "排序前的数据：" << endl;
	for(i=0;i<20;i++)
		cout << data1[i] << "  ";
	cout << endl;
	cout << "开始排序..." << endl;
	insertSort(data1, 20);
	cout << "排序后的数据：" << endl;
	for(i=0;i<20;i++)
		cout << data1[i] << "  ";
	cout << endl;
	return 0;
}

9-12

#include <iostream>
using namespace std;

// 辅助函数：交换x和y的值
template <class T>
void swapData(T &x, T &y)
{
	T temp;
	
	temp = x;
	x = y;
	y = temp;
}

// 用选择法对数组A的n个元素进行排序
template <class T>
void selectSort(T a[], int n)
{
	int smallIndex;    //每以趟中选出的最小元素之下标
	int i, j;
	
	// sort a[0]..a[n-2], and a[n-1] is in place
	for (i = 0; i < n-1; i++) 
	{
		smallIndex = i;    //最小元素之下标初值设为i
		// 在元素a[i+1]..a[n-1]中逐个比较显出最小值
		for (j = i+1; j < n; j++) 
			// smallIndex始终记录当前找到的最小值的下标
			if (a[j] < a[smallIndex])
				smallIndex = j;
			// 将这一趟找到的最小元素与a[i]交换
			swapData(a[i], a[smallIndex]);
			//输出数据
			for(int k=0;k<n;k++)
				cout << a[k] << "  ";
			cout << endl;
			//结束输出	
			
	}
}

int main()
{
	int i;
	
	int data1[]={1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20};
	cout << "排序前的数据：" << endl;
	for(i=0;i<20;i++)
		cout << data1[i] << "  ";
	cout << endl;
	cout << "开始排序..." << endl;
	selectSort(data1, 20);
	cout << "排序后的数据：" << endl;
	for(i=0;i<20;i++)
		cout << data1[i] << "  ";
	cout << endl;
	return 0;
}