数据结构、算法与应用答案第五章21-30

22：

	 void reverse(){
		 for (i = 0; i != listSize / 2; ++i) {
			 T p = element[i];
			 element[i] = element[listSize - i - 1];
			 element[listSize - i - 1] = p;
		 }
	 }

2）复杂度因为只有一个循环，因此是O（listSize）

23：

	 //线性表左移i个位置
	 void leftShift(int i) {
		 if (i > listSize) {
			 ostringstream s;
			 s << "listSize=" << listSize << "I=" << i;
			 cout << s.str();
		 }
		 copy(element + i, element + listSize, element);
		 listSize = listSize - i;
		 element[listSize].~T();
	}

24：

	 //循环移动按照顺时针方向。
	 void circularShift(int i){
		 T* temp = new T[arrayLength];
		 copy(element + i, element + listSize, temp);
		 copy(element, element + i, temp + listSize - i);
		 delete []element;
		 element = temp;
	 }

25：

	 //隔一个删除一个元素
	 void half() {
		 T* temp = new T[arrayLength];
		 for (int i = 0; i !=listSize / 2+1; ++i) {
			 temp[i] = element[2*i];
		 }
		 delete []element;
		 element = temp;
		 listSize = listSize / 2;
	 }

2）因为代码的循环次数只跟listSize有关，所以他的复杂度是O（listSize）

26:

实现上并没有多大差别，只是把temp改成了insert，把【】改成了get

27：加上以下功能

		iterator& operator +(int i) const {
			return *position + i;
		}
		iterator& operator -(int i) const {
			return *position - i;
		}
		iterator& operator +=(int i) const {
			position + i;
			return *this;
		}
		iterator& operator -=(int i) const {
			position - i;
			return *this;
		}
		iterator& operator -(iterator right) const {
			int i,j;
			i = position - element;
			j = right.position - element;
			return i - j;
		}

		T& operator*() const { return *position; }
		T* operator->() const { return &*position; }

28：

	//求两个线性表按照一定规律的排列
	arraylist<T> meld(arraylist<T> a, arraylist<T> b) {
		listSize = a.listSize + b.listSize;
		if (a.listSize > b.listSize) {
			int i = b.listSize;
			int j;
			for (j = 0; j != i * 2; ++j) {
				if (j % 2 == 0) {
					element[j] = a[j / 2];
				}
				element[j] = b[j / 2];
			}
			copy(a.element + i, a.element + a.listSize, element + j);
		}
		else {
			int i = a.listSize;
			int j;
			for (j = 0; j != i * 2; ++j) {			
				if (j % 2 == 0) {
					element[j] = a[j/2];
				}
				else {
					element[j] = b[j/2];
				}
			}
			copy(b.element + i, b.element + b.listSize, element + j);
		}
		return *this;
	}

因为是首先先需要进行二倍min（a.listSize,b.listSize）次移动，然后再用COPY函数进行MAX-min次移动，所以是MAX+MIN次移动，因此复杂度位O（max+min）

29：

//求两个非递减有序的线性表的集合
	arraylist<T> merge(arraylist<T> a, arraylist<T> b) {
		int i, j=0;
		listSize = 0;
		for ( i = 0; i != a.listSize; ++i) {
			for ( ; j != b.listSize; ++j) {
				if (b.element[j] > a.element[i]) {
					element[i + j] = a.element[i];
					listSize++;
					break;
				}
				element[i + j] = b.element[j];
				listSize++;
			}
		}
		if (j == b.listSize) {
			copy(a.element + listSize - j, a.element + i + j, element + listSize);
		}
		else {
			copy(b.element + listSize - i, b.element + a.listSize + b.listSize, element + listSize);
		}
		listSize = a.listSize + b.listSize;
		return *this;
	}

复杂度为O(a.listSize*b.listSize)

30:

	void split(arraylist<T>& a, arraylist<T>& b) {
		for (int i = 0; i != listSize; ++i) {
			if (i % 2 == 0) {
				a.element[i / 2] = element[i];
			}
			else {
				b.element[i / 2] = element[i];
			}
		}
		b.listSize = listSize / 2;
		if (listSize % 2 == 0) {
			a.listSize = listSize / 2;
		}
		else
			a.listSize = listSize / 2 +1;
	}

复杂度显然为O(listSize)