OSI 7 Layer

IT 2016. 8. 1. 15:47

OSI 7계층을 아주 간단히 정리하면 다음과 같다.

REF

 

7: Application Layer (응용 계층)

- 텔넷 등

 

6: Presentation Layer

- Encoding/Decoding 압축/암호화 등이 이루어지는 Layer이다.

 

5: Session Layer

- 운용 체제에서 다루어주는 TCP/IP 세션 생성 및 해제.

 

4: Transport Layer(트랜스포트 계층)

- 쉽게 TCP를 이용하는 계층이라고 보면 된다.

- End-to-End간 통신을 다루는 최하위 계층이다.

- 오류검출, 흐름제어, 중복검사 등이 이루어진다.

 

3: Network Layer

- IP와 라우팅 기반으로 데이타 통신이 이루어진다.

- 패킷 생성이 이루어지며, QoS관리 등이 이루어진다.

 

2: Data Link Layer (데이터 링크 계층)

- MAC Address 기반으로 통신을 하는 계층.

- CRC 체크등 에러체크 가 이루어 진다.  (+재전송/흐름제어)

 

1: Physical Layer(물리계층)

- H/W Layer로서 가장 복잡한 계층이다.

Posted by yongary
,

<Self-Balanced Tree>

B-Tree:      2개 이상의 child를 가짐..    


2-3 B-Tree   (I think - 2 max, 3 Node) 

        • Every non-leaf node has either 2 or 3 children.
        • All leaves are at the same depth.
        • Information (keys and associated data) is stored only at leaves

        • 부모는 leftMax, middleMax를 저장. (left children's Max, middle children's Max)

        • non-leaf nodes have 2 or 3 children (never 1 )

        • Insert Operations: (value k)
          (2가지 예외)
          - T is empty일 때, 싱글 node with k 생성. 
          - T is 1 node(m) 일 때 : (1 parent, 2 child node로)
                                       => 1.node(n)k포함 생성,  
                                            2.new 내부node (with n,m are child node) 생성
                                             + leftMax,middleMax 세팅.
          (general)
          - insert(T,k) 



ㅁ 2-3-4 Tree : 3개의 data와 4개의 child node를 가질 수 있다. 



<Self-Balanced Binary Tree>

Red-Black Tree: Ref1 ,  

root는 블랙노드

레드노드(temp노드)가 항상 블랙child를 가짐.
삽입시에 레드노드를 삽입하는데, 레드-레드 될 경우 회전으로 해결.


특징: 최장거리 노드도 최단거리의 2배가 이하임. 


AVL Tree:  Refwiki - Height balanced 이진트리 - 각 two child간의 depth가 1 밖에 차이가 안남.
      - depth가 좋으 므로 Red-Black Tree보다 탐색속도가 좋음.

- 특징: 4가지 회전 방식이 존재함 (할아버지 노드까지만 보면 됨)

   LL/RR은 한번만 회전.  LR/RL은 2번 회전. 


Splay Tree  

         - self balanced이면서 속도도 빠름.  이 역시 위 둘과 같이 회전으로 balancing. 

         - 최근 access한 값을 다시 access 할 수 있도록 배치.

  - cache나 gc에 자주 쓰임.

  - zig (parent  root, x is child) , zig-zig (p!=root, p,x 같은 방향), zig-zag (p!=root p,x다른 방향) case 존재.   

 

         

      [기본 회전 알고리듬] Ref

  Root Pv C A B

Pivot = Root.OS (O=Opposite side) Pivot설정. Root.OS = Pivot.RS (R= Rotate side) Pivot.RS를 1.detach Pivot.RS = Root Pivot.RS를 2.Set Root = Pivot Root설정.

   
회전시 left,right가 계속 바뀌므로 java reflection을 쓰면 좋을 것 같네요.
   left, right child를 이름으로  가져오게...  reflection REF

Class aClass = MyObject.class Field field = aClass.getField("someField"); //for node : MyObject node = new MyObject(); Object value = field.get(node); field.set(node, value);



<other tree>

Cartesian Tree ref1txt

 - Heap Tree와 비슷하게 min(or max)값이 제일 위에 있으나, complete tree가 아님.

 - 한번 구성하면 끝날 듯( self balanced가 아님)



KD Tree : k dimensional Tree이다. left-child에 tree하나, right-child에 tree하나 가 관리되는데..
                 recurive하게 여러개의 tree가 계속 관리될 수 있다. 



Huffman Tree: 압축알고리듬 허프만 코드- (확률빈도가 높은 char을 짧은 bit로 관리하는 코드 방식. )
                         를 생성할때 사용하는 binary Tree이다. 

                          왼쪽이 0, 오른쪽이 1 간단하다. 빈도수가 낮은것부터 밑에서 tree를 만든다. 





Heap Tree:  complete binary tree (즉  포화트리에서 마지막 자식은 왼쪽노드부터 채움)

  - heap Tree Java 알고리듬: 

k 의 parent는  k/2;    k의 2자식은  2k 와 2k + 1.  (array로 구현하고 첫자리를 비움. array size는 2^(h+1) 이 되겠죠.)


  최상위 root에는 최소값(Min Heap)이나 최대값(Max Heap)을 관리.

  - complete binary tree는 배열로 관리 가능함.  h로 관리되겠죠. 2^(h+1) -1 개가 max 노드개수임.  

  -Priority Queue 가 Heap으로 구현됨. (단, 이 때는 중복 허용)


  

insert: 일단 마지막 leaf에 넣고.. 자리바꾸기. 

  removeMax:  최상위 삭제하고, 마지막 leaft를 최상위로 배치.. (그 후 자리바꾸기)

  




Posted by yongary
,

enum

java core 2016. 7. 20. 17:38

java의 enum은 c처럼 간단한 enum기능에, 약간의 static class같은 기능이 추가되었다.

new를 해서 쓰지는 못하고, 상수에 value가 매핑되어 있는 형태로 사용가능하며

Serializable,Comparable, Runnable 모두 구현가능하다.

추가로 EnumSet, EnumMap도 있다. 


REF-SITE


1. 간단한 java enum:

enum Day { MONDAY, TUESDAY, WEDNESDAY }

==> 항상 이값으로만 사용가능.  c처럼 숫자로 자동 대체되지 않음.



2. enum에 value를 추가시:

enum Coin {

  PENNY(1), NICKLE(5), DIME(10), QUARTER(25);

  private int value;

 

  private Coin(int v){

 value = v;

  }

  public int getValue(){

 return value;

  }


  //참고: toString()오버라이드 안해도 PENNY찍힘.

