Algorithm Review: Sorting

参考资料：http://blog.csdn.net/touch_2011/article/details/6767673

// 选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法，而冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。

#include<iostream>
#include<math.h>
#include<vector>
using namespace::std;

/*
性能分析
容易看出，简单选择排序所需进行记录移动的操作次数较少，这一点上优于冒泡排序，最佳情况下
（待排序序列有序）记录移动次数为0，最坏情况下（待排序序列逆序）记录移动次数n-1。外层循
环进行了n-1趟选择，第i趟选择要进行n-i次比较。每一趟的时间：n-i次的比较时间+移动记录的时
间（为一常数0或1，可以忽略）。总共进行了n-1趟。忽略移动记录的时间，所以总时间为
(n-1)*(n-i)=n^2-(i+1)*n+i。时间复杂度为O（n^2）。不管是最坏还是最佳情况下，比较次数都是
一样的，所以简单选择排序平均时间、最坏情况、最佳情况 时间复杂度都为O（n^2）。同时简单选
择排序是一种稳定的原地排序算法。当然稳定性还是要看具体的代码，在此就不做深究。          
*/
void selectionSort(int input[], int n)
{
	int index = 0;
	for(int i = 0; i < n - 1; i++)
	{
		index = i;
		for(int j = i + 1; j < n; j++)
		{
			if(input[j] < input[index])
			{
				index = j;
			}
		}
		if(index != i)
		{
			int tmp = input[i];
			input[i] = input[index];
			input[index] = tmp;
		}
	}

}



/*堆排序性能分析
       堆排序时间=建堆时间+调整堆时间。从上文中知道建堆时间复杂度为O（n*log2n）
	   。筛选法调整堆（maxHeap函数）时间O（logn），总共循环了n-1次maxHeap函数，
	   所以调整堆时间复杂度为O（n*logn）。得出堆排序时间复杂度O（n*logn）。
       熟悉了堆排序的过程后，可以发现堆排序不存在最佳情况，待排序序列是有序或
	   者逆序时，并不对应于堆排序的最佳或最坏情况。且在最坏情况下时间复杂度也是
	   O（n*logn）。此外堆排序是不稳定的原地排序算法。
	   */
void maxHeap(int a[], int i, int n)
{
	int left, right, largest, temp;
	left = 2*i + 1;
	right = left + 1;

	largest = left;
	if(left > n-1)
		return;
	if(right <= n-1 && a[right] > a[left])
		largest = right;
	if(a[i] < a[largest])
	{
		temp = a[i];
		a[i] = a[largest];
		a[largest] = temp;
	}

	maxHeap(a, largest, n);
}

void createHeap(int a[], int n)
{
	int index = (n-1)/2;
	for(index; index >= 0 ; index--)
	{
		maxHeap(a, index, n);
	}
}


void heapSort(int a[], int n)
{
	int tmp = 0;
	createHeap(a, n);
	for(int i = n-1; i >= 0 ; i--)
	{
	cout<<endl;
		tmp = a[i];
		a[i] = a[0];
		a[0] = tmp;

		maxHeap(a , 0 , i-1);
	}

}

/*
相对于简单选择排序，冒泡排序交换次数明显更多。它是通过不断地交换把最大的数冒出来。
冒泡排序平均时间和最坏情况下（逆序）时间为o（n^2）。最佳情况下虽然不用交换，但比
较的次数没有减少，时间复杂度仍为o（n^2）。此外冒泡排序是稳定的。

*/
//冒泡排序
void bubbleSort(int *a,int n)
{
<span style="white-space:pre">	</span>int i,j;
<span style="white-space:pre">	</span>for(i=0;i<n;i++)
<span style="white-space:pre">		</span>for(j=0;j<n-i-1;j++){
<span style="white-space:pre">			</span>if(a[j+1]<a[j]){
<span style="white-space:pre">				</span>a[j]=a[j]+a[j+1];
<span style="white-space:pre">				</span>a[j+1]=a[j]-a[j+1];
<span style="white-space:pre">				</span>a[j]=a[j]-a[j+1];
<span style="white-space:pre">			</span>}
<span style="white-space:pre">		</span>}
}

