严蔚敏数据结构习题10.30

这个快排的话，说实话，之前一直写的都是递归形式的快排，对待非递归的快排，也就是自己要维护一个栈，所以觉得挺有意义的，单开一个博文，记录一下。

先把我之前的递归形式的快排放上来,当然这个也是做了优化的快排，并没有每一次都把轴心元素和找到的元素交换，而是先通过low和high所指的元素之间的相互赋值，从而找到轴心元素应该所在的位置，从而直接一个赋值即可。

具体的步骤如下：

这里的话，将a[low]看作轴心元素,先用一个临时变量tmp保存数组a[low]的值，然后，从high侧开始比较，如果比tmp大，就移动high的指针，如果小的话，直接将这个值赋给low指针所指的值，low指针所指的第一个值是咱们的轴心元素，所以不用担心值的覆盖问题的。同样，low那边的元素也是同样的道理。代码如下：

#include<stdio.h>

//先写一个递归的快排算法

void printArray(int a[],int n);


int partition(int arr[],int low,int high)
{
	printf("%d %d\n", low,high);
	int aim;
	aim = arr[low];

	while(low < high)
	{
		while(low < high && arr[high] >= aim) --high; //先从high开始
		//直到while不满足循环的时候，即存在一个比中间值小的数，此时赋值过来，这里不用交换
		arr[low] = arr[high];	

		while(low < high && arr[low] <= aim) ++low;
		arr[high] = arr[low];

	}


	arr[low] = aim;

	return low;

}

void QSort(int arr[],int low,int high)
{
	if(low < high)
	{
		int middle;
		middle = partition(arr,low,high);
		printf("middle = %d\n",middle );
		QSort(arr,low,middle - 1);
		QSort(arr,middle + 1,high);
	}


}

void quicksort_firstq(int arr[],int n)
{
	QSort(arr,0,n-1);

}





void printArray(int a[],int n)
{
	int i;
	for(i = 0;i < n ; i++)
	{
		printf("%d ",a[i]);

	}

	printf("\n");

}


int main(int argc, char const *argv[])
{
	int a[8]={8,3,6,2,9,5,1,4};
	quicksort_firstq(a,8);

	printArray(a,8);
	
	return 0;
}

但是这道题目确是要求用非递归的方法，有点意思哦～
题目如下：

(1)

#include<stdio.h>

#define FALSE 0
#define TRUE 1


typedef struct 
{
	int low;
	int high;
	
}SNode;

int partition(int arr[],int low,int high)
{
	int aim;
	aim = arr[low];

	while(low < high)
	{
		while(low < high && arr[high] >= aim) --high; //先从high开始
		//直到while不满足循环的时候，即存在一个比中间值小的数，此时赋值过来，这里不用交换
		arr[low] = arr[high];	

		while(low < high && arr[low] <= aim) ++low;
		arr[high] = arr[low];

	}

	arr[low] = aim;

	return low;

}


void quicksort1(int arr[],int low,int high)
{
	int tag; //判断序列是否有序
	int position;   //轴心元素应该处的位置
	int lnum,rnum;  //左右子序列中元素的个数
	int count;      //栈中元素的个数
	SNode Stack[100]; //栈 0位置不用


	tag = TRUE;
	count = 0;

	while(tag)
	{
		position = partition(arr,low,high);
		if(position == low) //这里要判断是否是一个元素，如果是一个元素则有序，否则就需要进一步排序
		{
			if( (high-low) == 0)
				tag = FALSE;
			else
				low = low + 1;
		}
		if(tag)
		{
			lnum = position - low;
			rnum = high - position;

			if( lnum > 1 || rnum > 1)
			{
				count++;  

				if(lnum <= rnum) //左边的少，则先排左边的，将右边的上下界入栈
				{
					Stack[count].low = position+1;
					Stack[count].high = high;
					high = position - 1;  
				}

				else
				{
					Stack[count].low = low;
					Stack[count].high = position - 1;
					low = position + 1; //先排右边的
				}

			}//if( lnum > 1 || rnum > 1)
		}//if(tag)


		if(!tag || (lnum <= 1 && rnum <= 1))  //已经有序的时候
		{
			if(count)
			{
				low = Stack[count].low;  //将栈中保存的上下界弹出
				high = Stack[count].high;
				count --;  //出栈
				tag = TRUE;  //设定此时栈中无序
			}//if
		}//if

	}//while


}


void quicksort_1(int arr[],int n)
{
	quicksort1(arr,0,n-1);
}

void printArray(int a[],int n)
{
	int i;
	for(i = 0;i < n ; i++)
	{
		printf("%d ",a[i]);

	}

	printf("\n");

}


int main(int argc, char const *argv[])
{
	int a[8]={7,3,6,2,9,5,1,4};
	quicksort_1(a,8);

	printArray(a,8);
	
	return 0;
}

(2)

第二问，我们在排序之前先进行元素个数的检查

#include<stdio.h>

#define FALSE 0
#define TRUE 1

void printArray(int a[],int n);

//这样写并没有让记录小于3时用比较排序


typedef struct 
{
	int low;
	int high;
	
}SNode;

void swap(int *i,int *j)
{
	int p;
	p = *i;
	*i = *j;
	*j = p;
}

int partition(int arr[],int low,int high)
{
	int aim;
	aim = arr[low];

	while(low < high)
	{
		while(low < high && arr[high] >= aim) --high; //先从high开始
		//直到while不满足循环的时候，即存在一个比中间值小的数，此时赋值过来，这里不用交换
		arr[low] = arr[high];	

		while(low < high && arr[low] <= aim) ++low;
		arr[high] = arr[low];

	}

	arr[low] = aim;

	return low;

}


//这里我理解为冒泡排序吧
void compareSort(int arr[],int low,int high)
{
	int remark;
	int num = high - low + 1;
	do
	{
		remark = FALSE;
		for(int i = low; i < num - 1 ; i++)
		{

			if( arr[i] > arr[i+1] )
			{
				swap( &arr[i] , &arr[i+1] );
				remark = TRUE;

			}
		}

		num -- ;

	}while(remark);

}

void __quicksort2(int arr[],int low,int high)
{
	int tag = TRUE;  //判断序列是否有序
	SNode Stack[100];
	int lnum,rnum;
	int position;
	int i,j;
	int count = 0; //记录栈中元素,要初始一下元素

	while(1)//这里不是tag了
	{
		//先判断待排记录
		if(high - low + 1 <= 3)
		{
			compareSort(arr,low,high);
			//先判断栈里是否有元素，有就弹出
			if(count)
			{
				low = Stack[count].low;
				high = Stack[count].high;
				count --;
			}
			else
				break;
		}
		else
		{
			position = partition(arr,low,high);
			lnum = position - low;
			rnum = high - position;

			count++;

			if( lnum <= rnum ) //左边的元素少，右边入栈
			{
				Stack[count].low = position + 1;
				Stack[count].high = high;
				high = position - 1;
			}
			else
			{
				Stack[count].low = low;
				Stack[count].high = position - 1;
				low = position + 1;
			}


		}
	}
}

		

void quicksort2(int arr[],int n)
{
	__quicksort2(arr,0,n-1);

}
void printArray(int a[],int n)
{
	int i;
	for(i = 0;i < n ; i++)
	{
		printf("%d ",a[i]);

	}

	printf("\n");

}


int main(int argc, char const *argv[])
{
	int a[8]={7,3,6,2,9,5,1,4};
	quicksort2(a,8);

	printArray(a,8);
	
	return 0;
}