'Algorithm'에 해당되는 글 18건

  1. 2015.05.03 이진 탐색트리 삽입
  2. 2015.05.03 이진 탐색트리 개념
  3. 2015.04.23 quick sort 나누는 부분 성공
  4. 2015.04.22 Binarysearch
  5. 2015.04.21 merge sort의 합병 부분
  6. 2015.04.15 bubble sort
  7. 2015.04.14 selection sort
  8. 2015.04.14 insert sorting

클래스 두개로 구성  

1. Node 클래스 --   1.값을 담을수 있는 변수  ex) int value= 0 ; 

   --   2.왼쪽 노드의 주소값을 담을 수 있는 변수  ex) Node leftNode=null;

   --  3. 오른쪽 노드의 주소값을 담을 수 있는 변수 ex)Node rightNode=null;

public class Node {

int value=0;

Node leftNode=null;

Node rightNode=null;

public int getValue() {

return value;

}

public void setValue(int value) {

this.value = value;

}

public Node getLeftNode() {

return leftNode;

}

public void setLeftNode(Node leftNode) {

this.leftNode = leftNode;

}

public Node getRightNode() {

return rightNode;

}

public void setRightNode(Node rightNode) {

this.rightNode = rightNode;

}

}

2. Tree 클래스 -- 삽입 하는 실제 함수를 구현한 곳 

--오버로딩 이용  1 .addnode(int value) root값이  없는 경우  

 2. addnode( int value , Node root) root 값이 존재 하는 경우 




public class Tree {


Node rootNode=null;

public void addNode(int value){

// root 값이 없는 경우 

if(rootNode==null){

Node n=new Node();

n.setValue(value);

rootNode=n;

}else{// root 값이 있는경우 

addNode(value , rootNode );

}

}

public void addNode(int value , Node rootNode){

// root 값보다 작은 경우   

if(rootNode.getValue()>value){

// root의 왼쪽 노드가 없는경우 

if(rootNode.getLeftNode()==null){

Node n = new Node();

n.setValue(value);

rootNode.setLeftNode(n);

}

else {// root의 왼쪽노드가 있는경우 

addNode(value, rootNode.getLeftNode()); // 다시 이함수를 호출해서 더 깊이 들어가는 부분이고 root는 root의 왼쪽 노드 

}

}else{//root 값보다 큰경우 

// root의 오른쪽 노드가 없는 경우 

if(rootNode.getRightNode()==null){

Node n = new Node();

n.setValue(value);

rootNode.setRightNode(n);

}

else{// root의 오른쪽 노드가 있는경우 더 깊이 들어가야한다 

addNode(value, rootNode.getRightNode());

}

}

}

public static void main(String[] args) {

Tree t = new Tree();

t.

}

}




'Algorithm' 카테고리의 다른 글

이진 탐색 순회 소스  (0) 2015.05.03
이진 탐색 순회 개념  (0) 2015.05.03
이진 탐색트리 개념  (0) 2015.05.03
quick sort 나누는 부분 성공  (0) 2015.04.23
Binarysearch  (0) 2015.04.22
Posted by 이상욱1
,



참조 사이트 http://marobiana.tistory.com/81  잘나옴 

이진트리 개념 

1.자식 노드가 최대 두개의 노드를 지니고있급니다.

2. 자식노드가 존재 안 할수도 있습니다.

3.왼쪽 자식 노드 또는 오른쪽 자식 노드만 있을 수 도 있습니다.

4. 왼쪽 오른쪽 자식노드가 전부 존재 할 수 도 있습니다.

5.핵심 개념 - 왼쪽 자식노드는 부모 노드보다 작고  오른쪽 자식 노드는 부모노드 보다 커져야 한다 .


위트리는 맨 밑 노드(리프노드)를 제외한 모든 각 노드가 자식노드를 2개씩 

갖고있는데 이런트리를 완전트리라고 한다.

 

완전 트리가 아니더라도 자식노드가 2개 이하면 이진트리이다 아래와 같은 트리도 

이진 트리이다 .