/*
可以说合并排序是比较复杂的排序，特别是对于不了解分治法基本思想的同学来说可能难以理解。
总时间=分解时间+解决问题时间+合并时间。分解时间就是把一个待排序序列分解成两序列，时
间为一常数，时间复杂度o(1).解决问题时间是两个递归式，把一个规模为n的问题分成两个规模
分别为n/2的子问题，时间为2T(n/2).合并时间复杂度为o（n）。总时间T(n)=2T(n/2)+o(n).这个
递归式可以用递归树来解，其解是o(nlogn).此外在最坏、最佳、平均情况下归并排序时间复杂度均
为o(nlogn).从合并过程中可以看出合并排序稳定。 用递归树的方法解递归式T(n)=2T(n/2)+o(n):
假设解决最后的子问题用时为常数c，则对于n个待排序记录来说整个问题的规模为cn。

*/

void merge(int* inputArray, int start, int mid, int end)
	{
		
		int* new_array = new int[end - start + 1];
	
		int i = start, j = mid + 1, x = 0;
		//cout<<"size: "<<size<<endl;
		while(i <= mid && j <= end)
		{
			if(inputArray[i] > inputArray[j])
			{
				new_array[x++] = inputArray[j++];
			
			}
			else
			{
				new_array[x++] = inputArray[i++];
				
			}
			
		}
		
		while(i <= mid)
		{
			new_array[x++] = inputArray[i++];

		}
				
		while(j <= end)
		{
			new_array[x++] = inputArray[j++];
		}
			
		for(i = start, x = 0; i <= end; i++, x++)
		{
			inputArray[i] = new_array[x];
		}
	
	}
void mergeSort(int * inputArray, int start, int end)
	{
		if(start < end)
		{
			int mid = ( start + end ) / 2; 
			mergeSort(inputArray, start, mid);
			mergeSort(inputArray, mid + 1, end);
			merge(inputArray, start, mid, end);
		}


	}


/*
   3.3 效率分析
        快速排序时间与划分是否对称有关。快速排序的平均时间复杂度为o（n*logn）
        最坏情况下，每次划分都很不对称T（n）=o（n^2）,此时就是冒泡排序。

*/
void quickSort(int input[], int low, int high)
{
	int key = input[low];
	int i = low, j = high;
	if(i > j)
		return;
	while(i < j)
	{
		while(i < j && input[j] >= key)//这里一定要有等号，否则会死循环
		{
			j--;
		}
		input[i] = input[j];
		while(i < j && input[i] <= key)//这里一定要有等号，否则会死循环
		{
			i++;
		}
		input[j] = input[i];
	}
	input[i] = key;
	quickSort(input, low, i - 1);
	quickSort(input, i + 1, high);

}





/*
容易看出，要插入的记录个数为n-1，其中关键字的比较次数和记录移动次数是依赖于给
出的待排序序列是否基本有序。在最佳情况下（待排序序列有序），比较次数和移动次数
时间为o（1），所以时间复杂度为o（n）.在最坏情况下（待排序序列逆序）和平均时间均
为o（n^2）.从上述分析中可以看出，直接插入排序适合记录数比较少、给定序列基本有序
的情况。熟悉了排序过程我们发现，直接插入排序是一种稳定的原地排序算法。
*/
void insertionSort(int input[], int n)
{
	for(int i=1; i<10; i++)
	{
		int tmp = input[i];
		int j;
		for(j=i-1; j>=0; j--)
		{
			if(tmp < input[j])
			{
				input[j+1] = input[j];
			}
			else
				break;
		}
		input[j+1] = tmp;
	}

}
/*
折半插入排序是对直接插入排序的一种改进，这种改进只考虑了关键字比较次数，
并没有减少移位次数，所以平均时间和最坏情况下（待排序序列逆序）时间复杂
度o（n^2）,如果记录数量很大的话，这两种情况下是优于直接插入排序。再来看
一下最佳情况（待排序序列有序），此时关键字比较次数并不为o（1），时间复杂
度为o（n*log2n）。（其中折半查找时间复杂度o（log2n），这个在以后写查找的
时候再分析，这里不做详细讲解。）。所以在记录数较小、待排序序列基本有序情
况下直接插入排序优于折半插入排序。此外，折半插入排序是不稳定的原地排序，
实现起来也较复杂。

*/

int binarySearch(int low, int high, int a[], int key)
{
	int mid = (low + high)/2;
	if(low > high)
		return low;
	if(a[mid] == key)
		return mid;
	if(a[mid] < key)
		return binarySearch(mid+1, high, a, key);
	else
		return binarySearch(low, mid-1, a, key);
}

