zoukankan      html  css  js  c++  java
  • Java 常用排序算法实现--快速排序、插入排序、选择、冒泡

     
    复制代码
    public class ArrayOperation {

        //二分查找算法
        public static int branchSearch(int[] array, int searchNum) {
            if (array == null)
                throw new NullPointerException("Null Referrence");
            if (array.length == 0)
                throw new IllegalArgumentException("Array Length is Zero");
            int low = 0, high = array.length;
            int middle = (high + low) / 2;
            int index = -1;
            if (searchNum <</span> array[0] || searchNum > array[array.length - 1])
                return index;
            while (middle >= 0) {
                if (array[middle] == searchNum) {
                    index = middle;
                    break;
                }
                if (searchNum > array[middle]) {
                    low = middle;
                } else {
                    high = middle;
                }
                middle = (low + high) / 2;
            }

            return index;

        }

        // 快速排序
        
        public static void quickSort(int a[], int left, int right) {
            int i, j, temp;
            i = left;
            j = right;
            if (left > right)
                return;
            temp = a[left];
            while (i != j)
            {
                while (a[j] >= temp && j > i)
                    j--;
                if (j > i)
                    a[i++] = a[j];
                while (a[i] <= temp && j > i)
                    i++;
                if (j > i)
                    a[j--] = a[i];

            }
            a[i] = temp;
            quickSort(a, left, i - 1);
            quickSort(a, i + 1, right);
        }

        // 插入排序
        // 特点:用temp保存将要排序的临时值,然后把大的值插入到这个位置。
        public static int[] insert_Sort(int[] array) {
            int i, j, temp;
            for (i = 1; i <</span> array.length; i++) {
                for (j = i, temp = array[i]; j > 0 && temp <</span> array[j - 1]; j--)
                    array[j] = array[j - 1];
                array[j] = temp;
            }
            return array;
        }

        // 冒泡排序
        // 特点:从第一个元素开始,如果需要交换,就一直冒泡到底,如果不需要交换,就从下一个元素开始比较
        public void bubble_Sort(int[] array, int size) {
            int i, j, temp;
            for (i = size - 1; i > 1; i--)
                for (j = 0; j <</span> i; j++)
                    if (array[j] > array[j + 1]) {
                        temp = array[j + 1];
                        array[j + 1] = array[j];
                        array[j] = temp;
                    }
        }

        // 交换排序
        // 特点:始终是第一个元素与其他元素一一比较,交互后,继续用第一个元素与后面元素一一比较,重复下去。
        public int[] change_Sort(int[] array, int size) {
            int i, j, temp;
            for (i = 0; i <</span> size; i++)
                for (j = i + 1; j <</span> size; j++)
                    if (array[i] > array[j]) {
                        temp = array[j];
                        array[j] = array[i];
                        array[i] = temp;
                    }
            return array;
        }

        // 选择排序一(便于区分:咱就叫:选择最小值排序法)
        // 特点:分有序区(第一个元素)和无序区(除第一元素外的元素),从无序区找出最小的元素移动到有序区
        public void SelectSort(int[] array) {
            int i, j, k;// 分别为有序区,无序区,无序区最小元素指针
            for (i = 0; i <</span> array.length; i++) {
                k = i;
                for (j = i + 1; j <</span> array.length; j++) {
                    if (array[j] <</span> array[k])
                        k = j;
                }
                if (k != i)// 若发现最小元素,则移动到有序区
                {
                    int temp = array[k];
                    array[k] = array[i];
                    array[i] = array[temp];
                }
            }
        }

        // 选择排序二
        public int[] select_Sort(int[] array, int size) {
            int i, j, temp, pos;
            for (i = 0; i <</span> size; i++) {
                for (j = i + 1, temp = array[i], pos = i; j <</span> size; j++)
                    if (temp > array[j]) {
                        temp = array[j];
                        pos = j;
                    }
                array[pos] = array[i];
                array[i] = temp;
            }

            return array;
        }

        //希尔排序
        //    属于插入类排序,是将整个无序列分割成若干小的子序列分别进行插入排序
        //  排序过程:先取一个正整数d1
        //  然后取d2
        public static void ShellSort(int[] array) {
            int length = array.length;
            for (int h = length / 2; h > 0; h = h / 2) {
                // here is insert sort
                for (int i = h; i <</span> length; i++) {
                    int temp = array[i];
                    if (temp <</span> array[i - h]) {
                        for (int j = 0; j <</span> i; j += h) {
                            if (temp <</span> array[j]) {
                                temp = array[j];
                                array[j] = array[i];
                                array[i] = temp;
                            }
                        }
                    }
                }
            }
        }
    }
    复制代码
  • 相关阅读:
    Atitit 经济学常见的流派 古典主义与凯恩斯主义
    Atitit 学习方法 体系化学习方法 Excel 科目,分类,专业 三级分类。。 知识点。。 课程就是每一个知识点的详细化。。 比如经济学 类别 专业 xx概论知识点 3、金
    atiitt it学科体系化 体系树与知识点概念大总结.xlsx
    Atitit 减少财政支出普通人如何蹭政府补贴措施 attilax大总结.docx
    Atitit 信用管理概论 attilax学习心得
    Atitit.月度计划日程表 每月流程表v5
    Atitit 企业6大职能 attilax总结
    Atitit 常见每日流程日程日常工作.docx v8 ver ampm imp 签到 am y 天气情况检查 am y 晨会,每天或者隔天 am 每日计划(项目计划,日计划等。 am
    Atitit 财政赤字解决方案
    Atitit 建设自己的财政体系 attilax总结 1.1. 收入理论 2 1.2. 收入分类 2 1.3. 2 1.4. 非货币收入 2 1.5. 2 1.6. 降低期望 2 1.7.
  • 原文地址:https://www.cnblogs.com/huxinping8800/p/7083843.html
Copyright © 2011-2022 走看看