문제 : 트리에 넣을 숫자들을 입력 받아 이진탐색트리를 만들어라.


위에서 이진탐색트리에 대한 정의를 설명한 것과 같이, 

숫자를 입력받고, 왼쪽엔 작은수, 오른쪽엔 큰 수를 넣는 것으로 흘러갈 것이다.


그런데 가만보면 왼쪽엔 작은수, 오른쪽엔 큰 수를 넣는 것   <= 요것이 반복되고 있다.

반복되는 것은? 재귀를 사용할 수 있다는 뜻이다.


흐름을 정리해보면 다음과 같다.


1) Root에 값이 없으면 Root에 값을 넣는다.

2) Root에 값이 있으면, 

   입력된 값이 Root보다 크면 오른쪽에 넣고, 작으면 왼쪽에 넣는다.

3) 오른쪽 혹은 왼쪽에 값이 이미 들어있으면,

    입력된 값과 비교해서 크면 오른쪽에 넣고, 작으면 왼쪽에 넣는다.

4) 오른쪽 혹은 왼쪽에 값이 이미 들어있으면,

    입력된 값과 비교해서 크면 오른쪽에 넣고, 작으면 왼쪽에 넣는다.

..... 



확실히 반복되는 흐름을 볼 수 있다.

우리는 반복되지 않는 1,2번을 코드로 만든 후 3번 이후를 재귀 호출 시키면 된다.


'Algorithm' 카테고리의 다른 글

이진 탐색 순회 개념  (0) 2015.05.03
이진 탐색트리 삽입  (0) 2015.05.03
quick sort 나누는 부분 성공  (0) 2015.04.23
Binarysearch  (0) 2015.04.22
merge sort의 합병 부분  (0) 2015.04.21
Posted by 이상욱1
,


public class Quicksort {


public static void main(String[] args) {

/*int arr[]={11,22,3,4,8,9,5,6,15,12,7};*/

int arr[]={11,22,3,4,6,15,12,7};

int pivot=arr.length-1;

int start=0;

int end=pivot-1;

while(start<=end){

if(start==end){

int tmp=0;

tmp=arr[start+1];// 이게 pivot의 오른쪽으로 정렬한것들중에 가장 왼쪽 아이 

arr[start+1]=arr[pivot];

arr[pivot]=tmp;

break;

}

/*if(arr[end]<arr[pivot]&&arr[start]>arr[pivot] || arr[end]>arr[pivot]&&arr[start]>arr[pivot]){// 둘다 큰경우가 없다 

int tmp =0; // 큰것들끼리 서로 교환하고 앞으로 한칸 가는경우 가서 결국엔 ij 만나면 큰애들은 다 정렬이 안됨 

tmp=arr[start];

arr[start]=arr[end];

arr[end]=tmp;

start++;

end--;

}

else if(arr[start]<arr[pivot]&& arr[end]<arr[pivot]){

start++;

}*/

if(arr[end]>arr[pivot]){

end--;

}

else if( arr[start]<=arr[pivot]){

start++;

}

int tmp =0; // 큰것들끼리 서로 교환하고 앞으로 한칸 가는경우 가서 결국엔 ij 만나면 큰애들은 다 정렬이 안됨 

tmp=arr[start];

arr[start]=arr[end];

arr[end]=tmp;

}

for(int i=0; i<arr.length; i++){

System.out.print("arr[]="+arr[i]);

}

}

}






참조 사이트  http://blog.naver.com/PostView.nhn?blogId=comthird&logNo=220066947945



1. 퀵 정렬(Quick Sort)이란

 

C. A. R. Hoare가 개발한 정렬 방법으로, 다음과 같은 순서로 수행되는 정렬 알고리즘이다.

 

① 정렬할 리스트에서 피벗(pivot)을 선택한다.

② 피벗을 기준으로 하여 피벗의 왼쪽은 피벗보다 작거나 같고 피벗의 오른쪽은 크거나 같은 리스트로 분류한다.