void binaryInsertion(int a[], int n)
{
	for(int i=1; i<10; i++)
	{
		int tmp = a[i];
		int j;
		int index = binarySearch(0, i-1, a, a[i]);
		cout<<"number is "<<a[i]<<endl;
		cout<<"index is "<<index<<endl;
		for(j=i-1; j>=index; j--)
		{
			a[j+1] = a[j];
		}
		a[j+1] = tmp;
	}

}


/*
效率分析：
表插入排序也是对直接插入排序的一种改进，这种改进只减少了移动次数，
并没有减少关键字比较次数，所以平均时间和最坏情况下（待排序序列逆序）
时间复杂度o（n^2）,如果记录数量很大的话，这两种情况下是优于直接插入
排序。再来看一下最佳情况（待排序序列有序），关键字比较次数并为o（1）
，时间复杂度为o（n）。此时和直接插入排序时间复杂度一样。此外，表插
入排序改变了记录的存储结构，无法顺序访问，是一种稳定的排序算法，实
现起来也较复杂。
*/

struct listNode{
	int val;
	int next;
};


void listInsertion(listNode *list, int n)
{
	list[0].next = 1;
	list[1].next = 0;
	int p, pre;
	

	for(int i=2; i<=n; i++)
	{
		p = list[0].next;
		pre = 0;

		while(p != 0 && (list[i].val >= list[p].val))
		{

			pre = p;
			p = list[p].next;

		}

		if(p == 0)
		{
			list[i].next = 0;
			list[pre].next = i;
			
		}

		else
		{
			list[i].next = p;
			list[pre].next = i;
			
		}

	}
}
/*
5.3 效率分析
当给定序列记录量较大时，希尔排序性能优于直接插入排序。再希尔排序的过程中，
关键字是跳跃式移动的，这样就减少了移动次数。希尔排序性能的分析是一个复杂
的问题，时间与所取的增量有关。增量选取的不好可能会大大降低排序效率。
*/
void shellInsert(int input[], int n, int dk)
{
	int j = 0;
	for(int i = dk; i < n; i += dk)
	{
		int tmp = input[i];
		{
			for(j = i - dk; j >= 0; j -= dk)
			{
				if(input[j] > tmp)
				{
					input[j + dk] = input[j];
				}
				else
					break;
			}
			input[j + dk] = tmp;
		}
	}
}

void shellInsertionSort(int input[], int n)
{
	int dk[] = {5,4,3,2,1};
	for(int i = 0; i < 5; i++)
	{
		shellInsert(input, n , dk[i]);
	}

}
/*
从代码来看，计数排序有5个for循环，其中三个时间是n，两个时间是k。所以总时间T(3n+2k),
时间复杂度o（n+k），不管是在最坏还是最佳情况下，此时间复杂度不变.此外，计数排序是稳
定的，辅助空间n+k,这个空间是比较大的，计数排序对待排序序列有约束条件(如前面我们假设
待排序序列a中值的范围[0,k],其中k表示待排序序列中的最大值)，元素值需是非负数，k太大
的话会大大降低效率。这里要注意的是 “扫描a数组把各个元素放在有序序列相应的位置上”
这步为什么要从后往前扫描a数组呢？大家想一想计数排序的过程就知道，因为从前扫描导致计
数排序不稳定，前面说了，计数排序是基数排序的基础，所以它的稳定性直接影响到基数排序的稳定。

时间复杂度小，空间复杂度大
当数据中的值较小时适用此法
*/
void countingSort(int input[], int max, int n)
{
	int* count = new int[max + 1];
	int* tmp_array = new int[n];
	for(int i = 0; i < max + 1; i++)
	{
		count[i] = 0;
	}
	for(int i = 0; i < n; i++)
	{
		count[input[i]]++;
	}	
	for(int i = 0; i < max; i++)
	{
		count[i+1] += count[i];
	}
	
	for(int i = n - 1; i >= 0; i--) // 必须要从后往前排序才是稳定的: 意思是对于重复元素，保持其原本在input中的相对位置。所以要从后往前扫
	{
		//cout<<"i = "<<i<<endl;
		//cout<<"input[i]"<<input[i]<<endl;
		//cout<<"tmp_array[count[input[i]]] "<<tmp_array[count[input[i]]]<<endl;
		cout<<"index: "<<count[input[i]]<<endl;
		tmp_array[count[input[i]] - 1] = input[i];
			//cout<<"here"<<endl;
		count[input[i]]--;
	}

	for(int i = 0; i < n; i++)
	{
		input[i] = tmp_array[i];
	}
	
	delete[] tmp_array;
	delete[] count;
}
/*
3.3 效率分析
基数排序时间T(n)=d*(2k+3n),其中d是记录值的位数，(2k+3n)是每一趟计数排序时
间，上文分析过了，k不超过9，d的值一般也很小，k、d都可以看成是一个很小的
常数，所以时间复杂度o（n）。最坏最佳情况并不改变时间复杂度。基数排序是稳
定的。辅助空间同计数排序k+n.

*/