  public String toString(){

 return super.toString()+":"+value;

  }

}


public class EnumTest {


public static void main(String args[]){

for(Coin c : Coin.values())

System.out.println(c.toString());  //오버라이드안하면 c = c.toString();


    //비교시

    if (c == Coin.DIME) { }

    if (c.getValue() == Coin.DIME.getValue()) { } 

}

}



3. enum에 value,color를 추가시:

enum Coin {

  PENNY(1,"gold"), NICKLE(5,"white"), DIME(10,"silver"), QUARTER(25,"silver");

  private int value;

  private String color;

 

  private Coin(int v, String c){

 value = v;

 color = c;

  }

}

Posted by yongary
,

java FP Ref_Site


 ::  (Double colon) : reduce에서 standard에 맞으면 사용할 수 있는 연산자.

      reduce( (int left, int right) -> Math.max(left, right) )  

     --> reduce(Math::max);   



List의 각 항목을 제곱해서 출력하기:

LinkedList<Integer> list = new LinkedList<Integer>();

list.add(0); list.add(10);list.add(2);

list.stream()

.map( i -> i*i )

.forEach(System.out::println);  //= forEach(i -> System.out.println(i));


Sum구하기:

int sum = list.stream()

   .reduce(0, (x,y) -> x+y );   //identity(sum variable), Operation


각항목을 제곱한 LinkedList 만들기

   LinkedList<Integer> list2 = 

list.stream()

.map( i -> i*i )

.collect(Collectors.toCollection(LinkedList::new));  //.collect(Collectors.toList());

Posted by yongary
,

 

http://bigocheatsheet.com/  참고

 

 

Merge sort(합병 소트):  O(nlogn)  단점 O(n)스페이스 필요.  Ref-Site

  - 반씩 분할하는 divide & conquer 소트의 일종.

  -  merge_sort (int[] arr, int low, int high) {

            int mid=0;

    if (low < high) {

        mid = (low+high) / 2;

        merge_sort(arr, low, mid);

        merge_sort(arr, mid+1, high);

        

        merge(arr, low, mid, high); // 이 안에서 스페이스 필요. 

    }

     }

  - qSort는 최악에 O(n^2)이지만 실제로는 평균적으로는 qSort가 20%정도 빠르다고 함.

     => qSort 최악의 경우:  pivot을 정할때.. pivot이 최대값이면..  글케 됨.

 

 

Radix sort(̧기수 정렬) :  Ref-Site

  - O(pN) 이며, 2^20(백만개)정도의 숫자를 소팅할때 16진수로 한다고 치면 4자리 수이므로
    4번 * N  정도로 할 수 있어  일반 정렬 O(n logn) =  O(n * 20) 보다 훨씬 빠른 경우가 발생한다.

 

 

 

Insertion Sort(삽입 정렬):  Ref-Site

 - O(N^2) 이지만 구현이 매우 간단하고,  길이가 짤을 때 속도가 좋고 안정적이라는 장점이 있다. 

 

c코드-참고 

void insertion_sort (int *data, int n ) { 
	int i, j, remember; 
    for ( i = 1; i < n; i++ ) { 
    	j=i; 
        remember = data[i]; 
        while ( --j >= 0 && data[j] > remember) 
        	data[j+1] = data[j]; //쭉 copy
            
        data[j+1] = remember; 
     }
 }

 

참고: 자바에서는 리스트의 기본 정렬 방식으로 

1) Merge Sort를 사용하거나 

2) tuned depending on the datatypes  Quick Sort를 사용 

+ 개체수가 7개 이하일 때 Insertion Sort 방식을 사용한다.

 

==============Data Structure=================

 

 

Heap:  complete binary tree (즉  포화트리에서 마지막 자식은 왼쪽노드부터 채움)

  최상위 root에는 최소값(Min Heap)이나 최대값(Max Heap)을 관리.

  - complete binary tree는 배열로 관리 가능함.  h로 관리되겠죠. 2^(h+1) -1 개가 max 노드개수임.

 

  -Priority Queue 가 Heap으로 구현됨.

  -median을 구하기에 가장 최적의 자료구조는

  바로
  Min Heap과 Max Heap을 동시에 하나씩 관리하는 것이다.

 

  예를 들어 100까지의 숫자가 있다면  Max Heap으로 50까지 관리하고,  Min Heap을 51부터 관리하면 
  median이 50 or 51 or 50.5 로 바로 구할 수 있다. 

 

 

Trie : REF2  Ref-Site   

    text 추천에 가장 많이 사용되는 변형된 Tree 로서, 마지막 노드에서만 숫자(접근빈도)를 관리한다.

    - 일반적으로 Root에는 데이타를 관리하지 않으며, mutliNary tree이다.
    - 마지막에 숫자를 관리하지 않아도 서치에는 유용하다. O(L)탐색, 생성은 O(M*L),  M은 단어수, L은 가장 긴 단어길이.

    

 

참고:

HashTable : O(1+N/B)  (B=bucket)

 

Posted by yongary
,

<Tree traverse>

java에서 binary tree는 간단히 node class로 구현이 된다.

그 후, traverse에는 2가지 방식이 있는데..

 

 

DFS: Depth First Search - 깊이 부터 서치하는 일반적인 방식.

이렇게 node로 구성된 BinaryTree 를 DFS로 traverse하는 방법에는 2가지가 있는데 

 

