排序算法-c实现

---

1.算法实现

1.1选择排序，冒泡排序，插入排序，快速排序，归并排序

#include <stdio.h>
#include <stdlib.h>
#include<cstring>
void quicksort(int arr[],int left,int right) {
	if (left >= right) {
		return;
	};
	int pivot = arr[left];
	int i = left;
	int j = right;
	while (i < j) {
		while (arr[j] >= pivot && i < j){
			j--;
		};
		while (arr[i] <= pivot && i < j) {
			i++;
		};
		if (i < j) {
			int temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		};
	};
	arr[left] = arr[i];
	arr[i] = pivot;
	quicksort(arr, left, i - 1);
	quicksort(arr, i + 1, right);
};
void merge(int arr[], int left, int mid, int right) {
	int len1 = mid - left + 1;
	int len2 = right - mid;
	int *a = new int[len1+1];
	int *b = new int[len2+1];
	for (int i = 0; i < len1; i++) {
		a[i] = arr[left + i];
	};
	for (int j = 0; j < len2; j++) {
		b[j] = arr[mid + 1 + j];
	};
	int i = 0, j = 0;
	a[len1] = b[len2] = INT_MAX;
	for (int k = left; k <= right; k++) {
		if (a[i] < b[j]) {
			arr[k] = a[i];
			i++;
		}
		else {
			arr[k] = b[j];
			j++;
		}
	}
};
void mergesort(int arr[], int left, int right) {
	if (left < right) 
	{
		int mid = (left + right) / 2;
		mergesort(arr, left, mid);
		mergesort(arr, mid + 1, right);
		merge(arr, left, mid, right);
	}
	else {
		return;
	}
};
void bubblesort(int arr[],int len) {
	for (int i = len - 1; i > 0; i--) {
		for (int j = 0; j <= i - 1; j++) {
			if (arr[j] > arr[j + 1]) {
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
};
void selectionsort(int arr[], int len) {
	for (int i = 0; i <= len - 2; i++) {
		int smallest = i;
		int index = i;
		for (int j = i; j < len; j++) {
			if (arr[j] < arr[smallest]) {
				smallest = j;
			}
		};
		int temp = arr[index];
		arr[index] = arr[smallest];
		arr[smallest] = temp;
	}
};
void swap(int* Ina, int* Inb)
{
	int temp = *Ina;
	*Ina = *Inb;
	*Inb = temp;
};
void insertsort(int arr[], int len) {
	for (int i = 1; i < len; i++)
	{
		for (int j = i; j > 0; j--)
		{
			if (arr[j] > arr[j - 1])
			{
				break;
			}
			else
			{
				swap(&arr[j], &arr[j - 1]);
			}
		}
	}
};
int main()
{
	int arr[] = { 1,4,9,5,7 };
	//quicksort(arr, 0, 4);
	//mergesort(arr, 0, 4);
	//bubblesort(arr, 5);
	//selectionsort(arr, 5);
	//insertsort(arr, 5);	
	for (int i = 0; i < 5; i++) {
		printf("%d", arr[i]);
	};
	system("pause");
	return 0;
}

1.2链表实现冒泡排序

#include <stdio.h>
#include <stdlib.h>
struct node {
	int data;
	struct node *next;
};
int main() {
	int n,data;
	struct node *head,*p,*q;
	scanf_s("%d", &n);
	head = NULL;
	p = NULL;
	q = NULL;
	for (int i = 0; i < n; i++) {
		scanf_s("%d", &data);
		p = (struct node *)malloc(sizeof(struct node));
		p->data = data;
		p->next = NULL;
		if (head == NULL) {
			head = p;
			q = p;
		}
		else {
			q->next = p;
			q = p;
		};
	};
	struct node *s;
	struct node *t = head;
	for (int i = 0; i < n; i++) {
		printf_s("%d\t", t->data);
		t = t->next;
	};
	printf("\n");
	int i = 1;
	while (i < n)
	{
		printf("%d\n", i);
		s = head;
		while (s->next != NULL)
		{
			if (s->next->data < s->data)
			{
				printf("%d %d\t", s->data, s->next->data);
				int temp = s->data;
				s->data = s->next->data;
				s->next->data = temp;
			}
			s = s->next;
			printf("\n");			
		}
		i++;
	};
	t = head;
	for (int i = 0; i < n; i++) {
		printf("%d\t", t->data);
		t = t->next;
	}
	system("pause");
	return 0;
}

2.稳定性分析

排序后的相对位置与排序之前相同即具有稳定性。其中堆排序和快速排序不稳定，冒泡、插入、选择和归并排序具有稳定性。因为堆排序以及快速排序都会将pivot与中间的值交换，导致相对顺序改变，所以不具有稳定性。