void countingWithRadix(int input[], int radix, int n)
{
	int* count = new int[10];
	int* tmp_array = new int[n];
	for(int i = 0; i < 10; i++)
	{
		count[i] = 0;
	}
	for(int i = 0; i < 10; i++)
	{
		//cout<<input[i] / (int)pow(10.0, radix - 1) % 10<<endl;
		count[(input[i] / (int)pow(10.0, radix - 1) % 10) + 1]++;
	}
	for(int i = 0; i < 9; i++)
	{
		count[i+1] += count[i];
	}
	for(int i = n - 1; i >= 0; i--)
	{
		//cout<<"index: "<<count[(input[i] / (int)pow(10.0, radix - 1) % 10) + 1] - 1<<endl;
		tmp_array[count[(input[i] / (int)pow(10.0, radix - 1) % 10) + 1] - 1] = input[i]; 
		count[(input[i] / (int)pow(10.0, radix - 1) % 10) + 1]--;
	}
	for(int i = 0; i < n; i++)
	{
		input[i] = tmp_array[i];
	}
	delete[] tmp_array;
	delete[] count;
}

void radixSort(int input[], int radix, int n)
{
	for(int i = 1; i <= radix; i++)
	{
		countingWithRadix(input, i, n);
	}

}
/*
当记录在桶中分布均匀时，即每个桶只有一个元素，此时
时间复杂度o（n）。因此桶排序适合对很少重复的记录排序。
辅助空间2n。桶排序是稳定的排序，实现比较复杂。
*/

struct ListNode
{
	float value;
	ListNode * next;
	ListNode(float key = 0): value(key), next(NULL){}
};//注意自己定义构造函数会覆盖原有的默认构造函数

void bucketSort(float input[], int n)
{
	ListNode* bucket[10] = {NULL};
	for(int i = 0; i < n; i++)
	{
		//cout<<"i "<<i<<endl;
		//cout<<"input[i] "<<input[i]<<endl;
		int index = input[i] * 10;
		//cout<<"index: "<<index<<endl;
		ListNode *node = new ListNode(input[i]);
		ListNode *p;
		ListNode *q;
		p= bucket[index];
		if(bucket[index] == NULL)
		{
			bucket[index] = node;
			continue;
		}
		//cout<<"here"<<endl;
		
		while(p != NULL && input[i] > p->value)
		{
			q = p;
			p = p->next;
		}
		//注意通过指针对链表的操作，若p为空时，直接把node赋值给p，那么原链表将不会添加上这个元素，所以要添加q这个指针，通过q->next来赋值
		if(p == NULL)
		{
			q->next = node;
			//cout<<"q value: "<<node->value<<endl;
		}
		else
		{
			ListNode *tmp = p->next;
			p->next = node;
			node->next = tmp;
		}
		
	}
	
	for(int i = 0, j = 0; i < n; i++)
	{
		ListNode* tmp_node;
		//cout<<"bucket i"<<bucket[i]<<endl;
		tmp_node = bucket[i];
		while(tmp_node != NULL)
		{
			input[j] = tmp_node->value;
			
			//cout<<"input[j] "<<input[j]<<endl;
			j++;
			tmp_node = tmp_node->next;
		}
	}


}

int main()
{
	float input[] = {0.03, 0.05, 0.12, 0.55, 0.23, 0.12 ,0.23, 0.23, 0.24, 0.12};
	//shellInsertionSort(input, 10);
	//bubbleSort(input, 10);
	//quickSort(input, 0, 9);
	//mergeSort(input,0,9);
	//countingSort(input,232,10);
	//radixSort(input, 3, 10);
	bucketSort(input, 10);
	for(int i = 0; i < 10; i++)
	{
		cout<<input[i]<<" ";
	}
	cout<<endl;
}