1. recursive   (좀 안좋은: 참고 )

       출력은: printInOrder(node) {
                        if (node!=null) {

                            printInOrder(node.left);

                            System.out.println(node.value);

                            printInOrder(node.right);
                        }      

 

2. loop 이용..    loop를 이용한 방법은 다음과 같다.  myREF  REF

 

    주로 stack이용.

 

BFS: Breadth First Search - 같은 depth에 있는 형제들 먼저 출력. (아래코드 참조) -Queue이용.

          q.add(root); 
          while (q.size() > 0) {
                node = q.poll();
                print ( node.value );
                if (node.left != null) q.add( node.left);
                if (node.right !=null) q.add (node. right);
           }

 

 

<Direct Graph Traverse>

 

Dijkstra :  Vertex(node)---edge--->  w 로 갈 때 각 Edge마다 Weight가 있는 경우, 적합.

 log(n^2)으로 vertex를 늘여가면서 가까운 Destination으로의 path를 찾아나간다.

핵심공식: distance[w] = min(distance[w], distance[u] + weight[u][w])

 

 

            (아래 표 참조 1에서 출발:)

           w    S               D(2)  D(3)  D(4)  D(5)

           1   S{1}            10    무한    30    100

           2   S{1,2}         10    60      30    100

 

   1에서 가까운 w를 하나씩 추가하면서 진행해 나가므로,  가까운 Vertex관리가 필요한데,

   A. (Linked)adjacent List 로 관리하거나

   B.  priority Queue로 관리할 수 있다.    (모든 Vertex에서 다해도 되지만, S 에 들어가는 거 위주로 해도 된다.)

 

 

 

BFS: tree에서 처럼 weight없이 탐색한다. 탐색방식은 Dijkstra와 근본적으로 같다.

 

 

 

<MST:min Spanning Tree>   REF

 

 

Prim 알고리듬:  O(n^2) => 보통 점만 주어질 땐,  link가 많으므로 이럴때 적합. 

  - 노드 하나를 기준으로  그 외부와 연결되는 가장 min 값을 연결한다.

  -  연결된 Set  과   그 외부 Set(외부를 전체 Set으로 보고) 또  가장 min 값을 연결한다.

   (구현이 간단함)


  내가 구현한 예제: disjointSet 이용.

더보기

 

int dist(int[] p1, int[] p2) {
        return Math.abs(p1[0] - p2[0]) + Math.abs(p1[1] - p2[1]);
    }

    class Node {
        int id; //1~5
        int dist;
        int pid1;
        int pid2;


        public Node(int pid1, int pid2,int id, int dist) {
            this.pid1 = pid1;
            this.pid2 = pid2;
            this.id = id;
            this.dist = dist;
        }
    }

    /** MAIN */
    public int minCostConnectPoints(int[][] points) {

        if (points.length <= 1 )  return 0;
        //4point case: 3*2 = 6개? (n-1!)

        int N = points.length;
        //20개 중 작은값 4개를 뽑아서 더하면 될듯. (단 이미연결된거 방지 체크)
        //int dists[] = new int[ N * (N-1)];

        PriorityQueue<Node> pq = new PriorityQueue<>(new Comparator<Node>() {
            @Override
            public int compare(Node n1, Node n2) {
                return n1.dist - n2.dist;
            }
        }
        );

        //10개 노드: 4 + 3+ 2+ 1
        int id = 0;
        for (int i = 0; i < N-1; i++) {
            for (int j = i+1; j < N; j++) {
                Node node = new Node( i, j, id++, dist(points[i], points[j]));
                pq.add(node);
            }
        }
        System.out.println( "Total NODE: :" + id);


        //필요 node는  (n-1)! -1 ///////////////////////
        int k = N - 1;


        int totDist = 0;

//        HashSet<Integer> hs = new HashSet<>();
        DjSet djSet = new DjSet(N);

        while (pq.size() > 0) {
            // while (k > 0) {
            Node node = pq.poll();
            System.out.println("node poll:" + k);

            //TODO check.
            if (!djSet.isConnected(node.pid1, node.pid2)) {

                //add node.pid1, node.pid2
                djSet.union(node.pid1, node.pid2);

                totDist += node.dist;
                k--;
            }
            //DjSet 도입이전 코드:  섬이 2개 생기면 이미 추가되어서 오류가 생김.
//            if ( !hs.contains(node.pid1) || !hs.contains(node.pid2)  ) {
//                //System.out.println(node.dist + "," + node.pid1 + "," + node.pid2 + ",");
//                hs.add(node.pid1);
//                hs.add(node.pid2);
//
//                totDist += node.dist;
//                k--;
//            }
        }

        return totDist;
    }

 


   구현에 DisjointSet(서로소 집합)과 union 이 필요할 것 같아서 링크 REF

 /////////// DjSet: find, union, isConnected ////////////////////////////
    class DjSet {

        int[] parent;
        int[] size;

        public DjSet(int n) {
            parent = new int[n];
            size = new int[n];
            for (int i = 0; i < n; i++) {
                parent[i] = i;
            }
        }

       
        //find parent //////////////
        int find(int x) { //union하면서 아직 update안된 parent들 udpate하면서 find
            if (parent[x] != x) {
                parent[x] = find(parent[x]); // 경로 압축: 부모를 찾아서 업데이트하면서 재귀적으로 호출
            }
            
            return parent[x];  // 노드 x의 부모 반환
        }

        boolean isConnected(int x, int y) {
            return find(x) == find(y);
        }

        void union(int x, int y) {
            int rootX = find(x);
            int rootY = find(y);

            if (rootX == rootY) return;

            if (size[rootX] > size[rootY]) parent[rootY] = rootX;
            else if (size[rootX] < size[rootY]) parent[rootX] = rootY;
            else {
                parent[rootY] = rootX;
                size[rootX]++;
            }

        }
    }


   구현에 DisjointSet(서로소 집합)과 union 이 필요할 것 같아서 링크 REF

 

Kruskal 알고리듬: O(eloge)    -  e 가 적당하다면 이 알고리듬이 훨씬 낫다. 

  - 일단 min Edge 들을 연결한다. (단 cycle이 안생기는 방식으로 연결)

 - 마지막엔   Set 과 Set 간 연결들이 필요.

 

 

<TSP: Travelling Salesman Problem>

모든 노드를 한번씩만 돌아서 다 돌때 최소 weight 찾는 문제로, 일반적으로 알고리듬이 없다. 

즉 모든 경우의 수를 다 해봐야 한다.  

 

 

 

 

   ====Tree BFS code  (순서없이 BFS Breadth First Search )======

위에 5줄이면 충분함.   detail을 포함한 세부구현은 아래 더보기 참조.

더보기
class Node{
    int value;
    Node left;
    Node right;

    public Node (){
        left=right=null;
    }

    public Node (int v){
        value = v;
    }
}

class Test {

    /* DFS */
    public void printInOrder(Node node){  //이함수는 DFS recursive test용 임.

        if (node != null){
            printInOrder(node.left);
            out(":" +node.value);
            printInOrder(node.right);
        }
    }
    
    /* simple class for Marking a New Line in the Queue
     */
    class NewLine extends Node{

    }
    
    /* print same depth nodes at the same line
     * @param binTree : root Node of binary Tree
     */
    public void printBFSTree(Node binTree){

        if (binTree == null) return;
        Queue<Node> queue = new LinkedList<Node>();
        
        queue.add( binTree );
        queue.add( new NewLine()); //depth seperator
        
        while (queue.size() > 0){

            Node node = queue.poll();
            
            if ( node instanceof NewLine) { //(Depth changed)
                System.out.println();   //print new Line
                if (queue.size() > 0)
                    queue.add(node);           //add NewLine for added sibling
            }else {                   //(general Node)
                //print Node's value
                System.out.print(node.value + " ");
            }
            
            if (node.left != null) {
                queue.add( node.left );
            }

            if (node.right != null) {
                queue.add( node.right );
            }
        }
    }
 

 

Posted by yongary
,

콤비네이션(C) 알고리듬 참조:  http://stackoverflow.com/questions/2201113/combinatoric-n-choose-r-in-java-math 

 

int nCk = 1;
       
for (int k = 0; k < K; k++) {
           
System.out.print(nCk + " ");
            nCk
= nCk * (n-k) / (k+1);
       
}

예) 5C3 =   5/1 * 4/2 * 3/3  =  10..

 

중복 콤비네이션(H) 참조: https://ko.wikipedia.org/wiki/%EC%A1%B0%ED%95%A9 

    개의 빈칸에 중복을 허용하여 개의 원소를 넣는 개수로 생각할 수 있다.?

      즉, 개의 칸막이를 두고 가지 경우를 임의의 순서로 배열하는 것.?

 

      nHk = (n+k-1)C(n-1) = (n+k-1)Ck

 

 

Posted by yongary
,

spring에서 bean은

Spring 2016. 6. 29. 16:48

spring에서 bean은 아무 생각없이 만들면

spring container에서 singleton 으로 만들어 준다.

(즉, 전체 sping container에서 항상 동일한 하나의 global instance로 bean을 만들어 준다)

 

따라서 immutable이고 status도 없이 만드는 것이 좋음.

 

만약, 다른 용도로 만드려면

 

Prototype Bean - 매번 생성

Session Bean  - WEB 세션별로 생성

Request  Bean - WEB Request별로 생성

이 존재하며..

 

 

@Component

@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)     과 같이 annotate 한다.

    - @Scope("prototype") 만 해도 되지만.. 위에 방식이 더 안전.

 

 

