排序【操作】

排序

1、折半插入排序　　

折半插入排序的基本思想是：设在数据表中有一个元素序列a[0]~a[n-1],其中，a[0]~a[i-1]已经排好序，在插入a[i]时，利用折半查找法在有序表a[0]~a[i-1]内寻找a[i]的插入位置
#include"dataList.h"
void BinarysertSort(DataList &L)
{
	DataType temp;
	int i, j, low, middle;
	for(i = 1; i <= L.n-1; i++)
		if(L.elem[i-1].key > L.elem[i].key)
		{
			temp = L.elem[i];
			low = 0;
			high = i-1;
			while(low <= high)
			{
				mid = (low+high)/2;
				if(temp.key < L.elem[mid].key)
					high = mid -1;
				else low = mid +1;

			}
			for(j = i-1; j >= low; j--)
				L.elem[j+1] = L.elem[j];
			l.elem[low] = temp;
		}
};

2、直接插入排序算法可以基于链表来实现

直接插入排序算法可以基于链表来实现
#include"LinkList.h"
void inserSort(LinkNode * & head)
{
	LinkNode *pre, *p, *q;
	q = head ->link;
	head -> link = NULL;
	while(q != NULL)
	{
		pre = head;
		p = head -> link;
		while(p != NULL && p->data <= q->data)
		{
			pre = p;
			p = p->link;
		}
		pre->link = q;
		q = q->link;
		pre->link->link = p;
	}
};

3、折半插入排序算法

在折半插入排序算法中用到一个小循环，是为了在有序子序列中找到插入位置后把有序子序列后面的元素全部后移，空出插入位置给要插入的元素
#include"dataLIst.h"
void BinaryInsertSort(DataList &L)
{
	DataType temp;
	int i,j,low,high,middle;
	for(i = 1; i <= L.n-1; i++)
		if(L.elem[i-1].key>L.elem.key)
		{
			temp = L.elem[i];
			low = 0;
			high = i-1;
			while(low <= high)
			{
				mid = (low+high)/2;
				if(temp.key < l.elem[mid].key)
				{
					for(j = high; j>=mid; j--)
						L.elem[j+1] = L.elem[j];
					high = mid-1;
				}
				else low = mid+1;
			}
			L.elem[low] = temp;
		}
};

4、冒泡排序算法基于链表实现

#include"LinkList.h"
void BubbleSort(LinkNode *&head)
{
	LinkNode *front,*pre,*p,*q,*rear,*last;
	last = NULL;

	while(head ->link != last)
	front = head; rear = pre = head->link;
	p = pre->link;
	while(p != last)
	{
		q = p->link; p->link = pre; pre ->link = q;
		front->link = p;
		front = p;
		rear = pre;
	}
	else front = pre;
	pre = front->link;
	p = pre ->link;
	}
	last = rear;
}

5、设计一个算法，使得在O（n）的时间内重排数组，将所有取负值的排序码排在所有取正值的排序码之前

设计一个算法，使得在O（n）的时间内重排数组，将所有取负值的排序码排在所有取正值的排序码之前
void exstorage(int A[],int n)
	int i = 0, j = n-1, temp;
	while(i<j)
	{
		while(i<j && A[i]%2 != 0)i++;
		while(i<j && A[i]%2 == 0)j--;
		if(i<j)
		{
			temp = A[i];
			A[i] = A[j]; 
			A[j] = temp;
		}
	};

6、快速排序算法

借助于快速排序算法的思想，在一组无序的元素中查找关键码等于x的元素
	int find(DataType A[], int left, int right, DataType X)
	{
		int i = left, j = right;
		while(i < j)
		{
			while(i <= j && A[j]>x)
				j--;
			if(A[j] == x)
				return j;
			while(i<=j && A[i]<x)
				i++;
			if(A[i] == x)
				return i;
			j--; i++;
		}
		return -1;
	}

7、设计一个递归函数，重新实现简单排序算法　

void selectSort(int A[], int left, int right)
	{
		if(left < right)
			int K = left, i, temp;
		for(i = left+1; i<= right; i++)
			if(A[i] < A[k])
				k = i;
			if(left != k)
			{
				temp = A[left];
				A[left] = A[k];
				A[k] = temp;
			}
			selectSort(A,left+1,right);
			}
	};

8、用单链表存储的待排数据序列实现简单选择排序

#include"LinkList.h"
		void selectSort(LinkList * & head)
		{
			LinkNode *h = head ->link, *p, *q, *r, *s;
			head->link = NULL;
			while(h != NULL)
			{
				p = s = h;
				q = r = NULL;
				while(p != NULL)
				{
					if(p->data > s->data)
					{
						s = p;
						r = q;
					}
					q = p; p = p->link;
				}
				if(s==h)
					h = h -> link;
				else r->link = s->link;
				s->link = head -> link; head -> link = s;
			}

		}		
　　

9、用单链表存储的待排数据序列实现简单选择排序

#include"stdio.h" 
		typedef struct LinkNode
		{
			int data;
			struct LinkNode * next
		}LinkNode, *Linklist;
		void selectSort(LinkList head);
		int main()
		{
			selectSort(head);
			return 0;
		}

        void selectSort(LinkList head)
        {
            LinkNode *h = head ->next, *p, *q, *r, *s;
            head->next = NULL;
            while(h != NULL)
            {
                p = s = h;
                q = r = NULL;
                while(p != NULL)
                {
                    if(p->data > s->data)
                    {
                        s = p;
                        r = q;
                    }
                    q = p; p = p->next;
                }
                if(s==h)
                    h = h -> next;
                else r->next = s->next;
                s->next = head -> next; head -> next = s;
            }
 
        }