基础数据结构算法总结

对本科使用的数据结构课本感情很深, 当初学的时候, 并不需要上机编程, 考试时只需写出伪代码即可. 而今, 实现的细节已经变得必须了, 所以, 再次拿出课本, 复习一下实现细节

 

数据结构和算法

1. 堆的实现(插入, 删除, 初始化, 以最大根为例) 

2. 快排的实现

3. 归并排序的实现

4. 数组实现队列

 

1. 堆的实现, 代码

template <class T>
class MaxHeap {
public:
	MaxHeap(int MaxHeapSize = 10);
	~MaxHeap(delete [] heap);

	int Size() const {
		return CurrentSize;
	}

	T Max() const {
		if(CurrentSize == 0)
			return OutOfBounds();
		return heap[1];
	}

	MaxHeap<T>& Insert(const T &x);
	MaxHeap<T>& Delete(T &x);

	void Initialize(T a[], int size, int ArraySize);

private:
	int CurrentSize, MaxSize;
	T *heap;
};

template <class T>
MaxHeap<T>::MaxHeap(int MaxHeapSize) {
	MaxSize = MaxHeapSize;
	CurrentSize = 0;
	heap = new T[MaxHeapSize+1];
}

template <class T>
MaxHeap<T>& MaxHeap<T>::Insert(const T &x) {
	if(CurrentSize == MaxSize) throw NoMem();

	int i = ++ CurrentSize;

	while(i != 1 && x > heap[i/2]) {
		heap[i] = heap[i/2];
		i /= 2;
	}

	heap[i] = x;
	return *this;
}

template <class T>
MaxHeap<T>& MaxHeap::Delete(T &x) {
	if(CurrentSize == 0) return OutOfBounds();

	x = heap[1];

	T y = heap[CurrentSize--];

	int i = 1, ci = 2*i;

	while(ci <= CurrentSize) {
		if(ci < CurrentSize && heap[ci] < heap[ci+1])
			ci ++;

		if(y >= heap[ci]) break;

		heap[i] = heap[ci];

		i = ci;
		ci *= 2;
	}
	heap[i] = y;

	return *this;
}

template <class  T>
void MaxHeap<T>::Initialize(T a[], int size, int ArraySize) {
	delete [] heap;
	heap = a;
	CurrentSize = size;
	MaxSize = ArraySize;

	for(int i = CurrentSize/2; i >= 1; i --)  {
		T y = heap[i];

		int c= 2 * i;

		while(c <= CurrentSize) {
			if(c < CurrentSize && heap[c] < heap[c+1])
				c ++;
			if(y >= heap[c]) break;

			heap[c/2] = heap[c];
			c *= 2;
		}
		heap[c/2] = y;
	}
}

　　

2. 快排的实现

template <class T>
void QuickSort(T *a, int n)  {
	quickSort(a, 0, n-1);
}

template <class T> 
void quickSort(T *a, int l, int r)  {
	if(l >= r) return;

	int i = l; j = r+1;
	T pivot = a[i];

	// it should be aware that replace T[i] < pivot to T[i] <= pivot
	// the correctness of program can be remained

	while(true)  {
		do  {
			i = i + 1;
		}  while(T[i] < pivot);
		
		do  {
			j = j - 1;
		}  while(T[j] > pivot);

		if(i >= j) break;

		swap(T[i], T[j]);
	}

	a[l] = a[j];
	a[j] = pivot;

	quickSort(T, l, j-1);
	quickSort(T, j+1, r);
}

　　

3. 归并排序

template <class T>
void MergeSort(T a[], int n)  {
	T *b = new T[n];

	int seg = 1; // the size of segment
	while(seg < n)  {
		MergePass(a, b, seg, n);
		seg ++;
		MergePass(b, a, seg, n);
	}
	delete []b;
}

template <class T>
void MergePass(T a[], T b[], int seg, int n)  {
	int i = 0;

	while(i < n - 2*seg)  {
		Merge(a, b, i, i+seg-1, i+2*seg-1);
		i += 2*seg;
	}

	if(i < n - seg)  {
		Merge(a, b, i+seg-1, n-1);
	}  else  {
		for(int j = i; j <= n-1; j ++)
			b[j] = a[j];
	}
}

template <class T>
void Merge(T a[], T b[], int l, int m, int r)  {
	int i = l, j = m+1, k = l;

	while(i <= m && j <= r)  {
		if(a[i] < b[j])  {
			b[l++] = a[i++];
		}  else  {
			b[l++] = b[j++];
		}
	}

	while(i < m)  {
		b[l++] = a[i++];
	}
	while(j < m)  {
		b[l++] = b[j++];
	}
}

　　

4. 数组实现队列

template <class T>
class Queue {
public:
	Queue(int MaxQueueSize = 10);
	~Queue() {
		delete []queue;
	}

	bool IsEmpty() const {
		return (front == rear);
	}
	bool IsFull() const {
		return (rear+1)%MaxSize == front ? 1:0;
	}

	T First() const;
	T Last() const;

	Queue<T>& Add(const T &x);
	Queue<T>& Delete();

private:
	int front;
	int rear;
	int MaxSize;
	T *queue;
};

template <class T>
Queue<T>::Queue(int MaxQueueSize) {
	MaxSize = MaxQueueSize + 1;
	queue = new T[MaxSize];
	front = rear = 0;
}

template <class T>
T Queue<T>::First() const {
	if(IsEmpty()) throw OutOfBounds();
	return queue[(front+1)%MaxSize];
}
template <class T>
T Queue<T>::Last() const {
	IsFull(IsEmpty()) throw OutOfBounds();
	return queue[rear];
}

template<class T>
Queue<T>& Queue::Add(const T &x) {
	if(IsFull()) throw NoMem();
	rear = (rear+1) % MaxSize;
	queue[rear] = x;
	return *this;
}
template <class T>
Queue<T>& Queue::Delete() {
	if(IsEmpty()) throw OutOfBounds();
	front = (front+1) % MaxSize;
	x = queue[front];
	return *this;
}