1、直接插入排序算法

源码:

package com.DiYiZhang;
/* 插入排序算法
 * 如下进行的是插入,排序算法*/

public class InsertionSort {
    public static void insertionSort(int[] a) {
        int tmp;
        for (int i = 1; i < a.length; i++) {
            for (int j = i; j >0; j--) {
                if (a[j] < a[j-1]) {
                    tmp = a[j-1];
                    a[j-1] = a[j];
                    a[j] = tmp;
                }
            }
//            for(int j=i+1;j<a.length;j++){
//            if(a[j]>a[j+1]){
//                tmp=a[j+1];
//                a[j+1]=a[j];
//                a[j]=tmp;
//            }
//            }
        }
    }
    public static void main(String[] args) {
        int[] a = { 49, 38, 65, 97, 76, 13, 27, 50 };
        insertionSort(a);
        for (int i : a)
            System.out.print(i + " ");
    }
}

2、二分查找排序算法

源码:

package com.DiYiZhang;
import java.security.*;
import java.awt.dnd.*;
import java.awt.*;
import java.net.*;
import java.sql.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.Arrays;
import java.util.Scanner;

/*  本程序用来将乱序的一组数字先按照二分查找的方式进行排序*/
public class MergeSort {
     public static void main(String[] args) {
//         Scanner reader=new Scanner(System.in);
//         reader.hasNextLine();
            int []a ={564,378,954,1255,684,57,15,389,687,45,98,125,348};  
            new MergeSort().MergeSort(a,0,a.length-1);  
            for(int i:a) {  
                System.out.print(i+" ");  
            }  
        }  
        public void MergeSort(int []a,int low,int high) {  
            int mid=0;  
            while(low<high) {  
                mid=low+(high-low)/2;  
                MergeSort(a,low,mid);  
                MergeSort(a,mid+1,high);  
                Merge(a,low,mid,high);  
                return;  
            }  
        }  
        private void Merge(int[] a, int low, int mid, int high) {  
            // TODO Auto-generated method stub  
            int i=low,j=mid+1,k=0;  
            int []b = new int[high-low+1];  
            while(i<=mid&&j<=high) {  
                if(a[i]<=a[j]) {  
                    b[k++]=a[i++];  
                }else {  
                    b[k++]=a[j++];  
                }  
            }  
            while(i<=mid) {  
                b[k++]=a[i++];  
            }  
            while(j<=high) {  
                b[k++]=a[j++];  
            }  
            for(int x=0,m=low;m<=high;m++) {  
                a[m]=b[x++];  
            }  
              
        }  
    }

3、直接排序算法

源码:

package com.DiYiZhang;

import java.util.Arrays;