xml에서 할 경우에는
<baen id="note" class="my.Note" scope="prototype"> 으로 한다.




참고:  @Component는 autoscan이 되지만 @Bean의 경우에는 안되므로

@Bean을 직접 사용할 경우에는 method body에서 생성해서 return해야 한다.  REF


Posted by yongary
,

참고: java binarySearch예제

Comparator<Person> ageComparator = Comparator.comparingInt(Person::getAge);

int index = Arrays.binarySearch(people, new Person("Bob", 30), ageComparator);

(찾으면 >=0 못찾으면 -index-1 리턴)

 

 

아래는 없을땐 -1 리턴하는 java 코드들입니다.

 

<sort된 array내에서 exact매칭을 위한  BinSearch >

 

public int binSearch ( int A[],  int target ){

 

int low = 0;

int high = A.length -1;

int mid = 0;

 

while (low <= high ){

mid = (low+high)/2;

 

if       ( A[mid] < target)  low = mid+1;

else if ( A[mid] > target ) high = mid -1;

else 

return mid;

}

return -1;

}

 

<sort + rotate된 array내에서 exact매칭을 위한  BinSearch 
예) [4,5,6,7,8, 0,1,2,3] 에서 target이 2인경우 ==> 정 답: 7

public int search(int[] nums, int target) {
        int low = 0;
        int high = nums.length - 1;
        int mid = 0;

        while (low <= high) {
            mid = (low + high) /2;
            
            if (nums[mid] == target) return mid;
            
            //left half sorted
            else if (nums[low] <= nums[mid] ) {
                //target이 left 존재 (mid제외)
                if (nums[low] <= target && nums[mid] > target) {
                    high = mid - 1;
                } 
                else low = mid + 1;
            }
            //right half sorted
            else {
                //target이 right에 존재 (mid 제외)
                if (nums[mid] < target && nums[high] >= target )
                    low = mid + 1;
                else
                    high = mid - 1;     
            }
        }
        return -1;
    }

 

 

<LE를  위한  BinSearch >  : LE - lessthan or Equal을 만족하는 최대 index 리턴.  

 

// A:{1,2,5, 9, 10}, target:7 =>   index:2 return이 목표.

public int binSearchLE ( int A[],  int target ){    

int low = 0;

int high = A.length -1;

int mid = 0;

 

while (low <= high) {

mid = (low+high)/2;

 

if       ( A[mid] < target)  low = mid+1;

else if ( A[mid] > target ) high = mid -1;

else 

return mid;

}

 

if ( mid>0 ) {   

if (A[mid] < target )    //LE CHeck

return mid;

 

if (A[mid] > target && A[mid-1] < target ) 

return mid-1; 

}

if (mid==0){  //mid가 0일경우는 어떡하나?

if (A[0] < target) return 0;

}

 

return -1;

}

 

   ======> 마지막 2개의 if를 간단히 3줄로도 줄일 수 있음.

if (arr[mid] < target) return mid;

else if (mid > 0 && arr[mid] > target && arr[mid-1] < target)
return mid -1;

 

//// low,high trace ///////////////////////

0,4 -> mid:2   if

3,4 -> mid:3   else_if

3,3 -> (mid:3) else_if

=> low,high가 마지막 loop이므로 이때 one more check가 필요. 

   return -1;  

 

 

 

<GE를  위한  BinSearch >  : GE - grea than or Equal을 만족하는 최소 index 리턴. 

 

// A:{1,2,5, 9, 10}, target:7 =>   index:3  return이 목표.

public int binSearchGE ( int A[],  int target ){    

int low = 0;

int high = A.length -1;

int mid = 0;

 

while (low <= high) {

mid = (low+high)/2;

 

if       ( A[mid] < target)  low = mid+1;

else if ( A[mid] > target ) high = mid -1;

else 

return mid;

}

 

if ( mid < A.length-1 ) {  

      if ( A[mid] < target &&  A[mid+1] > target ) 

return mid+1;

 

if  (A[mid] > target )  //GE CHeck

return mid;

 }

 

if (mid==A.length-1){  //?

if (A[mid] > target) 

return (A.length-1);

}

return -1;

}

 

//// low,high trace ///////////////////////

0,4 -> mid:2   if

3,4 -> mid:3   else_if

3,3 -> (mid:3) else_if

=> low,high가 마지막 loop이므로 이때 one more check가 필요. 

   return -1;  

Posted by yongary
,

java 에서  int 와 double이 default 이다.


따라서


long 이나, float를 선언할 때는 주의 해야 하는데



long sum =2147483648;     //에러

    =>  long sum=2147483648L;  //근데 작은값 들은 자동으로  문제 없는것 같긴 하다.


float f = 23.1

   => float f = 23.1f; 