③ 피벗에 의해 분리된 두개의 좌우 리스트를 서로 독립적으로 퀵 정렬한다.

 

 

2. 특징

 

퀵 정렬은 불안정적인(unstable) 정렬 방법으로, 다른 항목들과의 비교 연산만으로 정렬을 수행하는 비교 정렬에 속한다. 또한 위에서 설명하였듯이 분할 해결 전략(divide and counquer)을 사용하는 알고리즘이다.

 

 

3. 자바(java)로 구현

 void quickSort(int[] list, int left, int right) 

 {

 int pivot, i, j, temp;

 if (left < right) 

 {

 i = left;

 j = right;

 pivot = list[left];                                         //피벗은 정렬 대상 리스트의 left로 한다.

 

 while (i < j) 

 {

 while (list[j] > pivot)                          //피벗보다 큰 값은 오른쪽

 j--;

 while (i < j && list[i] <= pivot)             //피벗보다 작은 값은 왼쪽

 i++;

 

 temp = list[i];                                   //왼쪽에 있는 피벗보다 큰 값과

 list[i] = list[j];                                 //오른쪽에 있는 피벗보다 작은 값을

 list[j] = temp;                                   //서로 자리 변경한다.

 }

 

 list[left] = list[j];                                      //j값은 피벗보다 작은 값 중에서 가장 오른쪽에 있는 값

 list[j] = pivot;                                           //left와 j값을 서로 자리 변경함으로써

      //j에 피벗이 위치하게 된다.

 quickSort(list, left, j - 1);

 quickSort(list, j + 1, right);

 }

 }

 

 

4. 시간 복잡도

 

퀵 정렬에서 최선의 경우란 피벗(pivot)으로 항상 정렬 대상 리스트의 중간 값이 선택되는 경우이다. 이 경우 피벗에 의해 분리된 두개의 리스트는 길이 차가 1이하가 되므로 시간 복잡도는 O(n log n)이 된다. 최악의 경우는 피벗에 의해 분리되는 두개의 리스트 중 하나의 리스트의 길이가 항상 1이 되는 경우이다. 피벗이 정렬 대상 리스트의 최소값이나 최대값이 항상 선택되어 분리가 불균형적으로 이루어지는 경우일 것이다. 이 경우 시간 복잡도는 O(n^2)가 된다. 평균적으로 퀵 정렬의 시간 복잡도는 O(n log n)으로 알려져 있다.

 

 

5. 퀵 정렬의 개선 1 - 세 값의 메디안을 사용한 퀵 정렬

 

위에서 설명한 퀵 정렬은 항상 현재 정렬 대상 리스트의 첫 번째 레코드를 피벗(pivot)으로 선택한다는 것을 알 수 있다. 이러한 방법보다 더 좋은 결과를 얻을 수 있는 방법이 있는데, 현재 정렬 대상 리스트의 첫 번째, 중앙, 마지막 값 중에서 메디안을 피벗으로 선택하는 방법이다. 즉 pivot = median { K_l, K_(l+r)/2, K_r } 이다.

 

 

6. 퀵 정렬의 개선 2 - 일정 크기 이하에서 삽입 정렬의 사용

 

삽입 정렬(삽입정렬로 가기)은 그 단순성 때문에 일정 크기 이하 (n<=30)에서 가장 빠른 정렬 방법으로 알려져 있다. 이러한 특징을 이용하여 퀵 정렬의 수행에서 정렬 대상 리스트의 크기가 일정 크기(n=30)보다 작은 경우 퀵 정렬이 아닌 삽입 정렬로 정렬을 수행하면 성능을 개선할 수 있다.

 

 

7. 퀵 정렬 프로그램 작성

 

위에서 배운 내용을 참고하여 입력 리스트를 파일로 입력 받아 이를 퀵 정렬한 후 내용을 출력해주는 프로그램을 작성해보자. 정렬 항목은 자연수라고 가정한다.

 

① 입력 파일 : input.txt

 

첫번째 줄에는 리스트의 크기,

두번째 줄에는 리스트의 내용, 각 숫자는 공백으로 구분한다.

 

