double linked
#include <stdio.h>
#include <stdlib.h>
#define OR ||
typedef int element;
typedef struct doubleLinked {
element data;
struct doubleLinked* left;
struct doubleLinked* right;
}doubleLinked;
/*
| left | data | right |
*/
typedef struct node {
doubleLinked* head;
doubleLinked* tail;
int dataCnt;
}node;
/*
| head | tail |
*/
// --<< Function >>--
void setting_DoubleLinked_function(node* pointer); //[1]
void dataInsert_DoubleLinked_function(node* pointer); //[2]
void Printf_DoubleLinked_function(node* pointer);//[3]
void ReversePrintf_DoubleLinked_function(node* pointer);//[4]
void FirstData_Remove(node* pointer);//[5]
void LastData_Remove(node* pointer);//[6]
void FirstData_Plus(node* pointer);//[7]
int main(void) {
node start;
setting_DoubleLinked_function(&start);
dataInsert_DoubleLinked_function(&start);
dataInsert_DoubleLinked_function(&start);
dataInsert_DoubleLinked_function(&start);
dataInsert_DoubleLinked_function(&start);
dataInsert_DoubleLinked_function(&start);
dataInsert_DoubleLinked_function(&start);
dataInsert_DoubleLinked_function(&start);
dataInsert_DoubleLinked_function(&start);
dataInsert_DoubleLinked_function(&start);
dataInsert_DoubleLinked_function(&start);
dataInsert_DoubleLinked_function(&start);
Printf_DoubleLinked_function(&start);
FirstData_Remove(&start);//[5]
ReversePrintf_DoubleLinked_function(&start);
LastData_Remove(&start);//[6]
Printf_DoubleLinked_function(&start);
FirstData_Plus(&start);//[7]
Printf_DoubleLinked_function(&start);
return 0;
}
void setting_DoubleLinked_function(node* pointer) {//[1]
pointer->head = (doubleLinked*)malloc(sizeof(double));
pointer->tail = (doubleLinked*)malloc(sizeof(double));
if(pointer->head == NULL OR pointer->tail == NULL) {
printf("fail!!! \n");
return;//END
}else{//pointer->head !=NULL AND pointer->tail != NULL
pointer->head->data = 0;
pointer->head->left = NULL;
pointer->head->right = NULL;
pointer->tail->data = 0;
pointer->tail->left = NULL;
pointer->tail->right = NULL;
pointer->dataCnt = 0;
}
}
//double ------> | left | data | right |
void dataInsert_DoubleLinked_function(node* pointer) {//[2]
doubleLinked* newNode = NULL;
newNode = (doubleLinked*)malloc(sizeof(doubleLinked));
if(newNode == NULL){
printf("fail \n");
return;//END
}else{//newNode != NULL
newNode->left = NULL;
newNode->right = NULL;
newNode->data = 0;
printf("new data input >>> ");
scanf("%d", &newNode->data);
//|left|data|[right<---------> left]|data|[right<---------->left]|data|right|
if(pointer->dataCnt == 0) {
pointer->head->right = newNode;
newNode->left = pointer->head;
newNode->right = pointer->tail;
pointer->tail->left = newNode;
pointer->dataCnt ++;
}else{
//|left|data|[right<---------> left]|data|[right<---------->left]|data|right<------------->left]|data|[right]
pointer->tail->left->right = newNode;
newNode->left = pointer->tail->left;
newNode->right = pointer->tail;
pointer->tail->left = newNode;
pointer->dataCnt ++;
}
}
}
void Printf_DoubleLinked_function(node* pointer) {//[3]
doubleLinked* index_Node = NULL;
int i;
if(pointer->dataCnt == 0){
printf("data empty!! \n");
return;//END
}else{
index_Node = pointer->head->right;
for(i= 1 ; i<= pointer->dataCnt ; i++) {
printf("%d ", index_Node->data);
index_Node = index_Node->right;
}printf("\n");
}
}
void ReversePrintf_DoubleLinked_function(node* pointer) {//[4]
doubleLinked* index_Node = NULL;
int i;
if(pointer->dataCnt == 0){
printf("data empty!! \n");
return;//END
}else{
index_Node = pointer->tail->left;
for(i= 1 ; i<= pointer->dataCnt ; i++) {
printf("%d ", index_Node->data);
index_Node = index_Node->left;
}printf("\n");
}
}
//|left|data|[right<---------> left]|data|[right<---------->left]|data|right<------------->left]|data|[right]
void FirstData_Remove(node* pointer) {//[5]
doubleLinked* remove_node = NULL;
if(pointer->dataCnt == 0) {
printf("data is empty!! \n");
return;//END
}else{//pointer->dataCnt >=1
if(pointer->dataCnt == 1) {
remove_node = pointer->head->right;
pointer->head->right = NULL;
pointer->tail->left = NULL;
pointer->dataCnt --;
free(remove_node);
return;//END
}else{//pointer->dataCnt>1
remove_node = pointer->head->right;
pointer->head->right->right->left = pointer->head;
pointer->head->right = pointer->head->right->right;
pointer->dataCnt --;
free(remove_node);
return;//END
}
}
}
void LastData_Remove(node* pointer) {//[6]
doubleLinked* remove_node = NULL;
if(pointer->dataCnt == 0) {
printf("data is empty!! \n");
return;//END
}else{//pointer->dataCnt>=1
if(pointer->dataCnt == 1) {
remove_node = pointer->head->right;
pointer->head->right = NULL;
pointer->tail->left = NULL;
pointer->dataCnt --;
free(remove_node);
return;
}else{ // pointer->dataCnt >1
remove_node = pointer->tail->left;
pointer->tail->left->left->right = pointer->tail;
pointer->tail->left = pointer->tail->left->left;
pointer->dataCnt --;
free(remove_node);
return;//END
}
}
}
//|left|data|[right<---------> left]|data|[right<---------->left]|data|right|
void FirstData_Plus(node* pointer) {//[7]
doubleLinked* newNode = NULL;
newNode = (doubleLinked*)malloc(sizeof(doubleLinked));
if(newNode == NULL) {
printf("malloc fail !!! \n");
return;
} else {//newNode != NULL
newNode->left = NULL;
newNode->right = NULL;
newNode->data = 0 ;
printf("new data input >>> ");
scanf("%d", &newNode->data);
if(pointer->dataCnt == 0) {
pointer->head->right = newNode;
newNode->left = pointer->head;
newNode->right = pointer->tail;
pointer->tail->left = newNode;
pointer->dataCnt++;
}else{//pointer->dataCnt>=1
pointer->head->right->left = newNode;
newNode->right = pointer->head->right;
pointer->head->right = newNode;
newNode->left = pointer->head;
pointer->dataCnt++;
}
}
}
'언어 > c언어' 카테고리의 다른 글
| queue 다른버전 (0) | 2016.03.05 |
|---|---|
| c언어 행렬 구현 (0) | 2016.02.25 |
| QUEUE (0) | 2016.02.22 |
| STACK (0) | 2016.02.21 |
| queue (수정할것 아직 완성되지 않음) (0) | 2016.02.17 |
#include <stdio.h>
#include <stdlib.h>
typedef int element_type_int;
typedef struct queue{
element_type_int data;
struct queue* linked;
}queue, *queue_pointer;
typedef struct node{
queue_pointer head;
queue_pointer tail;
int dataCnt;
}node, *node_pointer;
//--------------- FUNCTION COMPLEX -------------------
void Queue_Setting(node_pointer NP);
void Queue_Data_Input(node_pointer NP);
void Queue_Data_Remove(node_pointer NP);
void Queue_Data_Printf(node_pointer NP);
int main(void)
{
node start;
Queue_Setting(&start);
Queue_Data_Input(&start);
Queue_Data_Input(&start);
Queue_Data_Input(&start);
Queue_Data_Input(&start);
Queue_Data_Printf(&start);
return 0;
}
//---------------------------------------------------
void Queue_Setting(node_pointer NP){
NP->head = (queue_pointer)malloc(sizeof(queue));
if ( NP->head == NULL ){
printf("malloc fail!!\n");
return;//END
}
else{ // NP->head != NULL
//------data setting-------------------
NP->head->data = 0;
NP->head->linked = NULL;
NP->tail = NP->head;
NP->dataCnt = 0;
//------------------------------------
}
}
void Queue_Data_Input(node_pointer NP){
queue_pointer newData_Node = NULL;
newData_Node = (queue_pointer)malloc(sizeof(queue));
if (newData_Node == NULL){
printf("malloc fail!!|\n");
return;//END
}
else{ //newData_Node != NULL
//----------- data setting ---------------
newData_Node->data = 0;
newData_Node->linked = NULL;
printf("newData input >>> ");
scanf("%d", &newData_Node->data);
//--------------------------------------
if (NP->dataCnt == 0){
NP->head->linked = newData_Node;
NP->tail = newData_Node;
NP->dataCnt++; // data +1
}
else{ // NP->dataCnt >=1
NP->tail->linked = newData_Node;
NP->tail = newData_Node;
NP->dataCnt++; // data +1
}
}
}
void Queue_Data_Remove(node_pointer NP){
queue_pointer remove_node = NULL;
if(NP->dataCnt == 0){
printf("data is empty !! \n");
return;//END
}
else{//NP->dataCnt >=1
if (NP->dataCnt == 1){
remove_node = NP->head->linked;
NP->head->linked = NULL;
NP->tail = NULL;
NP->dataCnt--; // dataCnt -1
free(remove_node);
}
else{// NP->dataCnt >1
remove_node = NP->head->linked;
NP->head->linked = NP->head->linked->linked;
NP->dataCnt--; // dataCnt -1
free(remove_node);
}
} }
void Queue_Data_Printf(node_pointer NP){
queue_pointer index_node = NULL;
int index;
if(NP->dataCnt == 0){
printf("data is empty !! \n");
return;//END
}
else{//NP->data
index_node = NP->head->linked;
for(index = 0; index< NP->dataCnt; index++){
printf("%d ",index_node->data);
index_node = index_node->linked;
}
}printf("\n");
}
'언어 > c언어' 카테고리의 다른 글
| c언어 행렬 구현 (0) | 2016.02.25 |
|---|---|
| double linked (0) | 2016.02.23 |
| STACK (0) | 2016.02.21 |
| queue (수정할것 아직 완성되지 않음) (0) | 2016.02.17 |
| Bubble__Sort (ver 0.1) 2016. 2. 17 kimjun hyeon (0) | 2016.02.17 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef int element;
typedef struct stack_type{
element data_type_integer;
struct stack_type* linked;
}StackType, *StackTypePointer;
typedef struct nodeType{
StackTypePointer Head;
StackTypePointer Top;
int dataCnt;
}nodeType, *nodeTypePointer;
//---- < FUNCTION > -----
void stack_setting(nodeTypePointer NTP);
void stack_data_input(nodeTypePointer NTP);
void stack_data_printf(nodeTypePointer NTP);
void stack_data_pop(nodeTypePointer NTP);
//---- < MAIN > ----
int main(void){
nodeType stack;
stack_setting(&stack);
stack_data_input(&stack);
stack_data_input(&stack);
stack_data_input(&stack);
stack_data_input(&stack);
stack_data_input(&stack);
stack_data_printf(&stack);
stack_data_pop(&stack);
stack_data_printf(&stack);
return 0;
}
//Func [1]
void stack_setting(nodeTypePointer NTP){
NTP->Head = NULL;
NTP->Head = (StackTypePointer)malloc(sizeof(StackType));
if (NTP->Head == NULL) {
printf("fail \n");
return;//END
} else {// NTP->Head != NULL
NTP->dataCnt = 0;
NTP->Head->data_type_integer = 0;
NTP->Head->linked = NULL;
NTP->Top = NTP->Head;
}
}
//Func [2]
void stack_data_input(nodeTypePointer NTP){
StackTypePointer newNode = NULL;
newNode = (StackTypePointer)malloc(sizeof(StackType));
if (newNode == NULL) {
printf("fail \n");
return;//END
} else {//newNode != NULL
//------- <- new data setting -> ---------------
newNode->linked = NULL;
newNode->data_type_integer = 0;
printf("data input >>> ");
scanf("%d", &newNode->data_type_integer);
//----------------------------------------------
}
if (NTP->dataCnt == 0) {
NTP->Head->linked = newNode;
NTP->Top = newNode;
NTP->dataCnt++; //---------------------------------- dataCnt +1
} else {//NTP->dataCnt >=1
NTP->Top->linked = newNode;
NTP->Top = newNode;
NTP->dataCnt++;//----------------------------------- dataCNt +1
}
}
//Func [3]
void stack_data_printf(nodeTypePointer NTP){
StackTypePointer index_ = NULL;
int index;
if (NTP->dataCnt == 0) {
printf("dataCnt Empty!!!\n");
return;//END
} else {//NTP->dataCnt>=1
index_ = NTP->Head->linked;
for(index = 0; index < NTP->dataCnt; index++){
printf("%d ", index_->data_type_integer);
index_ = index_->linked;
}printf("\n");
}
}
void stack_data_pop(nodeTypePointer NTP){
StackTypePointer remove_node = NULL;
StackTypePointer index_node = NULL;
if (NTP->dataCnt == 0) {
printf("data Empty!!");
return;//END
}else {//NTP->dataCnt != 0
//case1
if (NTP->dataCnt == 1){
remove_node = NTP->Head->linked;
NTP->Head->linked = NULL;
NTP->Top = NTP->Head;
NTP->dataCnt--;//--------------------------- dataCnt -1
free(remove_node);
}
//case2
else{//NTP->dataCnt >1
index_node = NTP->Head->linked;
while(index_node->linked != NTP->Top){
index_node = index_node->linked;
}NTP->Top = index_node;
remove_node = NTP->Top->linked;
free(remove_node);
NTP->dataCnt--;//--------------------------- dataCnt -1
}
}
}
'언어 > c언어' 카테고리의 다른 글
| double linked (0) | 2016.02.23 |
|---|---|
| QUEUE (0) | 2016.02.22 |
| queue (수정할것 아직 완성되지 않음) (0) | 2016.02.17 |
| Bubble__Sort (ver 0.1) 2016. 2. 17 kimjun hyeon (0) | 2016.02.17 |
| linkedList (수정) (0) | 2016.02.16 |
queue (수정할것 아직 완성되지 않음)
#include <stdlib.h>
#include <string.h>
typedef int element;
typedef struct queue
{
struct queue* linked;
element data;
}queue, *queuePointer;
typedef struct node
{
queuePointer head;
queuePointer top;
int dataCnt;
}node, *nodePointer;
//---------------------- function ----------------------
void queue_setting(nodePointer); //------------------>[1]
void enqueue_function(nodePointer);//---------------->[2]
void queue_printf(nodePointer);//-------------------->[3]
//------------------------------------------------------
int main(void) {
nodePointer queue_start;
queue_setting(&queue_start);
return 0;
}
////////////////////////////////////////////////////////
void queue_setting(nodePointer queue)//-------------->[1]
{
queue->head = (queuePointer)malloc(sizeof(queue));
if (queue->head == NULL) {
printf("malloc fail!!\n");
return;//END
}
else//queue->head !=NULL
{
queue->dataCnt = 0;
queue->head->data = 0;
queue->head->linked = NULL;
queue->top = queue->head;
}
}
////////////////////////////////////////////////////////
void enqueue_function(nodePointer queue)//----------->[2]
{
queuePointer new_Node = NULL;
new_Node = (queuePointer)malloc(sizeof(queue));
if (new_Node == NULL) {
printf("malloc fail!!\n");
return;//END
}
else {
//new_Node != NULL
// -------- < data setting > ----------
new_Node->data = 0;
new_Node->linked = NULL;
queue->dataCnt += 1; //----------------> +1
printf("new_Node data input >>> ");
scanf_s("%d", &new_Node->data);
// ------------------------------------
queue->top->linked = new_Node;
queue->top = new_Node;
}
}
////////////////////////////////////////////////////////
void queue_printf(nodePointer queue) {//------------->[3]
int index;
queuePointer index_node = queue->head->linked;
if (queue->dataCnt == 0) {
printf("queue is empty!!!\n");
return;//END
}
else {//queue->dataCnt >=1
for (index = 0; index < queue->dataCnt; index++) {
printf("%d ", index_node->data);
index_node = index_node->linked;
} printf("\n");
}
}
'언어 > c언어' 카테고리의 다른 글
| QUEUE (0) | 2016.02.22 |
|---|---|
| STACK (0) | 2016.02.21 |
| Bubble__Sort (ver 0.1) 2016. 2. 17 kimjun hyeon (0) | 2016.02.17 |
| linkedList (수정) (0) | 2016.02.16 |
| naver 지식인 (0) | 2016.02.15 |
Bubble__Sort (ver 0.1) 2016. 2. 17 kimjun hyeon
//bubble sort
//2016 2 17
//kim jun hyeon
//ver 1.0
#include <stdio.h>
#define SIZE 10
void bubble_sorting(int[]);
int main(void) {
int arr_int[SIZE] = { 0, }; // initiallize
int index;
for (index = 0; index < SIZE; index++) {
printf("arr_int[%d] data input >>> ", index);
scanf_s("%d", &arr_int[index]);
}
bubble_sorting(arr_int);
return 0;
}
void bubble_sorting(int arr[])
{
int indexI, indexJ, indexK;
int temp = 0;
for (indexI = 0; indexI < SIZE-1; indexI++){
for (indexJ = 0; indexJ <SIZE-1; indexJ++){
if (arr[indexJ] > arr[indexJ + 1]) {
temp = arr[indexJ];
arr[indexJ] = arr[indexJ + 1];
arr[indexJ + 1] = temp;
for (indexK = 0; indexK < SIZE; indexK++) {
printf("%d ", arr[indexK]);
}printf("\n");
}
}
}
for (indexK = 0; indexK < SIZE; indexK++) {
printf("%d ", arr[indexK]);
}printf("\n");
}
'언어 > c언어' 카테고리의 다른 글
| QUEUE (0) | 2016.02.22 |
|---|---|
| STACK (0) | 2016.02.21 |
| queue (수정할것 아직 완성되지 않음) (0) | 2016.02.17 |
| linkedList (수정) (0) | 2016.02.16 |
| naver 지식인 (0) | 2016.02.15 |
linkedList (수정)
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define OR ||
typedef int element;
typedef struct linkedList {
struct linkedList* linked;
element data_of_int;
}linkedList, *linkedList_Pointer;
typedef struct nodeType {
linkedList_Pointer head;
linkedList_Pointer tail;
int dataCnt;
}nodeType, *nodeType_Pointer;
// function
void linkedList_Setting(nodeType_Pointer start); //[1]
void linkedList_Data_Input(nodeType_Pointer start); //[2] +
void linkedList_Printf(nodeType_Pointer start); //[3]
void linkedList_First_Remove(nodeType_Pointer start); //[4] -
void linkedList_Last_Remove(nodeType_Pointer start); //[5] -
// ---------------- < MAIN > -------------------------------------
int main(void) {
nodeType start;
linkedList_Setting(&start);
linkedList_Data_Input(&start);
linkedList_Data_Input(&start);
linkedList_Data_Input(&start);
linkedList_Data_Input(&start);
linkedList_Data_Input(&start);
linkedList_Printf(&start);
linkedList_First_Remove(&start);
linkedList_Printf(&start);
linkedList_Last_Remove(&start);
linkedList_Printf(&start);
return 0;
}
// ---------------------------------------------------------------
void linkedList_Setting(nodeType_Pointer start) { //[1]
start->head = (linkedList_Pointer)malloc(sizeof(linkedList));
start->tail = (linkedList_Pointer)malloc(sizeof(linkedList));
if ((start->head == NULL) OR(start->tail == NULL)) return;//END
else { // start->head !=NULL AND start->tail != NULL
// ----- < node_initiallize > ------
start->head->linked = NULL;
start->head->data_of_int = 0;
start->tail->linked = NULL;
start->tail->data_of_int = 0;
start->dataCnt = 0;
}
}
void linkedList_Data_Input(nodeType_Pointer start) { //[2]+
linkedList_Pointer newNode = NULL;
newNode = (linkedList_Pointer)malloc(sizeof(linkedList));
if (newNode == NULL) return;//END
else { // newNode != NULL
//------------- node setting -------------
newNode->linked = NULL;
newNode->data_of_int = 0;
printf("new_Data input >>> ");
scanf_s("%d", &newNode->data_of_int);
//----------------------------------------
if (start->dataCnt == 0) {
start->head->linked = newNode;
start->tail->linked = newNode;
start->dataCnt += 1; //------------> +1
}
else {//--------------------------------> start->dataCnt >= 1
start->tail->linked->linked = newNode;
start->tail->linked = newNode;
start->dataCnt += 1; //------------> +1
}
}
}
void linkedList_Printf(nodeType_Pointer start) { //[3]
int index_i;
linkedList_Pointer index = start->head->linked;
if (start->dataCnt == 0) {
printf("data empty!!\n");
return;//END
}
else {//-------> start->dataCnt != 0
for (index_i = 0; index_i< start->dataCnt; index_i++) {
printf("%d ", index->data_of_int);
index = index->linked;
}printf("\n");
}
}
void linkedList_First_Remove(nodeType_Pointer start) { //[4] -
linkedList_Pointer remove_node = NULL;
if (start->dataCnt == 0) { //------------->[case1]
printf("data empty!!!\n");
return;//END
}
else if (start->dataCnt == 1) {//------>[case2]
remove_node = start->head->linked;
start->head->linked = NULL;
start->tail->linked = NULL;
start->dataCnt -= 1;//--------------------> -1
free(remove_node); // memory release
}
else //(start->dataCnt > 1) {//---------->[case3]
remove_node = start->head->linked;
start->head->linked = start->head->linked->linked;
free(remove_node);//--------------------->memory release
start->dataCnt -= 1;//--------------------> -1
}void linkedList_Last_Remove(nodeType_Pointer start)
{
linkedList_Pointer remove_node = NULL;
linkedList_Pointer index_node = NULL;
if (start->dataCnt == 0) { //------------->[case1]
printf("data empty!!!\n");
return;//END
}
else if (start->dataCnt == 1) {//------>[case2]
remove_node = start->head->linked;
start->head->linked = NULL;
start->tail->linked = NULL;
start->dataCnt -= 1;//--------------------> -1
free(remove_node);//--------------------->memory release
}
else {//(start->dataCnt > 1) {//--------->[case3]
int index;
index_node = start->head->linked;
for (index = 0; index < start->dataCnt - 1; index++) {
index_node = index_node->linked;
} remove_node = index_node->linked;
index_node->linked = NULL;
start->tail->linked = index_node;
start->dataCnt -= 1;////--------------------------> -1
}
}
'언어 > c언어' 카테고리의 다른 글
| QUEUE (0) | 2016.02.22 |
|---|---|
| STACK (0) | 2016.02.21 |
| queue (수정할것 아직 완성되지 않음) (0) | 2016.02.17 |
| Bubble__Sort (ver 0.1) 2016. 2. 17 kimjun hyeon (0) | 2016.02.17 |
| naver 지식인 (0) | 2016.02.15 |
#include <stdio.h>
#include <stdlib.h>
#define NAME_SIZE 20
#define TOTAL_EMPLOYEE 5
typedef struct {
char name[NAME_SIZE]; // name type string
double score; //score type double
int english_score; //english_score
}Employee;
void inclear(void){
int ch;
while((ch=getchar()) != EOF && ch != '\n');
}
void elite_sorting(Employee[]);
int main(void) {
Employee person[5];
int index;
for (index=0; index<TOTAL_EMPLOYEE; index++) {
printf("[%d person] name input >>> ", index+1); // name input
fgets(person[index].name, sizeof(NAME_SIZE), stdin);
printf("[%d person] score >>> ", index+1); // score double
scanf("%lf", &person[index].score);
printf("[%d person english_score]", index+1); // english_score
scanf("%d", &person[index].english_score);
inclear();
}
elite_sorting(person);
return 0;
}
void elite_sorting(Employee employee_person[]){
int index;
for(index=0; index<TOTAL_EMPLOYEE; index++)
{
printf("%lf \n",employee_person[index].score);
}printf("\n");
}
'언어 > c언어' 카테고리의 다른 글
| QUEUE (0) | 2016.02.22 |
|---|---|
| STACK (0) | 2016.02.21 |
| queue (수정할것 아직 완성되지 않음) (0) | 2016.02.17 |
| Bubble__Sort (ver 0.1) 2016. 2. 17 kimjun hyeon (0) | 2016.02.17 |
| linkedList (수정) (0) | 2016.02.16 |