로 고쳐주어야 한다. (L,f는 대소문자는 상관없다)





array의 경우도

float[] a = new float[] {-1.3f, -4.5f} ; //이런식으로 해야  컴파일 에러가 안난다.

                      


< int +int => long>

  int a; int b; 

  a + b > c   하려면  a+ (long)b > c 로 해야지  좌변이 long으로 정확히 비교된다.

Posted by yongary
,

jvm & GC

java core 2016. 6. 6. 17:19

<참고사이트1>  <참고사이트2>

 

 

<메모리 분류>

  Young Gen  ( Eden ,  From, To)

            

  Old Gen  

 

  Perm Gen  :  static Object, Constant String,  Meta  가 저장되는데  GC가 되지 않는 영역이라서

                    메모리부족을 일으키는 요인 중 하나였는데,     JDK1.8 에서는 제거되었다..    Meta->native로,  static,String -> Heap으로 이동.

 

 

 

 

 <GC> minor GC 하다가 모자라면   Old로 promotion 하고.. 그래도 부족하면  Major GC or Full GC를 하게된다.

 

       1. minor GC (young GC) 가 할당된 survivor영역이 꽉차면 발생.

          Young Gen에서  unReferrence된  Object들을   GC하면서 

                => 비어있는 survivor영역으로 이동.  (공간부족시 Old영역으로 이동)

 

          from<->to 를 몇번(tenuringThreshold) 왔다갔다하면서도 살아남은 애들은 Old Gen 으로  옮긴다.
                                       

                                             CMS:Concurrent Mark & Sweep

        - Old GC (major GC) = parallel GC +  CMS GC + G1 GC  + (serial GC, parallel GC, parallel Comacting GC)  REF

           혹자는 Major GC=Full GC로 부르므로, 가능하면 Major GC란 용어는 사용하지 말자.

          

        2. Magor GC: 1 이후  CMS GC 가 일어나는데..
          CMS GC가  Old영역을 Compaction하지 않고 (즉, fragment를 해결하지 못하고) 따라서,  

          Full GC (전체 Heap clean) 를 유발: 즉, fragment가 많으면 Compaction(조각모음)도 수행한다.  ---> 이 때, STW 발생. '

                a. from, to 의 size를 늘이거나

                b. tenuringThreshold를 늘여서 old로 잘 안보내거나,  

                c. CMS 의 동작을 좀 빨리하도록 해서 compaction이 덜 일어나게 하거나??  (XX:CMSInitiatingOccupancyFraction)

          해서 해결한다. 

 

참고: Major GC vs Full GC - Full GC 는 전체 Heap을 clean .. Ref

 

        3.  old 나  Perm영역이 부족하면  Full GC가 일어나고, 
             이 대, 
 fragment가 많으면 Compaction(조각모음)도 수행한다.  ---> 이 때, STW 발생.         

                      혹자들(한국사이트들)은 old Generation이 꽉차면 이라고도 하는데.. 머 주로 compaction시 이것도 같이 발생할 것으로 보인다.


               

 

        

java 1.8 에서 permGen이 없어진 대신 metaSpace라는게 생겼다.
 metaSpace는 클래스Loader가 로드한 클래스들의 metaData과 관리되는 곳.
기존의 permGen은 Heap에서 관리했으나,  metaSpace는 native memory영역에서 관리함.
==> 그러므로 application이 STW할 확률은 낮아졌으나, OS전체 메모리가 부족할 수도 있으므로 --XXMetaSpace등으로 사이즈 조절필요.    참고: REF

 

Posted by yongary
,

XML XSD와 DTD와 차이.

IT 2016. 5. 28. 10:15

참고사이트: http://www.scitech.co.kr/upload/book_image/s_017/Xml04.pdf 


