二叉树和快速排序的算法实现

1 快速排序+选择排序+冒泡排序

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int mid_seek(int arr[], int low, int high)
{
    //默认基准值为第一个（low）元素
    int key = arr[low];
    while (low < high)
    {
        //先从后面比较，直到遇到比key小的值
        while (low < high && key <= arr[high])
        {
            --high;
        }
        //交换两个下标的值（把小的值放在key前面）
        arr[low] = arr[high];
        //再从前面依次比较，直到遇到比key大的值
        while (low < high && key >= arr[low])
        {
            ++low;
        }
        //交换两个下标的值（把大的值放在key后面）
        arr[high] = arr[low];
    }
    //将基准值放在（low == high）下
    arr[low] = key;
    //返回基准值下标
    return low;
}

void quick_sort(int arr[], int low, int high)
{
    //直到只剩下一个元素（low == high）
    if (low < high)
    {
        int mid = mid_seek(arr, low, high);
        //递归基准值的左边
        quick_sort(arr, low, mid - 1);
        //递归基准值的右边
        quick_sort(arr, mid + 1, high);
    }
}

//冒泡排序
void Bubble(int arr[], int len)
{
    
    //扫描次数
    for (int i = 0; i < len - 1; i++)
    {
        int cnt = 0;
        //每次扫描将最值放在最后
        for (int j = 0; j < len - i - 1; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                ++cnt;
            }
        }
        if (!cnt)
            break;
    }
}

//选择排序
void simple_select(int arr[], int len)
{
    for (int i = 0; i < len - 1; i++)//扫描的次数
    {
        int min_i = i;
        for (int j = i + 1; j < len; j++)//每次扫描确定最值
        {
            if (arr[min_i] > arr[j])
            {
                min_i = j;
            }
        }
        if (min_i != i)//交换最值位置
        {
            int temp = arr[min_i];
            arr[min_i] = arr[i];
            arr[i] = temp;
        }
    }
}

//快速排序
int main(void)
{
    int arr[] = { 1, 4, 5, 2, 7, 0, 6 };
    int len = sizeof(arr) / sizeof(arr[0]);

    simple_select(arr, len);
    //遍历数组
    for (int i = 0; i < len; i++)
    {
        printf("%d\t", arr[i]);
    }

    return 0;
}

2 直接插入排序

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int* insert_sort(int* p, int len)
{
    int j = 0;
    //i：无序区下标；j：有序区下标
    for (int i = 1; i < len; i++)
    {
        int temp = p[i];
        j = i;
        while (j > 0 && temp < p[j - 1])
        {
            //将无序区的数与有序区（从尾部开始）的数比较，小于有序区数时，将有序区数后移
            p[j] = p[j - 1];
            --j;
        }
        //如果有序区数小于无序区数时，插入无序区数
        if(j != i)
            p[j] = temp;
    }
    for (int i = 0; i < len; i++)
    {
        printf("%d\t", p[i]);
    }
    return p;
}

//直接插入排序
int main(void)
{
    int arr[] = {1, 4, 5, 2, 7, 0, 6};
    int len = sizeof(arr) / sizeof(arr[0]);
    
    insert_sort(arr, len);
    //遍历数组
    
    return 0;
}

3 二叉树的创建与遍历

3.1 功能函数

#define _CRT_SECURE_NO_WARNINGS 1
#include "binary.h"

/*
* Purpose：创建二叉树
* 
* Entry：  无
* 
* return：返回二叉树的地址
*/
Btree new_binary()
{
    Eletype ele = 0;
    printf("请输入数据元素：");
    scanf("%c", &ele);
    getchar();
    if (ele == '#')//递归终止条件
        return NULL;

    Btree T = malloc(sizeof(Node));

    T->data = ele;//数据域赋值
    T->left = new_binary();//左子树的创建
    T->right = new_binary();//右子树的创建

    return T;
}

void output(Btree T)
{
    
    if(T == NULL)//递归终止条件
        return NULL;
    printf("%c\t", T->data);
    //先打印左子树
    output(T->left);
    //打印右子树
    output(T->right);
}

3.2 头文件

#pragma once
#ifndef __BINARY_H__
#define __BINARY_H__

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef char Eletype;

typedef struct Node
{
    //数据域
    Eletype data;
    //指针域
    struct Node* left, * right;
}Node, *Btree;

Btree new_binary();
void output(Btree T);

#endif

3.3 主函数

#define _CRT_SECURE_NO_WARNINGS 1
#include "binary.h"


int main(void)
{
    //创建二叉树
    Btree T = new_binary();
    //遍历二叉树
    output(T);
    return 0;
}

4 二叉树的遍历方式

已知先序与中序或者中序与后序则可推出二叉树