《数据结构（A）》第10章“查找”基本作业与设计作业

1  作业题目

10.1 编程实现快速排序。

10.2 编程实现冒泡排序。

10.3 以单链表为存储结构，实现简单选择排序。

2  作业题目解答

【10.1题解答】

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
void QuickSort(int* arr, int low, int high)
{
	if (low >= high)
		return;
	int left = low,right = high;
	int key = arr[low];
	while (low < high)
	{
		//找小
		while (arr[high] >= key && low < high)
		{
		  --high;
		}
		//小的放到左边的low指向
		arr[low] = arr[high];
		//找大
		while (arr[low] <= key && low < high)
		{
			++low;
		}
		//大的放到右边的high指向
		arr[high] = arr[low];
	}
	arr[low] = key;
	int keyi = low;
	//[left,keyi-1]keyi[keyi+1,right]
	QuickSort(arr, left, keyi - 1);
	QuickSort(arr, keyi + 1, right);
}

int main() {
  int a[100];
  int n;
  printf("数组元素个数：\n");
  scanf("%d", &n);
  for (int i = 0; i < n; i++) {
	scanf("%d", &a[i]);
  }
  QuickSort(a, 0, n - 1);
  for (int i = 0; i < n; i++) {
	printf("%d ", a[i]);
  }
}

运行结果：

 【10.2题解答】

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
void bubblesort(int* R, int n)
// 改进的冒泡排序算法一
{
  int i = n, temp;
  int flag = 1;         // flag=1表示发生了交换
  while ((i > 1) && flag) {
	{ flag = 0;
	for (int j = 0; j < i-1; j++)
	  if (R[j] > R[j + 1])
	  {
		temp = R[j];
		R[j] = R[j + 1];
		R[j + 1] = temp;
		flag = 1;
	  }
	i--;
	}
  }
}

int main() {
    int a[100];
	int n,i;
	printf("数组元素个数：\n");
	scanf("%d", &n);
	printf("请输入数组元素：\n");
	for (i = 0; i < n; i++) {
	  scanf("%d", &a[i]);
	}
	a[i] = '\0';
	bubblesort(a, n);
	printf("冒泡排序后：\n");
	for (int i = 0; i < n; i++) {
	  printf("%d ", a[i]);
	}

运行结果：

 【10.３题解答】

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#define Maxsize 20

typedef struct {
  int key;
}RedType;

typedef struct {
  RedType r[Maxsize + 1];
  int length;
}SqList;

typedef struct Node {
  int data;
  struct Node* next;
}node, * List;
//创建单链表

List creat_list(int n)
{
  int i = 0;
  List head, L, temp;
  head = (List)malloc(sizeof(node));
  head->next = NULL;
  temp = head;
  for (; i < n; i++) {
    L = (List)malloc(sizeof(node));
    L->next = NULL;
    scanf("%d", &L->data);
    temp->next = L;
    temp = L;
  }
  return head;
}

List getmin(List L) {//取得从指针L开始的链表中记录的最小值
  List min;
  min = L;
  while (L->next) {
    if (min->data > (L->next->data)) {
      min = L->next;
    }
    L = L->next;
  }

  return min;//返回较小值的指针
}

void selectsort(List head)//简单选择排序--单链表
{
  List j, i = head->next;
  int temp;
  for (; i->next != NULL; i = i->next) {
    j = getmin(i);
    if (i->data != j->data) {
      temp = i->data;
      i->data = j->data;
      j->data = temp;
    }
  }
}
//输出单链表

void printf_list(List head) {
  List p = head->next;
  while (p) {
    printf("%3d", p->data);
    p = p->next;
  }
}

int main() {
  List head;
  SqList L;
  L.length = 10;
  int n;
  printf("请输入元素个数:");
  scanf("%d", &n);
  head = creat_list(n);
  //printf("\n");
  selectsort(head);
  printf("选择排序输出：\n");
  printf_list(head);
  printf("\n");

  return 0;
}