<DTD>


 <!DOCTYPE Memo [

    <!ELEMENT Memo (PInfo, MInfo)>

    <!ELEMENT PInfo (from, to)>

    <!ELEMENT MInfo (date, main)>

    <!ELEMENT form (#PCDATA)>

    <!ELEMENT to (#PCDATA)>

    <!ELEMENT date (#PCDATA)>

    <!ELEMENT main (#PCDATA)>

]>



     DTD를 이용한 XML:  REF사이트



<XML XSD> : XML Schema Definition.


<?xml version="1.0" encoding="EUC-KR"?>

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"

targetNamespace="http://www.lisia.net"

xmlns="http://www.lisia.net"

elementFormDefault="qualified">


<xsd:element name="Memo">

 <xsd:complexType>  

  <xsd:sequence>

    <xsd:element name="PInfo">

    <xsd:complexType>

     <xsd:sequence>

       <xsd:element name="from type="xsd:string"/>

       <xsd:element name="to" type="xsd:string"/>

   </xsd:sequence>




==> XSD 를 이용한  XML   

 

<?xml version="1.0" encoding="EUC-KR"?>

<Memo xmlns="http://www.lisia.net" 

              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 

              xsi:schemaLocation="http://www.lisia.net ex4_3.xsd"> 

<PInfo>

     <from>김광수</from>

     <to>박수란</to>

</PInfo>

   

Posted by yongary
,

List

scala 2016. 5. 11. 09:07

특성

1. immutable    (Array는 mutable)

2. recursive 지원 (Arrary는 미지원)

3. covariant  -   if S is subtype of T이면   List[S]도 List[T]의 subtype.

     =>  이로 인해, List() (List[Nothing])  이 List[S나 T]의 subtype 이 된다.

 

head와 tail

  - head는 첫 아이템이고 tail은 나머지 모든 아이템.

 

List 생성

 $ val abc: List[String] = List("a","b","c")

 $ val fruit = "ora" :: "pea" :: "apples" :: Nil     (이 경우에는 Nil이 꼭 필요)

 

패턴지정 (위에서 fruit가 지정되어 있는 경우)

 $ val List(a,b,c) = fruit     이런형태로 지정해서 a,b,c 를 자동 입력도 가능 (a="ora"가 됨)

 

:: (cons 연산자)

 - scala내의 class로도 존재하고, List내의 method로도 존재.

   (class로 존재하기 때문에  x :: xs 가 ::(x,xs) 로 취급됨.

 

 

 

 

 

Posted by yongary
,

(싱글턴) Object

scala 2016. 4. 22. 18:29

scala 싱글턴 Object  (즉, 키워드 object)

는 2가지 용도로 쓰인다.




1.  Companion Object

- scala class에는 static 함수를 포함할 수 없기 때문에, class 와 동일한 Object 이름을 이용해서

static 함수를 모아 놓는다. 


class A(msg:String){

   def greet() = println(msg)

}


object A{

  def trim(s:String) = s..blabla

}



2. stand-alone Object.    

 - 이건 제일 자주보는 main을 포함하기 위한 용도이다.

object myApp {

  def main( args: Array[String]) {

     

  }

}


Posted by yongary
,

1. Nil은  List 가   비어있을 때.를 Nil이라고 한다.

$ val a=List()

$ a==Nil      ==>    true 임.



2. Nothing은 최하위 class 이다.  

  아래 예제에서 else 경우에 Nothing이 리턴된다. (Int 의 Subtype이므로 리턴 가능.) 


  def divide(x:Int, y:Int) :Int =  if (y!=0) x/y  else error("hi Error")

   


    =>  이경우에 Nothing이...   인터프리터에서 돌려보니 deprecation 된 거 같기도 한데.. (추가 확인 필요) 



3. Null은 기존 java Null 하고 비슷하니 개념은 잠시 잊어도 되겠다.



<Hierarchy>

java.lang.Object 에 해당하는 건  scala.AnyRef 이다.



Scala에선 Any가 최상위 클래스 이고..

data Type 들은 왼쪽 AnyVal 트리를 타게 되므로..

아래 계층도와 같다.


            Any

          /     |    

AnyVal   AnyRef

      |         |

Type들    AnyObject

      |         |

      |       Null 

      |        /

     Nothing



Posted by yongary
,

함수 정의 def 예제

scala 2016. 4. 22. 17:40

 ($: scala line interpreter 라고 치고.....)


기본 def:

$def h(x:String):Type = { println(x)}


1. 한 줄 일때는 curly brace 생략 가능

$def  h() = println("hi")

$def  h = println("hi")    (이것도 동일 동작.)


  => 이 때 아무동작 안하는 듯한 return type은 Unit이라고 부름 (java 의 void 와 비슷)


2. retrurn Type은 보통 안 붙여도 자동추론 하지만. recursive일 때는 꼭 필요.




3. def this     :    추가 생성자용도이다.   (overloaded constructor or Auxilary constructor 라고 부른다) 

   primary 생성자는 자동생성되므로..아래 예제처럼 추가 생성자를 생성할때  this함수와 함께 사용할 수 있다.

   

 class Test( msg:String, count:Int) {


    def this (msg:String ) = this (msg,1)


 }    


Posted by yongary
,

scala 실행

scala 2016. 3. 16. 09:33

  hello.scala 내용:  println(" Hello world")


1. hello.scala와 같은 script 작성 후  


$ scala hello.scala 로 실행 .



2. class나 object .scala작성후


$scalac co.scala

$scala co   

하면 되는데


scalac 보다 빠른 fsc (fast scala compiler)가 존재한다.

차이점은 fsc는 항상 메모리에 띄워 놓고, scalac은 JVM을 그 때 그때 띄우게 되는데..

따라서 fsc를 죽이고 싶다면 

$ fsc co.scala

$ scala co 

$ fsc - shutdown  으로 죽이면 된다.

Posted by yongary
,

class

- java의 class와 동일하다고 보면 되나, primary 생성자는 없다.

- primary 생성자는 class Dog(legs:Int, name:String){ } 로 정의에서 끝난다.

=> legs,name은 val로 자동생성된다.

- primary생성자의 body는 class 안에 아무데나 쓰면 된다.

- overload 생성자는 def this(legs:Int)와 같은식으로 명시하면 된다.


object

- companion object와 stand_alone object 가 존재한다.

- companion object는 java의 static함수를 모아놓은 것이라고 생각하면 된다.
  동일한 이름의 class가 존재한다.

- stand alone object는 독립적으로 존재하는데 보통
  def main(args:Array[String]) {  } 을 포함하는 용도로 사용된다. 


trait

- java의 interface와 유사하다고 보면되나, implements 키워드 대신 항상 extends키워드를 쓴다.

- method를 구현할 수 있다. (java Interface도 원래는 abstract함수만 되나, 1.8부터 body구현 지원)

- 인스턴스 생성시에 with 키워드로 바로 적용이 가능하다. (복잡하겠군요.. 인스턴스마다 다른 특성을 지니겠네요)


- extends Trait  해서 함수 오버라이드 시에..  def 앞에 override 키워드 꼭 필요.




class 인스턴스의 접근성

- class Dog{ var sum=0 }  일 경우 val a = new Dog 이 안됨.  단 var a일 경우.. a.sum+=1 은 됨.  

- class Dog{ private sum=0} 일 경우 val a = new Dog이 됨. s.sum +=1 이 안됨.

  

def의 접근성. =이 type을 의미함.

scala> def h = {"hello"}    h는 hello String 리턴.

scala> def g {"hello"}    g는 리턴없음. 즉 Unit리턴.

scala> def f:Unit = "hello"    g와 동일. 

Posted by yongary
,

scala Collections

scala 2016. 3. 15. 17:16

Array: mutable이고  java와 달리, (0),(1)로 마치 함수호출 하듯이 element get함.


List : immutable이고 동일한 type을 보관

tuple: immutable이고 서로 다른 type의 데이타를 저장할 수 있다. 


HashSet, HashMapt: mutable   (Set,Map은 trait임)

예) val s = new HashSet[String] 

    s += "AA"

예) val m = new HashMap[Int, String]

    m += (1 -> "Go to Hell") 


<immutable Set/Map> - factory method방식으로 이용가능.

    예) val s = Set("A", "BB", "CC")            : compoiler transfers as Set.apply()

   예) val s = Map(1 -> "AA", 2->"BB")       : compoiler transfers as Map.apply()




요약하면 immutable List,Tuple,  Set,Map이 존재한다.



Posted by yongary
,

System.in 및 File IO

scala 2016. 3. 7. 11:13

1. io.Source.stdin 이용    REF-SITE

   for (ln <- io.Source.stdin.getLines) println(ln)  

   (참고: break나 return이 잘 안되서 study 중 )


  1.5 위에서 stdin = fromInputStream(System.in)으로 def(ine)되어 있다. 따라서 아래처럼 변형도 가능

    val input = Source.fromInputStream(System.in);

   val lines = input.getLines.collect


2. System.in 에서 읽기

=> readLine()함수가 system.in에서 바로 라인을 읽는다.

끝나면 null을 리턴하므로 체크 필요.

object SysteminTest {
  def main(args: Array[String]) {

var line = true
do {
var str = readLine() //depricated..
if (str!=null) println(str)

else line=false //need test..
} while ( line )

} }



2. File에서 읽기

Line을 읽어서 String으로 만드는데,  empty Line을 공백" " 으로 처리하는 방법.

val file = Source.fromFile(args(0)).getLines().filter(!_.isEmpty()).mkString(" ")

Posted by yongary
,

DB with anorm

scala 2016. 3. 2. 16:58

scala에서 DB를 연동할 때, JDBC를 직접 사용할 수도 있지만

Play Framework와 함께 할때는 Anorm을 사용하는 방법이 편리하다.


REF-SITE :play



사용모습을 보면 아래와 같다.



(예제: 출처 https://janhelwich.wordpress.com/tag/anorm/ )

object Post{
  val parser = {
      get[String]("title") ~
      get[Date]("posted") ~
      get[String]("content")~
      get[Pk[Int]]("authorId") map {
      case title ~ posted ~ content ~ author => Post(title,  posted, content, User.findBy(author))
    }
  }
 
  def findAll() = {
    DB.withConnection {
      implicit connection =>
        SQL("select * from posts").as(parser *)
    }
  }
 
  def create(post: Post): Unit = {
    DB.withConnection {
      implicit connection =>
        SQL("insert into posts(title, posted, content, authorId) values ({title}, {posted}, {content}, {authorId})").on(
          'title -> post.title,
          'posted -> post.posted,
          'content -> post.content,
          'authorId -> post.author.id
        ).executeUpdate()
    }
  }


Posted by yongary
,

Anonymous class

java core 2016. 2. 26. 21:50

java의 abstract class 나 interface가  instance 화가 될 수 있냐? 고 질문한다면

답은  1. 일반적으론 안된다.  

          2. 그렇지만 anonymous class 방식으로는 된다. REF(Runnable 참조)

       이렇게 둘 다 답하면 best 이다.

 

참고로 
 abstract class : 추상 method가 하나이상 존재--> 상속시 추상 method구현을 강제함.
 Interface : 추상 method만으로 이루어진 class   but jdk1.8에서는  구현된 method도 허용함.  

     REF-SITE:

Posted by yongary
,

[char array->String]

char cArr[] ;  

String s = String.valueOf(cArr);

 

 

 

 

1. Array에 특정한 Object가 있는지 Check:


Arrays.asList(yourArray).contains(yourValue)

Warning: this doesn't work for arrays of primitives (see the comments).


2. LinkedList 에서 삭제 및 data Set.

Size()가 변하는 loop안이라면 Iterator를 사용하여 삭제하는 게 안전.

아니면 뒤에서부터 앞으로 Loop돌면서 삭제. (테스트 필요)

 

Iterator<String> iter = list.iterator();
while (iter.hasNext()) {  
     String s = iter.next(); //꼭 next먼저 호출.
     if (s.equals("a"))  iter.remove();  //원래 remove는 가장최근 return()한 걸 삭제하는 이상한 함수임.
}


ListIterator의 경우에는 iter.set() 함수도 매우 쓸만하다. //이 역시, 가장 장최근 return()한 걸 치환.


3. LinkedList  에 특정위치에 data 넣고 싶을때?

    LikedList<String> list = new LinkedList<String>();

    list.add("a");list.add("c");


    <a,c사이에 b를 넣고 싶으면>

    list.add(1,"b");   // index를 이미 안다면,  방법을 쓰거나..

    list.add ( getIndex("a")+1, "b"); //모른다면.. 이방법. 근데이게 getIndex가 속도가 의심이 됨..  

     최상의 방법은? 뭘까요?  
     자가 List라면  node.next.next = node.next;  node.next = new Node(); 하면 되는데.. 
     

     이런방법 없을까요?


     

      

     

      

    

    


Posted by yongary
,

Java memory 사용량.

java core 2016. 2. 23. 23:50
public static void main(String[] args) {

    long used1 = memoryUsed();
    int[][] array = new int[200][2];

    long used2 = memoryUsed();
    int[][] array2 = new int[2][200];

    long used3 = memoryUsed();
    if (used1 == used2) {
        System.err.println("You need to turn off the TLAB with -XX:-UseTLAB");
    } else {
        System.out.printf("Space used by int[200][2] is " + (used2 - used1) + " bytes%n");
        System.out.printf("Space used by int[2][200] is " + (used3 - used2) + " bytes%n");
    }
}

public static long memoryUsed() {
    Runtime rt = Runtime.getRuntime();
    return rt.totalMemory() - rt.freeMemory();
}
출처: stackoverflow peter lawrey 


Posted by yongary
,

/*

usage: 

MyJson mj = new MyJson(aLineString);   // {"key1:value1","key2:value2"} 

        String offTime = mj.get("key1") ;

*/



class MyJson{

private HashMap<String, String> hm = new HashMap<String,String>();

public MyJson(String json){

String normal = json.replaceAll("[{\"}]", ""); //remove {,", }

System.out.println("(normal)"+normal);

String[] kvset = normal.split(",\\s*");  // comma + (*:space exist or not)

for( String s : kvset){

String kv[] = s.split(":");

if( kv.length==2)

hm.put(kv[0], kv[1]);

else{

System.err.println("Json Parse err(may have only key) "+s);

}

}

}

public String get(String key){

return hm.get(key);

}

}

Posted by yongary
,

=============My BucketSort. Example===================

 

import java.util.HashMap;
import java.util.LinkedList;
import java.util.ListIterator;



public class BucketSort {

private HashMap<Integer, LinkedList> hMap;
/*
input: unSorted Array, #bucket(number of Bucket)
process: bucket sorting Using #bucket
return: sorted Array.
*/
public Integer[] bucketSort(Integer data[], int numBucket){
Integer[] ret = new Integer[data.length];
hMap = new HashMap<Integer, LinkedList>();



for (int i: data) {
Integer key = numBucket * (i / numBucket); //분모가 maxInt 가 맞을듯.(16.6)

==> 그냥 i%numBucket가 맞을 듯한데.. 좀더 보자.(2017.10)

LinkedList<Integer> prevList;



//make new List and add to HashMap.. when there's no data
if ( (prevList = hMap.get(key)) == null ) {
LinkedList<Integer> list = new LinkedList<Integer>();
list.add(i);
hMap.put(key,list);
}else{ //prevList traverse and add i to apporate position
ListIterator<Integer> it = prevList.listIterator();

boolean added = false; //added flag prevents Concurrent Modify Error.
while (it.hasNext()) { //at least 1 element. SO always on this loop.
if (it.next() > i ) { //Add to Proper position
prevList.add(it.previousIndex(),i);
added = true;
break;
}
}
if (!added)
prevList.add(i); //Add to End

}//else
} //for



//to array.
int k=0;
for (int j=0; j< numBucket; j++){
Integer key = numBucket*j;
LinkedList<Integer> list = hMap.get(key);

if (list!=null) {
ListIterator<Integer> it = list.listIterator();

while (it.hasNext())
ret[k++] = it.next();
}
}

return ret;
}

/////////MAIN /////////////////
public static Integer datas[]={77, 11, 22, 55, 44, 33, 99, 88, 21, 23, 37, 41, 81, 91, 74, 19, 30, 40 };

public static void main(String args[]){

BucketSort b = new BucketSort();
Integer[] data = b.bucketSort(datas, 10);

for ( int i : data)
System.out.print(i+",");
}
}


Posted by yongary
,

Quick Sort using java Generic.

==>   <T extends Comparable> working. <T implements Comparable> not working.

 (Java Generic을 이용해서 Quick Sort를 구현하여보았는데..

            ==>  <T extends Comparable> 이건 동작하는데 <T implements Comparable>은 동작하지 않음)

public class QSortGen<T extends Comparable> {  


void swap(T data[], int i, int j){
T tmp = data[i];
data[i]=data[j];
data[j]=tmp;
}

public void qSort( T[] data, int st, int end){
if (st == end || end < 0) return;

T pivot=data[end]; //Pivot is End (temporary)

int j=end-1;
int i=0;
while (i<j) {
while ( i<j && data[i].compareTo(pivot) < 0 ) i++;
while ( j>i && data[j].compareTo(pivot) > 0) j--;
if (i < j)
swap(data, i, j);
};

System.out.println( "new Pivot:" +i + ","+j);

//IF pivot Largest ?
if ( j == end-1 && data[j].compareTo(pivot) < 0 ) // (j == end-1) =>sometimes wrong. when only 3 data.
qSort(data, 0, end-1);

//General pivot
else {
swap(data, i ,end); //i is real Pivot
qSort(data, 0, i-1); //left divide and conquer:recursive
qSort(data, j+1, end); //right divide and comquer:recursive
}
}

/////////MAIN /////////////////
public static String datas[]={"adf", "kk", "bb", "aa", "dd", "cc", "ff" };

public static void main(String args[]){
QSortGen<String> q = new QSortGen<String>();
q.qSort(datas, 0, datas.length-1);

for( String a : datas)
System.out.println(a);
}
}


Posted by yongary
,

Scala OO Example

scala 2016. 2. 1. 10:52

Scala를 이용해서 OO를 TEST.

(OO Test using Scala)

object Seminar{


class Dog(a:Int, n:String){
var age:Int = a
var name:String = n

def feed()={
println(this.name+ ":eating dog food")
}
}


class Cat(a:Int, n:String) extends Dog(a:Int, n:String){
override def feed()={
println(this.name+ ":eating Cat food")
}
}


//////// MAIN ////////////////////////////////////////////////
def main(args:Array[String]) = {
var allDog:Array[Dog] = Array( new Dog(1,"dogA"),
new Dog(2,"dogB"),
new Dog(3,"dogC"),
new Dog(4,"dogD"),
new Cat(5,"catA"))


for( dog<- allDog)
dog.feed()

}
} //end
Posted by yongary
,

Quick Sort (java)

algorithm & type 2016. 1. 31. 00:34

[int Array기반 간단한 QuickSort]

- http://www.algolist.net/Algorithms/Sorting/Quicksort 참고.

=>c++ 코드 참조하면.. 한번소트 후에, 끝나면 i가 j보다 크군요..

(j=2, i=3) 이때, j포함 왼쪽. i포함 오른쪽 돌려야 함.

public void quickSort(int arr[], int left, int right) { int i = left, j = right; int tmp; int pivotValue = arr[(left + right) / 2]; /* partition */ while (i <= j) { while (arr[i] < pivotValue) i++; while (arr[j] > pivotValue) j--; if (i <= j) { tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp; i++; j--; } }; /* recursion */ if (left < j) quickSort(arr, left, j); if (i < right) quickSort(arr, i, right); } public static void main(String args[]){ SortSearch s = new SortSearch(); int A[] = new int[] {9,8,7,6,5,4,3,2,1}; s.quickSort(A, 0, A.length-1); for (int a : A){ System.out.println(a); }

}




-----------아래 건은 연습용------------------

[Simple Quick Sort Example.. with String Array]

- using End element as a temporary Pivot.


 

public class QuickSort {


void swap(String data[], int i, int j){
String tmp = data[i];
data[i]=data[j];
data[j]=tmp;
}

public void qSort( String[] data, int st, int end){
if (st == end || end < 0) return;

String pivot=data[end];
//Pivot is End (temporary)

int j=end-1;
int i=0;
while (i<j) {
while ( i<j && data[i].compareTo(pivot) < 0 ) i++;
while ( j>i && data[j].compareTo(pivot) > 0) j--;
if (i < j)
swap(data, i, j);
};

System.
out.println( "new Pivot:" +i + ","+j);

//IF pivot Largest ?
if ( j == end-1 && data[j].compareTo(pivot) < 0 ) // (j == end-1) =>sometimes wrong. when only 3 data.
qSort(data, 0, end-1);

//General pivot
else {
swap(data, i ,end);
//i is real Pivot
qSort(data, 0, i-1); //left divide and conquer:recursive
qSort(data, j+1, end); //right divide and comquer:recursive
}
}

/////////main
public static String datas[]={"adf", "kk", "bb", "aa", "dd", "cc", "ff" };
public static void main(String args[]){
QuickSort q =
new QuickSort();
q.qSort(
datas, 0, datas.length-1);

for( String a : datas)
System.
out.println(a);
}
}


Posted by yongary
,

일반적으로 정렬 중에 가장 빠른 알고리듬은 quick sort로서 O(N*logN)의 평균속도를 가지고 있다.

 

하지만, 분포가 어느정도 균등한 자료의 경우

버킷 소트를 하게 되면 O(n)으로 정렬을 할 수 있다.

 

Hash의 개념을 사용하게 되며..  그림은 REF-SITE  참조.

 

 

단점: 버킷을 미리 만들어 둬야 하므로 메모리 소비가 좀 있고

그 외 최악의 속도는 O(n)*버킷내 정렬시간 이 되므로 O(n**2)까지도 갈 수 있다.

(어차피 quick sort도 O(n**2)까지 갈 수 있으므로.  자료가 적당하다면 일반적으로 quick sort보다 속도는 좋은 것 같다 ).

Posted by yongary
,