• 手写算法


    1. package com.wxl.array;
    2.  
       
    3.  
      public class Sort {
    4.  
       
    5.  
      private static void show(int[] a) {
    6.  
      int i;
    7.  
      for(i=0;i<a.length;i++)
    8.  
      System.out.print(a[i]+" ");
    9.  
      }
    10.  
       
    11.  
      public static void bubbleSort(int[] a) {
    12.  
      int i,j,temp,flag;
    13.  
      for(i=0;i<9;i++)
    14.  
      {
    15.  
      flag=1;//若本身有序,则只进行一次循环
    16.  
      for(j=0;j<9-i;j++)
    17.  
      if(a[j]>a[j+1])
    18.  
      {
    19.  
      temp=a[j];
    20.  
      a[j]=a[j+1];
    21.  
      a[j+1]=temp;
    22.  
      flag=0;
    23.  
      }
    24.  
      if(flag==1) break;
    25.  
      }
    26.  
      show(a);
    27.  
       
    28.  
      }
    29.  
       
    30.  
      public static void insertSort(int[] a) {
    31.  
      int i,j;
    32.  
       
    33.  
      int []b=new int[a.length+1];
    34.  
       
    35.  
      for(i=0;i<a.length;i++)
    36.  
      b[i+1]=a[i];
    37.  
       
    38.  
      for(i=2;i<=10;i++)
    39.  
      {
    40.  
      b[0]=b[i];
    41.  
      for(j=i-1;j>0;j--)//此处条件判断可直接换为b[0]<b[j]
    42.  
      if(b[0]<b[j])
    43.  
      b[j+1]=b[j];
    44.  
      b[j+1]=b[0];
    45.  
      }
    46.  
      for(i=0;i<a.length;i++)
    47.  
      a[i]=b[i+1];
    48.  
      show(a);
    49.  
      }
    50.  
       
    51.  
      public static void selectSort(int[] a) {
    52.  
      int i,flag,p,j,temp;
    53.  
      for (i = 0; i < 9; i++) {
    54.  
      flag = a[0];
    55.  
      p = 0;
    56.  
      for (j = 1; j < 9 - i; j++)
    57.  
      if (a[j] > flag) {
    58.  
      flag = a[j];
    59.  
      p = j;
    60.  
      }
    61.  
      if (a[p] > a[j]) {
    62.  
      temp = a[j];
    63.  
      a[j] = a[p];
    64.  
      a[p] = temp;
    65.  
      }
    66.  
       
    67.  
      }
    68.  
      show(a);
    69.  
      }
    70.  
       
    71.  
       
    72.  
       
    73.  
      public static void main(String args[]) {
    74.  
      int a[]= {9,8,7,6,5,4,3,2,1,0};
    75.  
      show(a);
    76.  
      System.out.println();
    77.  
      //bubbleSort(a);
    78.  
      //insertSort(a);
    79.  
      selectSort(a);
    80.  
      }
    81.  
      }

     

     

    ackage cn.csuft.poorguy.struct;
    
    public class quickSortText {
    	public static void main(String[] args) {
    		int[] arr = { 3, 4, 1, 2, 6, 9, 8, 5, 7 };
    		quickSort(arr, 0, arr.length - 1);
    		for (int i = 0; i < arr.length; i++) {
    			System.out.print(arr[i] + " ");
    		}
    	}
    
    	public static void quickSort(int[] arr, int left, int right) {
    		
    		//数组最左边小于最右边不合法,直接退出
    		if (left > right) {
    			return;
    		}
    		
    		//定义变量i指向最左边
    		int i = left;
    		
    		//定义变量j指向最右边
    		int j = right;
    		
    		//定义左边为基准元素base
    		int base = arr[left];
    
    		//只要i和j没有指向同一个元素,就继续交换
    		while (i != j) {
    
    			//从右向左寻找第一个小于基准元素的数
    			while (arr[j] >= base && i < j) {
    				j--;
    			}
    
    			//从左向右寻找第一个大于基准元素的数
    			while (arr[i] <= base && i < j) {
    				i++;
    			}
    
    			//执行到这里证明找到了i和j指向的元素
    			//交换i和j指向的元素
    			int temp = arr[i];
    			arr[i] = arr[j];
    			arr[j] = temp;
    		}
    
    		//将i和j共同指向的元素与基准元素交换
    		arr[left] = arr[i];
    		arr[i] = base;
    
    		//对左边进行快速排序
    		quickSort(arr, left, i - 1);
    		
    		//对右边进行快速排序
    		quickSort(arr, i + 1, right);
    	}

     

    手写快速排序(java实现)

    时间复杂度:

      O(nlogn)

    快速排序原理:

    1. 定义一个基准元素base(我这里定义的是最左面的元素定位基准元素)
    2. 定义两个变量i和j
    3. j先从右向左遍历,找到第一个比base小的数就停止
    4. i再从左向右便利找到第一个比base大的数停止
    5. 交换i和j指向的元素
    6. 直到i和j指向同一个元素,将这个元素与基准元素交换
    7. 递归求解即可

    图解:(排序过程)

     

    注意:

      上图为第一次快速排序的过程,递归过程和上图一致(没有给出)

     

    每一次的排序结果:

      现在在火车上没有给出具体每次排序结果,回学校补上.

     

    Java代码实现:

     
     
     
     
     
     

    手写快速排序(java实现)

    时间复杂度:

      O(nlogn)

    快速排序原理:

    1. 定义一个基准元素base(我这里定义的是最左面的元素定位基准元素)
    2. 定义两个变量i和j
    3. j先从右向左遍历,找到第一个比base小的数就停止
    4. i再从左向右便利找到第一个比base大的数停止
    5. 交换i和j指向的元素
    6. 直到i和j指向同一个元素,将这个元素与基准元素交换
    7. 递归求解即可

    图解:(排序过程)

     

    注意:

      上图为第一次快速排序的过程,递归过程和上图一致(没有给出)

     

    每一次的排序结果:

      现在在火车上没有给出具体每次排序结果,回学校补上.

     

    Java代码实现:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    package cn.csuft.poorguy.struct;
     
    public class quickSortText {
        public static void main(String[] args) {
            int[] arr = { 341269857 };
            quickSort(arr, 0, arr.length - 1);
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + " ");
            }
        }
     
        public static void quickSort(int[] arr, int left, int right) {
             
            //数组最左边小于最右边不合法,直接退出
            if (left > right) {
                return;
            }
             
            //定义变量i指向最左边
            int i = left;
             
            //定义变量j指向最右边
            int j = right;
             
            //定义左边为基准元素base
            int base = arr[left];
     
            //只要i和j没有指向同一个元素,就继续交换
            while (i != j) {
     
                //从右向左寻找第一个小于基准元素的数
                while (arr[j] >= base && i < j) {
                    j--;
                }
     
                //从左向右寻找第一个大于基准元素的数
                while (arr[i] <= base && i < j) {
                    i++;
                }
     
                //执行到这里证明找到了i和j指向的元素
                //交换i和j指向的元素
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
     
            //将i和j共同指向的元素与基准元素交换
            arr[left] = arr[i];
            arr[i] = base;
     
            //对左边进行快速排序
            quickSort(arr, left, i - 1);
             
            //对右边进行快速排序
            quickSort(arr, i + 1, right);
        }
    }
       
  • 相关阅读:
    mybatis源码解读(二)——构建Configuration对象
    mybatis源码解读(一)——初始化环境
    JDK1.8源码(七)——java.util.HashMap 类
    JDK1.8源码(六)——java.util.LinkedList 类
    JDK1.8源码(五)——java.util.ArrayList 类
    JDK1.8源码(四)——java.util.Arrays 类
    JDK1.8源码(三)——java.lang.String 类
    JDK1.8源码(二)——java.lang.Integer 类
    JDK1.8源码(一)——java.lang.Object类
    Java的深拷贝和浅拷贝
  • 原文地址:https://www.cnblogs.com/shan13936/p/13780043.html
Copyright © 2020-2023  润新知