• Code is clearer and easier to use
• The code can be much shorter, and easier to read

• It can be hard to find bugs~ particularly when using global variables
• It takes quite a bit of practice to get used to
• Space~ not too big a problem in modern technology, but any local variables within the function have to be created over and over again
• Time~ the operations which affect the space often affect the time of the method

void recursiveTriangle(int x) {
    if (x == 0) return; // do nothing else
    for (int i = 0; i < x; i++)
        cout << "*";
    cout << endl;
    recursiveTriangle(--x);
}

public static void recursiveTriangle(int x) {
    if (x == 0) return; // do nothing else
    for (int i = 0; i < x; i++)
        System.out.print("*");
    System.out.print("\n");
    recursiveTriangle(--x);
}

/*
 * @params: String directory ~ the directory to scan
 * @params: DefaultMutableTreeNode parent ~ the node to add any files as children
 * @params: Boolean recursive ~ determine whether to scan all subdirectories, or just the parent
 */
public static void listAllFiles(String directory, DefaultMutableTreeNode parent, Boolean recursive) {
	File [] children = new File(directory).listFiles(); // list all the files in the directory
	for (int i = 0; i < children.length; i++) { // loop through each
		DefaultMutableTreeNode node = new DefaultMutableTreeNode(children[i].getName());
		// only display the node if it isn't a folder, and if this is a recursive call
		if (children[i].isDirectory() && recursive) { 
			parent.add(node); // add as a child node
			listAllFiles(children[i].getPath(), node, recursive); // call again for the subdirectory
		} else if (!children[i].isDirectory()){ // otherwise, if it isn't a directory
			parent.add(node); // add it as a node and do nothing else
		}
	}
}

/// <summary>
/// A method to populate a TreeView with directories, subdirectories, etc
/// </summary>
/// <param name="dir">The path of the directory</param>
/// <param name="node">The "master" node, to populate</param>
public void PopulateTree(string dir, TreeNode node) {
	// get the information of the directory
	DirectoryInfo directory = new DirectoryInfo(dir);
	// loop through each subdirectory
	foreach(DirectoryInfo d in directory.GetDirectories()) {
		// create a new node
		TreeNode t = new TreeNode(d.Name);
		// populate the new node recursively
		PopulateTree(d.FullName, t);
		node.Nodes.Add(t); // add the node to the "master" node
	} 
	// lastly, loop through each file in the directory, and add these as nodes
	foreach(FileInfo f in directory.GetFiles()) {
		// create a new node
		TreeNode t = new TreeNode(f.Name);
		// add it to the "master"
		node.Nodes.Add(t);
	}
}

#include <string>
bool recursivePalindrome(std::string str, unsigned int index = 0) {
    return (str[index] == str[str.length()-index-1] ? recursivePalindrome(str, ++index) : index > (str.length()/2) ? true : false);
}

#include <string>
// by initialising index to 0 in our parameters, we give it a default value
// however, we can pass our own value later (which is what makes this recursive)
bool recursivePalindrome(std::string str, unsigned int index = 0) {
     // if we reached the half way point, we're good to go
    if (index > str.length()/2) return true;
    // if the character at [index] matches the character [length-index]
    // then we should continue
    else if (str[index] == str[str.length()-index-1])
        return recursivePalindrome(str, ++index);
    else return false; // otherwise, it's not a palindrome
}

int isPalindrome(char* str, int end) {
	if (end<1) { return 1; } // we've passed center, it's true
	if (str[0] != str[end]) { return 0; } // character doesn't match, it fails
	// note, we move the front one, the end one
	// then the end another one, to allow for the front movement
	return isPalindrome(str+1, end-2);
}

void checkPalindrome(char* str) {
	printf("'%s' is ", str);
	if(!isPalindrome(str, strlen(str)-1)) { printf("not "); }
	printf("a palindrome\n");
}

import java.util.*;

public class RecursiveStars
{
	 static Scanner console = new Scanner(System.in);

	public static void main(String[] args)
	{
		int lines;

		System.out.print("Enter the number of lines in the grid: ");
		lines = console.nextInt();
		System.out.println();

		printStars(1, lines);

		System.out.println();
	}