ex)

10

4 27 8 11 76 43 15 1 89 16

 

② 출력 형식

 

- 파일로부터 입력 받은 리스트의 내용을 출력

 

 ex)

입력 리스트 ( n = 10 )
4 27 8 11 76 43 15 1 89 16

 

- 퀵 정렬의 각 패스 결과를 출력

 

 L과 R은 각각 퀵 정렬 함수 호출시 넘겨운 인수 left와 right의 값을 의미한다.

 

ex)

퀵 정렬 시작
i 0  1  2  3   4   5  6  7   8  9   L  R
  1  4  8 11 76 43 15 27 89 16   0  9
  1  4  8 11 76 43 15 27 89 16   2  9
  1  4  8 11 76 43 15 27 89 16   3  9
  1  4  8 11 16 43 15 27 76 89   4  9
  1  4  8 11 15 16 43 27 76 89   4  7
  1  4  8 11 15 16 27 43 76 89   6  7
퀵 정렬 종료

 

- 퀵 정렬 결과 리스트 출력

 

 ex)

정렬 결과
1 4 8 11 15 16 27 43 76 89

 

③ 자바(java)로 구현 (소스 코드는 첨부 파일 참조)

프로그램은 크게 입력 파일 읽는 부분, 퀵 정렬하는 부분, 결과 출력하는 부분으로 크게 나눌수 있는데 코드 자체가 간단하므로 각 부분에 대한 설명은 생략한다.

 

④ 결과 화면 캡쳐


'Algorithm' 카테고리의 다른 글

이진 탐색트리 삽입  (0) 2015.05.03
이진 탐색트리 개념  (0) 2015.05.03
Binarysearch  (0) 2015.04.22
merge sort의 합병 부분  (0) 2015.04.21
bubble sort  (0) 2015.04.15
Posted by 이상욱1
,

Binarysearch

Algorithm 2015. 4. 22. 09:01

import java.util.Scanner;


//이진검색(BinarySearch) 또는 이분검색 :

//정렬된 상태 에서 원하는 원소를 찾는 알고리즘

//중앙의 원소를 기준으로해서 찾는값이 더 크면 오른쪽을 탐색하고 더 작으면 왼쪽을 탐색함

//( 정렬이되있으므로 중앙을 기준으로 오른쪽 왼쪽을 나눌수있는 것 이다.)


public class Binarysearch {



public static void main(String[] args) {

int arr[]={1,2,3,4,5,6,7,8,9};

System.out.println("찾을 데이터:");

Scanner sc = new Scanner(System.in);

int searchkey=sc.nextInt();

int low=0;

int high=arr.length-1;

boolean flag=false;

int midresult=0;

while(low<=high){

int mid=(low+high)/2;//arr.length 이걸로 줘서 에러났었음 

if(arr[mid]==searchkey){

flag=true;

System.out.println("찾음 "+mid);

midresult=mid;

break;

}

if(searchkey>mid){

low=mid+1;

}else {

high=mid-1;

}

}

if(flag){

           System.out.println(searchkey+"를 "+midresult+"번째 위치에서 찾았습니다.");

       }else{

           System.out.println("찾지 못했습니다.");

       }      

}

}



'Algorithm' 카테고리의 다른 글

이진 탐색트리 개념  (0) 2015.05.03
quick sort 나누는 부분 성공  (0) 2015.04.23
merge sort의 합병 부분  (0) 2015.04.21
bubble sort  (0) 2015.04.15
selection sort  (0) 2015.04.14
Posted by 이상욱1
,

http://blog.naver.com/PostView.nhn?blogId=javaking75&logNo=140176260475&parentCategoryNo=&categoryNo=&viewDate=&isShowPopularPosts=false&from=postView 

참조사이트


