java基本算法冒泡，插入，选择，归并

最近闲来没事，回顾了一下java的基本算法，给一些入门java不怎么理解算法的做一个很好的总结，理解精髓，不多说了，关键看代码，掌握算法思想才能做到灵活变通，算法是死的但是思想是活的，代码注释很清晰

package com.example.administrator.myapplication;

import android.os.Bundle;

import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.TextView;

import java.util.LinkedList;


public class MainActivity extends AppCompatActivity {
    private TextView txt_first, txt_last;
    //打印集合
    private String num_px;
    //找出集合的最大值
    private int max;
    //找出集合的最大值的位置
    private int position;
    //插入的数据
    private int cr_num[] = {48,21,560};
    private LinkedList<Integer> list=new LinkedList<>();


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        txt_first = (TextView) findViewById(R.id.txt_first);
        txt_last = (TextView) findViewById(R.id.txt_last);
        listAdd();
        for (int i = 0; i < list.size(); i++) {
            if (num_px == null) {
                num_px = list.get(i) + ",";
            } else {
                num_px = num_px + list.get(i) + ",";
            }

        }
        txt_first.setText("排序前" + num_px);

    }
    private void listAdd(){
        list.clear();
        list.add(1);
        list.add(23);
        list.add(12);
        list.add(32);
        list.add(431);
        list.add(2);
        list.add(25);
        list.add(45);
        list.add(46);
        list.add(31);
        list.add(27);
        list.add(68);

    }

    public void onclick(View view) {
        switch (view.getId()) {
            case R.id.bt_mp:
                sorting_mp();
                break;
            case R.id.bt_cr:
                sorting_cr();
                break;
            case R.id.bt_xz:
                sorting_xz();
                break;
            case R.id.bt_gb:
                sorting_gb();
                break;

        }

    }

    /**
     * 冒泡排序基本算法
     */
    private void sorting_mp() {
        listAdd();
        //循环list.size()次找出每次循环的集合最大值
        for (int i = 0; i < list.size(); i++) {
            //每一次循环找出该集合的最大值互换位置向后排列（list.size()-i-1：已排列好的集合不需要重新排列）
            for (int j = 0; j < list.size() - i - 1; j++) {
                if (list.get(j) > list.get(j+1)) {
                    max = list.get(j);
                    list.set(j,list.get(j+1));
                    list.set(j + 1,max);
                }
            }
        }
        num_px = null;
        //打印排列后的集合
        for (int i = 0; i < list.size(); i++) {
            if (num_px == null) {
                num_px = list.get(i) + ",";
            } else {
                num_px = num_px + list.get(i) + ",";
            }
        }
        txt_first.setText("排序后" + num_px);
    }

    /**
     * 插入排序基本算法(当列表的数据是有序的，此时插入数据进行排序)
     */
    private void sorting_cr() {
        sorting_mp();
        //循环需要插入的数组
        for (int i = 0; i < cr_num.length; i++) {
            //遍历集合从最后开始比较，
            for (int j = list.size()-1; j >= 0; j--) {
                //如果插入的数据没有比当前集合中的数字大则将当前位置向后移，
                if (cr_num[i] < list.get(j)) {
                    if(j==list.size()-1){
                        //这里比较如果是最后一位则采用添加
                        list.addLast(list.get(j));
                    }else {
                        list.set(j+1,list.get(j));
                    }
                }else {
                    if(j==list.size()-1){
                        //这里比较如果是最后一位则采用添加
                        list.addLast(cr_num[i]);
                    }else {
                        // 将当前位置赋值插入的数据（这里赋值的当前位置是比较后的位置因此要后推一位）
                        list.set(j+1,cr_num[i]);
                    }
                    break;
                }

            }
        }
        num_px = null;
        //打印排列后的集合
        for (int i = 0; i < list.size(); i++) {
            if (num_px == null) {
                num_px = list.get(i) + ",";
            } else {
                num_px = num_px + list.get(i) + ",";
            }
        }
        txt_last.setText("排序后" + num_px);

    }
    /**
     * 选择排序基本算法
     * */
    private void sorting_xz(){
        sorting_mp();
        //循环list.size()次找出每次循环的集合最大值
        for (int i = 0; i < list.size(); i++) {
            //每一次循环找出该集合的最大值并标记该位置（list.size()-i-1：已排列好的集合不需要重新排列）
            for (int j = 0; j < list.size() - i - 1; j++) {
                if (list.get(j) > list.get(j+1)) {
                    position = j;
                }
            }
            //将上一次的集合最大值排列在最后
            max=list.get(position);
            list.set(position,list.get(list.size()-1));
            list.set(list.size()-1,max);
        }
        num_px = null;
        //打印排列后的集合
        for (int i = 0; i < list.size(); i++) {
            if (num_px == null) {
                num_px = list.get(i) + ",";
            } else {
                num_px = num_px + list.get(i) + ",";
            }
        }
        txt_first.setText("排序后" + num_px);


    }
    /**
     * 归并排序基本算法
     * */
    int date[]={23,1,4,22,56,78,34,46};
    private void sorting_gb(){
        sort(date,0,date.length-1);
    }

    public void sort(int[] data, int left, int right) {
        if (left >= right)
            return;
        // 找出中间索引
        int center = (left + right) / 2;
        // 对左边数组进行递归
        sort(data, left, center);
        // 对右边数组进行递归
        sort(data, center + 1, right);
        // 合并
        merge(data, left, center, right);
        num_px = null;
        //打印排列后的集合
        for (int i = 0; i < data.length; i++) {
            if (num_px == null) {
                num_px = data[i] + ",";
            } else {
                num_px = num_px + data[i] + ",";
            }
        }
        Log.w("归并排序",num_px);
    }
    /**
     * 将两个数组进行归并，归并前面2个数组已有序，归并后依然有序
     *
     * @param data
     *            数组对象
     * @param left
     *            左数组的第一个元素的索引
     * @param center
     *            左数组的最后一个元素的索引，center+1是右数组第一个元素的索引
     * @param right
     *            右数组最后一个元素的索引
     */
    public void merge(int[] data, int left, int center, int right) {
        // 临时数组
        int[] tmpArr = new int[data.length];
        // 右数组第一个元素索引
        int mid = center + 1;
        // third 记录临时数组的索引
        int third = left;
        // 缓存左数组第一个元素的索引
        int tmp = left;
        while (left <= center && mid <= right) {
            // 从两个数组中取出最小的放入临时数组
            if (data[left] <= data[mid]) {
                tmpArr[third++] = data[left++];
            } else {
                tmpArr[third++] = data[mid++];
            }
        }
        // 剩余部分依次放入临时数组（实际上两个while只会执行其中一个）
        while (mid <= right) {
            tmpArr[third++] = data[mid++];
        }
        while (left <= center) {
            tmpArr[third++] = data[left++];
        }
        // 将临时数组中的内容拷贝回原数组中
        // （原left-right范围的内容被复制回原数组）
        while (tmp <= right) {
            data[tmp] = tmpArr[tmp++];
        }
    }


}

项目下载地址：https://download.csdn.net/download/qq_33407981/10290523