	public static void printStars(int i, int lines)
	{

		int j;

		if(i <= lines)
		{
			for(j = 0; j < lines - i + 1; j++)
				System.out.print(" ");

			for(j = 1; j <= i; j++)
				System.out.print(" *");
			System.out.println();

			printStars(i+1, lines);

			if(i != lines)
			{
				for(j = 0; j < lines - i + 1; j++)
					System.out.print(" ");

				for(j = 1; j <= i; j++)
					System.out.print(" *");
				System.out.println();
			}
		}
	}

#include <iostream>

using namespace std;

float HarmonicSum (int n, float retval = 0.0f) {
    if (n > 0) {
        retval += (1.0f / n);
        return HarmonicSum(--n, retval);
    } else {
        return retval;
    }
}

int main() {
    cout << HarmonicSum(3);
    cin.get();
    return EXIT_SUCCESS;
}

/*
 * A recursive function to remove a directory and it's contents
 * Author: Danny Battison
 * Contact: gabehabe@gmail.com
 */

#include <dirent.h>
#include <string>
using std::string;

bool IsDirectory(char path[]) {
    int i = strlen(path) - 1;
    if (path[strlen(path)] == '.') {return true;} // exception for directories
    // such as \. and \..
    for(i; i >= 0; i--) {
        if (path[i] == '.') return false; // if we first encounter a . then it's a file
        else if (path[i] == '\\' || path[i] == '/') return true; // if we first encounter a \ it's a dir
    }
}

bool RemoveDirectory(string path) {
    if (path[path.length()-1] != '\\') path += "\\";
    // first off, we need to create a pointer to a directory
    DIR *pdir = NULL; // remember, it's good practice to initialise a pointer to NULL!
    pdir = opendir (path.c_str());
    struct dirent *pent = NULL;
    if (pdir == NULL) { // if pdir wasn't initialised correctly
        return false; // return false to say "we couldn't do it"
    } // end if
    char file[256];

    int counter = 1; // use this to skip the first TWO which cause an infinite loop (and eventually, stack overflow)
    while (pent = readdir (pdir)) { // while there is still something in the directory to list
        if (counter > 2) {
            for (int i = 0; i < 256; i++) file[i] = '\0';
            strcat(file, path.c_str());
            if (pent == NULL) { // if pent has not been initialised correctly
                return false; // we couldn't do it
            } // otherwise, it was initialised correctly, so let's delete the file~
            strcat(file, pent->d_name); // concatenate the strings to get the complete path
            if (IsDirectory(file) == true) {
                RemoveDirectory(file);
            } else { // it's a file, we can use remove
                remove(file);
            }
        } counter++;
    }

    // finally, let's clean up
    closedir (pdir); // close the directory
    if (!rmdir(path.c_str())) return false; // delete the directory
    return true;
}

/** EXAMPLE USAGE **/
#include <iostream>
using std::cin;
using std::cout;
int main() {
    RemoveDirectory("C:\\New Folder");
    cin.get();
    return EXIT_SUCCESS;
}

/*
 * Yet another method to reverse a string
 * Author: Danny Battison
 * Contact: gabehabe@gmail.com
 */

#include <stdio.h>
#include <string.h>

char* reverseCharArray(char str[], int pos) {
    int swap = (strlen(str)-1) - pos;

    if (swap < pos) {
        char temp = str[swap];
        str[swap] = str[pos];
        str[pos] = temp;
        return reverseCharArray(str, --pos);
    } else {
        return str;
    }
}

/** EXAMPLE USAGE **/
int main() {
    char str[] = "gabehabe is so freakin' awesome.";
    // remember, because an array is 0 based, we have to pass the length-1
    printf(reverseCharArray(str, strlen(str)-1));
    return 0;
}

/*
 * Yet another method to reverse a string
 * Author: Danny Battison
 * Contact: gabehabe@gmail.com
 */

#include <stdio.h>
#include <string.h>

char* reverseCharArray(char str[], int pos) {
    int swap = (strlen(str)-1) - pos;
    char temp = str[swap]; str[swap] = str[pos]; str[pos] = temp;
    return (swap < pos ? reverseCharArray(str, --pos) : str);
}

/** EXAMPLE USAGE **/
int main() {
    char str[] = "gabehabe is so freakin' awesome.";
    // remember, because an array is 0 based, we have to pass the length-1
    printf(reverseCharArray(str, strlen(str)-1));
    return 0;
}