public class Mergefunction {


public static void main(String[] args) {

int arr[]={4,2,8,5 };

int arrlen=arr.length;

int brr[]= {3,1,15,14,11,7,6};

int brrlen=brr.length;

int merge[]= new int [arr.length+brr.length];

for(int i=0 ; i<arr.length-1;i++){

for(int j=0; j<arr.length-1;j++){

if(arr[j]>arr[j+1]){

int tmp = 0;

tmp=arr[j];

arr[j]=arr[j+1];

arr[j+1]=tmp;

}

}

}

for(int i=0 ; i<brr.length-1;i++){

for(int j=0; j<brr.length-1;j++){

if(brr[j]>brr[j+1]){

int tmp = 0;

tmp=brr[j];

brr[j]=brr[j+1];

brr[j+1]=tmp;

}

}

}

int i =0 ,  j =0 , k=0 ; // i 는 first인덱스 j는 second index k는 merge index

// 돌아가면서 순서대로 k는 늘어나면서 정렬해서 넣어진다 

while(i<arrlen && j<brrlen){

if(arr[i]<=brr[j]){// arr [i]가 brr[j]보다 작은경우

merge[k++]= arr[i++];

}

else{

merge[k++]=brr[j++];

}

}

while(i<arrlen){ // 저위에서 빠져나와서 i가 정렬 안된경우 

merge[k++]=arr[i++];

}

while(j<brrlen){// 저위에서 빠져나와서 j 가 정렬 안된경우 

merge[k++]=brr[j++];

}

for(int p=0; p<merge.length;p++){

System.out.print(merge[p]+",");

}

}

}

/* for(int i=0;i<arr.length;i++){

System.out.print(","+arr[i]);

}


for(int i=0;i<brr.length;i++){

System.out.print(","+brr[i]);

}정렬됬고 */



'Algorithm' 카테고리의 다른 글

quick sort 나누는 부분 성공  (0) 2015.04.23
Binarysearch  (0) 2015.04.22
bubble sort  (0) 2015.04.15
selection sort  (0) 2015.04.14
insert sorting  (0) 2015.04.14
Posted by 이상욱1
,

bubble sort

Algorithm 2015. 4. 15. 13:43

결과값은 정렬되는데  count가 다도는데 마치 아래는 다 안도는거 같아서 뭔가 찝찝하다 

나중에 다시 알아보자 




/*1. 인접한 두 인덱스를 비교해서 정렬이 되어있지 않을경우 정렬한다.


2. 리스트 처음부터 끝까지 이런식의 정렬을 하고 나면 제일 마지막 리스트에는 제일 큰 값(또는 작은 값)이 저장된다.


3. 다시 처음 리스트부터 마지막 리스트 이전 리스트까지 서로 이웃한 인덱스를 비교해가며 정렬한다.


4. 위 방법으로 계속해서 정렬한다.*/




public class Bubblesort {


public static void main(String[] args) {

int arr[]={4, 3, 12 , 5 , 2 , 1 , 8 ,9};

int count=0;

for(int i=0;i<7;i++ ){

for(int j=0; j<7 ; j++){

count++;

if(arr[j] >arr[j+1]){

int tmp =0;

tmp=arr[j];

arr[j]=arr[j+1];

arr[j+1]=tmp;

}

}

}


for(int i=0;i<8;i++ ){

System.out.println("arr[i]="+arr[i ]);


}

System.out.println(count);

}

}











Bubble Sort


 먼저, 버블 정렬의 원리를 보도록 하자.



위와 같이'4, 2, 8, 11, 7' 5개의 원소를 버블 정렬로 정렬시키는데 한번에 4번씩 비교하고 2회전을 걸쳐 완성되었다.

총 8번의 비교를 하였다.


>> 소스보기 

'4, 54, 2, 8, 63, 7, 55, 56' 8개의 원소로 버블정렬을 이용하여 정렬시키기.  

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
public class BubbleSort {
 