public class SelectSort {

public static void selectSort(int[] a) {
        if (a == null || a.length <= 0) {
            return;
        }
        for (int i = 0; i < a.length; i++) {
////            int temp = a[i];
//            int temp=i;
            int flag = i; // 将当前下标定义为最小值下标
            for (int j = i + 1; j < a.length; j++) {
                if (a[j] < a[flag]) {// a[j] < temp 从小到大排序;a[j] > temp 从大到小排序
//                    temp = a[j];
                    flag = j; // 如果有小于当前最小值的关键字将此关键字的下标赋值给flag
                }    
            }
            if (flag != i) {
                int temp=a[i];
                a[i]=a[flag];
                a[flag] = temp;
//                a[i] = temp;
            }
        }
    }
    public static void main(String[] args) {
        int a[] = { 49,38,65,97,76,13,27,49 };
        System.out.println("交换之前的排序列表");
        for(int i:a){
            System.out.print(i+" ");
        }
        selectSort(a);
        System.out.println("交换之后的排序列表");
        System.out.println(Arrays.toString(a));
    }
}
//class A{
//    int sys(int a){
//        int w=a;
//        return w;
//    }
//}
//public class InsertionSort{
//    public static void insrtionSort(int []a){
//        int tmp;
//        for(int i=1;i<a.length;i++){
//            for(int j=i;j>0;j--){
//                if(a[j]<a[j-1]){
//                    tmp=a[j-1];
//                    a[j-1]=a[j];
//                    a[j]=tmp;
//                }
//            }
//        }
//    }
//    public static void main(String [] args){
//        int[]a={23,34,2,45,3,24,54,33};
//        for(int i:a){
//            System.out.println(i+" ");
//        }
//    }
//}
4、背包问题

  1. public class sf {
  2. public static void main(String[] args) {
  3. // TODO Auto-generated method stub
  4. int[] weight = {3,5,2,6,4}; //物品重量
  5. int[] val = {4,4,3,5,3}; //物品价值
  6. int m = 12; //背包容量
  7. int n = val.length; //物品个数
  8. int[][] f = new int[n+1][m+1]; //f[i][j]表示前i个物品能装入容量为j的背包中的最大价值
  9. int[][] path = new int[n+1][m+1];
  10. //初始化第一列和第一行
  11. for(int i=0;i<f.length;i++){
  12. f[i][0] = 0;
  13. }
  14. for(int i=0;i<f[0].length;i++){
  15. f[0][i] = 0;
  16. }
  17. //通过公式迭代计算
  18. for(int i=1;i<f.length;i++){
  19. for(int j=1;j<f[0].length;j++){
  20. if(weight[i-1]>j)
  21. f[i][j] = f[i-1][j];
  22. else{
  23. if(f[i-1][j]<f[i-1][j-weight[i-1]]+val[i-1]){
  24. f[i][j] = f[i-1][j-weight[i-1]]+val[i-1];
  25. path[i][j] = 1;
  26. }else{
  27. f[i][j] = f[i-1][j];
  28. }
  29. //f[i][j] = Math.max(f[i-1][j], f[i-1][j-weight[i-1]]+val[i-1]);
  30. }
  31. }
  32. }
  33. for(int i=0;i<f.length;i++){
  34. for(int j=0;j<f[0].length;j++){
  35. System.out.print(f[i][j]+" ");
  36. }
  37. System.out.println();
  38. }
  39. int i=f.length-1;
  40. int j=f[0].length-1;
  41. while(i>0&&j>0){
  42. if(path[i][j] == 1){
  43. System.out.print("第"+i+"个物品装入 ");
  44. j -= weight[i-1];
  45. }
  46. i--;
  47. }
  48. }
  49. }

