数据结构实验4

（一）题目
1. 按下述原则编写快排的非递归算法：
(1) 一趟排序之后，若子序列已有序(无交换)，则不参加排序，否则先对长度较短的子序列进行排序，且将另一子序列的上、下界入栈保存；
(2) 若待排记录数<=3，则不再进行分割，而是直接进行比较排序。

测试实例：{49 38 65 97 76 13 27 49 88 21 105}
（二）算法思路
(1) 建立存储序列上下界的栈序列。

(2) 对栈顶作如下判断：
A. 若栈顶中记录的头与尾相距小于3，对对应的子序列进行排序，然后出栈，进入(3)；
B. 若栈顶中记录的头与尾相距大于等于3，则进行分块，判断分块是否有序，
a.若两分块都有序，则出栈，进入(3)；
b.若只有一分块有序，则改变栈顶内容为无序分块内容，进入(3)；
c.若两分块都无序，则改变栈顶内容为较长的无序块，然后把较短的无序块
压进栈。

进入(3)
(3)重复(2)的操作，直至栈空，得到最终结果。

（三）程序结构
定义的结构体及声明
（四）源码
using namespace std;
typedef struct _stack{
int left; //lowerbound
int right; //upperbound
struct _stack *next;
}qstack; //to store the child sequence's left and right
void sort(int *arr, int left, int right){ //sort child sequence less than 3
for(int i = left; i <= right; i++){
int k = i;
for(int j = i+1; j <= right; j++){
if(arr[k] > arr[j])
k = j;
}
if(k != i){
int t;
t = arr[k];
arr[k] = arr[i];
arr[i] = t;
}
}
}
bool sorted(int *arr, int left, int right){
for(int i = left; i < right; i++){
if(arr[i] > arr[i+1])
return false;
}
return true;
}
void qsort(int *arr, int left, int right){
qstack *head;
head = new qstack;
head->left = left;
head->right = right;
head->next = NULL;
qstack *p;
while(head != NULL){
if(head->right - head->left < 3){ //if less than 3, sort and pop
sort(arr, head->left, head->right);
p = head;
head = head->next;
delete p;
} else { //generally, separate the sequence int ml = head->left, mr = head->right;
int mm = ml;
int k = arr[mm];
//find the position, the key part of quick sort
while(ml < mr){
if(mm == ml){
if(arr[mr] >= k)
mr--;
else{
arr[mm] = arr[mr];
mm = mr;
}
}
if(mm == mr){
if(arr[ml] > k){
arr[mm] = arr[ml];
mm = ml;
}else
ml++;
}
}
arr[mm] = k;
bool l = sorted(arr, head->left, mm-1);
bool r = sorted(arr, mm+1, head->right);
if(!l && r){
//left child sequence isn't sorted, then change the top
head->right = mm - 1;
}else if(l && !r){
//right child sequence isn't sorted, then change the top
head->left = mm + 1;
}else if(!l && !r){
//both sequences aren't sorted, then change the top one
//to the longer sequence, push the shorter one to the stack
p = new qstack;
if(mm - head->left > head->right - mm){
p->left = mm + 1;
p->right = head->right;
head->right = mm - 1;
}else{
p->left = head->left;
p->right = mm - 1;
head->left = mm + 1;
}
p->next = head;
head = p;
}else {
//both sequences are sorted, then pop
head = head->next;
}
}
}
}
int main(){
int array[MAX_SEQ];
int n;
while(cout << "input the length of the sequence: ", cin >> n){ cout << "input " << n << " numbers\n";
for(int i = 0; i < n; i++)
cin >> array[i];
qsort(array, 0, n-1);
cout << "after quick sorted:\n";
for(int i = 0; i < n; i++)
cout << array[i] << " ";
cout << endl;
}
return 0;
}
（五）实验结果
（六）心得体会
本实验通过对栈的使用，实现了快速排序的非递归算法，加深了对快速排序与递归的理解，更熟悉了栈的操作。

而在实验中犯的大部分错误都在于栈的使用过程中，对于
栈的使用熟练度还需要加强。