    public static void main(String[] args) {
 
        int[] data = { 4, 54, 2, 8, 63, 7, 55, 56 };
        int temp;
        int cnt = 0;
         
        System.out.print("======정렬 전===============\n");
        for(int m=0; m<data.length; m++) {
            System.out.print(data[m] + ", ");
             
        }
         
        for(int i=data.length; i>0; i--) {
            //
            for (int j=0; j<i-1; j++) {
                cnt++;
                if(data[j] > data[j+1]) {
                    temp = data[j];
                    data[j] = data[j+1];
                    data[j+1] = temp;
                }
            }
        }
         
        System.out.print("\n\n======Bubble Sort=========\n");
        for(int k=0; k<data.length; k++) {
            System.out.print(data[k] + ", ");
             
        }
        System.out.println("\n\n 총 회전 수 : " + cnt);
    }
}



>> 결과보기



완성!!!!!!!!!!!!!!!!!!!



'Algorithm' 카테고리의 다른 글

quick sort 나누는 부분 성공  (0) 2015.04.23
Binarysearch  (0) 2015.04.22
merge sort의 합병 부분  (0) 2015.04.21
selection sort  (0) 2015.04.14
insert sorting  (0) 2015.04.14
Posted by 이상욱1
,

selection sort

Algorithm 2015. 4. 14. 23:17


public class SelectSort {


public static void main(String[] args) {

int arr [ ]={9, 7, 5, 3,11,2,14};

for (int i=0 ; i<6 ; i++){

for(int j=i+1; j<6; j++){

if(arr[i]>arr[j]){

int tmp=0;

tmp = arr[i];

arr[i]=arr[j];

arr[j]=tmp;

}

// i는 0부터 시작해서 가장 처음 부분  그리고 

// j는 

//i가 0일때 j=1 i의 0자리를 j의 1부터 쭉  비교하고 전체와 비교 

//배열의 가장 작은것은 i의 0에 저장한 후 i의 1로 넘어간 후 i의 1을 j의 2 부터 쭈욱 비교한후 

}

}

}

}



'Algorithm' 카테고리의 다른 글

quick sort 나누는 부분 성공  (0) 2015.04.23
Binarysearch  (0) 2015.04.22
merge sort의 합병 부분  (0) 2015.04.21
bubble sort  (0) 2015.04.15
insert sorting  (0) 2015.04.14
Posted by 이상욱1
,

insert sorting

Algorithm 2015. 4. 14. 23:15

/*삽입 정렬은 동작 방식은 매우 간단하다. 

우선 첫번째 원소 arr[0]를 '정렬이 되었다.' 라고 본다. 

그 뒤 인덱스를 하나 증가시킨 후 원소를 비교하게 되는데 만약 arr[1]의 원소가 arr[0]의 원소보다 작다면 swap 과정이 일어나고 

다시 arr[0],arr[1]는 '정렬되었다.' 라고 본뒤 인덱스를 하나 증가시키며 이러한 과정을 배열의 마지막 원소까지 반복하면 정렬이 된다.

*/




public class Insertsorting {


public static void main(String[] args) {

int arr [ ]={9, 7, 5, 3,11,2,14};

for (int i =0; i<7; i++){

//System.out.print(arr [i]);

for (int j =i+1 ; j<7 ; j++){// insert sorting 은  비교 기준이 2번째 부터 시작한다 

if(arr[i]>arr[j]){

int tmp=0;

tmp=arr[i];

arr[i]=arr[j];

arr[j]=tmp;

//   3인덱스와 2인덱스를 비교해서 3인덱스가 작은경우

// 2인덱스에 3인덱스꺼를 넣어주고 

if(i >= 1){

if(arr[i-1]>arr[i]){ // 3인덱스를 2인덱스 옴겼는데  2인덱스가 1인덱스보다 큰경우 

int swp=0;

swp= arr[i-1];

arr[i-1]=arr[i];

arr[i]=swp;

}

}

}

}

System.out.print(arr [i]+",");

}

}

}



'Algorithm' 카테고리의 다른 글

quick sort 나누는 부분 성공  (0) 2015.04.23
Binarysearch  (0) 2015.04.22
merge sort의 합병 부분  (0) 2015.04.21
bubble sort  (0) 2015.04.15
selection sort  (0) 2015.04.14
Posted by 이상욱1
,