常见的排序算法(直接插入&选择排序&二分查找排序)的更多相关文章

  1. Python排序算法之选择排序定义与用法示例

    Python排序算法之选择排序定义与用法示例 这篇文章主要介绍了Python排序算法之选择排序定义与用法,简单描述了选择排序的功能.原理,并结合实例形式分析了Python定义与使用选择排序的相关操作技 ...

  2. 八大排序算法~简单选择排序【记录下标k变量的作用】

    八大排序算法~简单选择排序[记录下标k变量的作用] 1,思想:打擂台法,数组中的前n-1个元素依次上擂台"装嫩",后边的元素一个挨着一个不服,一个一个上去换掉它 2,优化:通过记录 ...

  3. java排序算法(十):桶式排序

    java排序算法(十):桶式排序 桶式排序不再是一种基于比较的排序方法,它是一种比较巧妙的排序方式,但这种排序方式需要待排序的序列满足以下两个特征: 待排序列所有的值处于一个可枚举的范围之类: 待排序 ...

  4. java排序算法(八):希尔排序(shell排序)

    java排序算法(八):希尔排序(shell排序) 希尔排序(缩小增量法)属于插入类排序,由shell提出,希尔排序对直接插入排序进行了简单的改进,它通过加大插入排序中元素之间的间隔,并在这些有间隔的 ...

  5. javascript数据结构与算法--高级排序算法(快速排序法,希尔排序法)

    javascript数据结构与算法--高级排序算法(快速排序法,希尔排序法) 一.快速排序算法 /* * 这个函数首先检查数组的长度是否为0.如果是,那么这个数组就不需要任何排序,函数直接返回. * ...

  6. 七内部排序算法汇总(插入排序、Shell排序、冒泡排序、请选择类别、、高速分拣合并排序、堆排序)

    写在前面: 排序是计算机程序设计中的一种重要操作,它的功能是将一个数据元素的随意序列,又一次排列成一个按keyword有序的序列.因此排序掌握各种排序算法很重要. 对以下介绍的各个排序,我们假定全部排 ...

  7. 排序算法总结------选择排序 ---javascript描述

    每当面试时避不可少谈论的话题是排序算法,上次面试时被问到写排序算法,然后脑袋一懵不会写,狠狠的被面试官鄙视了一番,问我是不是第一次参加面试,怎么可以连排序算法都不会呢?不过当时确实是第一次去面试,以此 ...

  8. 第四篇、C_快速、冒泡、选择、插入排序、二分查找排序、归并、堆排序

    1.快速排序 实现: 1.取中间一个数作为支点 2.分别在支点的左右两边进行查找,如果左边查找到比支点大,右边查找到比支点小,就交换位置,如此循环,比支点小的数就排在了左边,比支点大的就排在右边 3. ...

  9. 常用排序算法之——选择排序(C语言+VC6.0平台)

    选择排序是另一种经典排序算法,核心思想是:在一趟找最小(大)数的过程中,先假设待排数据中的第一个数据即为最小(大)数据,然后循环将其他数据与该数据比较,每次比较时若小于该数据则让新数据成为最小(大)数 ...

随机推荐

  1. ES6走一波 Proxy/Reflect

    Proxy:像拦截器,对目标对象修改等进行拦截,是一种元编程(meta programming),即修改JS语言本身. //生成proxy实例,两个参数都是对象,targetObj是要拦截的目标对象, ...

  2. 【tmos】spring data jpa 创建方法名进行简单查询

    参考链接 spring data jpa 创建方法名进行简单查询:http://www.cnblogs.com/toSeeMyDream/p/6170790.html

  3. python概念(一)python基本数据类型

    http://www.cnblogs.com/nulige/p/6115765.html

  4. Tesseract识别图片提取文字&字库训练

    文中测试了3.0和4.0两个版本.发现3.0识别效率不准确,需要训练词库.4.0识别效率就比较高了,而且支持结果生成pdf.txt等格式.所以推荐使用4.0版本. 这个工具可以用在爬虫的时候获取验证码 ...

  5. nginx的linux服务器内核参数调整【转】

    概述 由于默认的linux内核参数考虑的是最通用场景,这明显不符合用于支持高并发访问的Web服务器的定义,所以需要修改Linux内核参数,让Nginx可以拥有更高的性能: 在优化内核时,可以做的事情很 ...

  6. html单选按钮用jQuery中prop()方法设置

    模拟单选按钮时用jQuery,prop方法来设置. 赋默认选中值:$("#" + id).find("input:radio[value='" + state ...

  7. Linux将公网ip映射到局域网ip

    测试环境如下: monitor: msc1:公网IP:103.6.164.128 eth0 内网IP:192.168.0.57 eth0内网IP:192.168.0.16 eth1 通过访问monit ...

  8. Mysql数据库远程链接、权限修改、导入导出等基本操作

    一.连接MySQL 格式: mysql -h主机地址 -u用户名 -p用户密码 1.例1:连接到本机上的MYSQL. 首先在打开DOS窗口,然后进入目录 mysqlbin,再键入命令mysql -ur ...

  9. windows类书的学习心得

    原文网址:http://www.blogjava.net/sound/archive/2008/08/21/40499.html 现在的计算机图书发展的可真快,很久没去书店,昨日去了一下,真是感叹万千 ...

  10. Lyk Love painting/convex hull/mumsic

    这场比赛真的是...打的好颓废啊... 所有题面的传送门 T1 分析: 我们发现 二分答案 + \(n^3\) \(dp\) 判断可行性 可以拿 60 分(于是就写好了啊!) 然后我们发现上面的 \( ...